In Go, what does the `[T any]` in `func Reverse[T any](s []T)` declare, and where can T be used?

## The shape of the declaration A Go generic function puts a **type parameter list** in square brackets between the function name and the ordinary parameter list: ```go func Reverse[T any](s []T) // ^^^^^^^ type parameter list // ^^^^^ ordinary parameter list ``` Every entry in that list is a *name* followed by a *constraint*: `T` is the name, `any` is the constraint. The constraint is mandatory — there is no bare `[T]` — and `any` (an alias for `interface{}` added as a predeclared name in Go 1.18) is the constraint that permits every type. The position matters. The brackets go **after the function name and before the parentheses**. `func [T any] Reverse(...)` and `func Reverse(s []T) [T any]` are both syntax errors, and `Reverse<T>(...)` is another language's spelling. ## What T actually is `T` is not a value and not a variable. It is a **type name** that stands for whatever type the call site supplies. Inside the function it behaves like any other type name: ```go func Reverse[T any](s []T) { for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 { s[i], s[j] = s[j], s[i] } } ``` You can declare variables of type `T`, build `[]T`, `map[string]T`, `chan T` or `*T`, pass `T` values to other generic functions, and name `T` in the result type. The one thing that changes relative to a normal type is that the compiler checks the body against the **constraint**, not against any particular concrete type. With `any` as the constraint, the set of operations available on a `T` value is deliberately tiny: assignment, passing, storing, taking its address. `a == b`, `a + b`, `a < b`, indexing and calling are all rejected, because `any` does not promise that every possible substitution supports them. ## Scope A type parameter is in scope from its declaration in the bracket list through: - the constraints of the other type parameters in the same list, - the ordinary parameter types and the result types, - the entire function body. It is *not* in scope outside the function, so two different functions may each declare a `T` and they are unrelated. Nor does it exist at run time as something you can print or switch on directly; it is a compile-time notion that gets resolved before the program runs. ## Instantiation Writing the function is only half of it. A generic function becomes callable when it is **instantiated** — the compiler substitutes a concrete type argument for `T`. In the common case the type argument comes from the call arguments, so `Reverse(nums)` reads exactly like a call to a non-generic function; you may also write it out, as `Reverse[int](nums)`. Every distinct instantiation is conceptually its own function, and `Reverse[int]` may even be assigned to a variable of function type. An instantiated generic function is a normal function value: ```go rev := Reverse[string] // type: func([]string) rev([]string{"a", "b"}) ``` ## What the compiler emits A frequent interview follow-up is whether Go produces one machine-code copy per type argument. It does not do full monomorphisation, and it does not erase types either. Go's implementation uses **GC-shape stenciling with dictionaries**: types that have the same shape from the garbage collector's point of view (all pointer-shaped types, for instance) share one compiled body, and a hidden dictionary argument carries the per-instantiation details the body needs. The practical consequence for a candidate is simply that generics are neither free in the way erasure is nor as aggressively specialised as C++ templates — but the semantics you reason about are the substitution semantics above. ## Why this beats `interface{}` Before Go 1.18 the only way to write one `Reverse` was `func Reverse(s []interface{})`, which forced callers to copy their slice element by element into a `[]interface{}` and lost the element type on the way out. The type parameter keeps the element type: `Reverse` applied to a `[]int` still deals in `int`, with no boxing and no type assertions, and the compiler rejects a mixed-type call at build time rather than at run time. ## Common mistakes - Putting the bracket list in the wrong place. - Assuming `any` lets the body use `==` or `<`. - Thinking `T` is only usable in the parameter list — it is usable in results and in the body too. - Declaring a type parameter that appears exactly once and is never constrained, which usually means an ordinary `any` parameter would have been simpler.