Generic Types

So far the type parameters have lived on functions. But a type can be generic too. That's how you build reusable containers — stacks, queues, trees, caches — that hold a specific element type without falling back to interface{} and type assertions.

Parameterizing a struct

Put the type parameter list right after the type name:

type Stack[T any] struct {
	items []T
}

Stack is now a generic type. It isn't a usable type by itself — you instantiate it by supplying the argument, and each instantiation is a distinct, fully checked type:

var ints Stack[int]        // items is []int
strs := Stack[string]{}    // items is []string

A Stack[int] and a Stack[string] are unrelated types; you can't accidentally push a string onto the int stack. The [T any] here uses any because the stack only stores and returns values — it never compares or adds them, so it needs nothing more.

Methods use the receiver's parameter

Methods on a generic type name the type parameter in the receiver, then use it freely in the signature and body:

func (s *Stack[T]) Push(v T) {
	s.items = append(s.items, v)
}

Two rules to internalize:

• The receiver is *Stack[T] (or Stack[T]) — you repeat the parameter name so the method can refer to T.
• A method cannot introduce new type parameters of its own. It works only with the ones the type already declares. (If you need a fresh parameter — say a Map that changes element type — that has to be a free function, not a method.)

The zero value of T

Sometimes a method must produce a T out of nothing — for example, what does Pop return when the stack is empty? You can't invent a value, but every type has a zero value:

func (s *Stack[T]) Pop() (T, bool) {
	if len(s.items) == 0 {
		var zero T
		return zero, false
	}
	last := len(s.items) - 1
	v := s.items[last]
	s.items = s.items[:last]
	return v, true
}

Returning (T, bool) is the idiomatic "value plus ok" shape — the caller checks the bool rather than trusting a possibly-zero value. var zero T gives the correct empty result whether T is int (0), string (""), or a struct.

Why Go does it this way

Before generic types, a general-purpose stack meant []interface{}: every Push boxed the value and every Pop needed a type assertion that could panic at run time. A Stack[T] erases none of that type information — the element type is baked into the instantiation, the compiler checks every call, and there's zero boxing or asserting. You write the data structure once and reuse it at any element type with full safety. In the exercise you'll finish exactly this stack: Push, Pop, and Len, tested at both int and string.