How do you declare a generic type such as `type Cache[K comparable, V any] struct`, and what must its methods repeat?

## Declaring the type A generic type declaration is an ordinary `type` declaration with a type parameter list wedged between the name and the definition: ```go type entry[V any] struct { value V hits int } type Cache[K comparable, V any] struct { entries map[K]*entry[V] order []K // least-recently-used first } ``` Two things are worth spelling out here. First, `K` and `V` are in scope for the *entire* definition — every field, every embedded type, every nested instantiation. Second, when the definition names another generic type it must instantiate it: the field is `map[K]*entry[V]`, never `map[K]*entry`. A generic type name on its own is not a type. `K` is constrained by `comparable` here only because it is used as a map key and map keys must support `==`; the interesting part for this discussion is the *shape* of the declaration, not that particular constraint. ## Methods must redeclare the parameters on the receiver Methods on a generic type are declared the usual way, except that the receiver names the type parameters: ```go func (c *Cache[K, V]) Put(k K, v V) { c.entries[k] = &entry[V]{value: v} c.order = append(c.order, k) } func (c *Cache[K, V]) Get(k K) (V, bool) { e, ok := c.entries[k] if !ok { var missing V return missing, false } e.hits++ return e.value, true } ``` The identifiers in `Cache[K, V]` on the receiver are **declarations**, not references back to the type declaration. They are matched by position, so their spelling is yours to choose: ```go func (c *Cache[Key, Val]) Len() int { return len(c.entries) } ``` compiles exactly as well, with `Key` bound to the first parameter and `Val` to the second. The count must match the type's parameter list, and you may not add constraints on the receiver — the constraints live on the type declaration and are simply inherited. In practice teams keep the same names across the type and all its methods, because reading a file where every method renames the parameters is miserable. ## Every instantiation is its own type `Cache[string, []byte]` is a defined type in its own right. So is `Cache[string, int]`. They share source but nothing else: - they are **not assignable** to one another, and no conversion between them exists; - each has its own method set, with `K` and `V` resolved; - each has its own zero value, its own layout, its own `%T` output. This is the property that makes a generic container safe: a `Cache[string, []byte]` cannot accidentally receive an `int`, and there is no place where the compiler quietly widens one instantiation into another. ## Recursion is fine A generic type may refer to itself as long as it does so with its own type parameters: ```go type node[K comparable, V any] struct { key K val V next *node[K, V] } ``` That is the ordinary recursive-struct rule; the instantiation `node[K, V]` inside the definition is the same instantiation as the one being defined, so there is nothing infinite about it. ## Where it usually goes wrong when reading a codebase Someone new to a generic package tends to hit three things in order: 1. They write `var c Cache` and get a compile error, because a generic type name needs type arguments before it is a type. 2. They add a method and forget the receiver's bracket list — `func (c *Cache) Len() int` — and are told the receiver is a generic type without instantiation. 3. They try to write `func (c *Cache[string, []byte]) Len() int`, putting *type arguments* on a receiver. The receiver declares parameters; it cannot pin them. If you want a method that only exists for one instantiation, write a plain function taking `*Cache[string, []byte]` instead. ## Constructors Because a generic type never infers its own type arguments, most packages export a constructor function, which *can* have its arguments inferred at the call site in the usual way: ```go func NewCache[K comparable, V any](capacity int) *Cache[K, V] { return &Cache[K, V]{entries: make(map[K]*entry[V], capacity)} } ``` Note that this particular constructor still has to be called as `NewCache[string, []byte](128)`, since nothing in its argument list mentions `K` or `V`. Where a constructor does take a value of the element type, the call reads like any other Go call.