Interfaces & Type Identity

An interface is a type defined by a method set. Any concrete type that has those methods satisfies the interface implicitly: there is no implements keyword and no explicit declaration. An interface value holds a (dynamic type, value) pair. The empty interface interface{} / any is satisfied by every type, and interfaces give Go its polymorphism and decoupling.

A type assertion x.(T) checks the interface's dynamic type and extracts the concrete value; the single-result form panics on mismatch, while the comma-ok form v, ok := x.(T) reports failure via ok instead. A type switch switch v := x.(type) dispatches on the dynamic type across several cases at once.

Comparable types support ==: booleans, numerics, strings, pointers, channels, interfaces, and structs/arrays whose every field is comparable. slices, maps, and functions are NOT comparable — only to nil — so cannot be map keys, which must be comparable.

Type mismatch. Set stores a value: s.cache.Put(wh.Id, *wh) dereferences the pointer, so the cached dynamic type is warehouse.Warehouse. But Get asserts a pointer: item.(*warehouse.Warehouse). That assertion never succeeds, so Get always falls through to return nil and the cache never hits. Fix: store and assert the same type — store wh, assert *warehouse.Warehouse.

Declare the interface in the consumer package — where the value is used, not where it is implemented. Because Go satisfies interfaces implicitly (duck typing), the consumer defines exactly the small method set it needs. This decouples the consumer from concrete types and makes it trivial to swap in a mock in tests. Implementations need not import the interface.

An interface value is two words. For an interface with methods (iface) the first word points to an itab — pairing the concrete type with its method set — and the second to the data. For the empty interface any (eface) the first word is just a *_type descriptor, the second the data pointer.

A pointer-receiver method is just a function taking the pointer as its first argument, so calling it on a nil pointer is legal as long as the body never dereferences that pointer. hello only prints a constant and never touches g.name, so it runs fine. Accessing g.name would panic with a nil dereference.

It prints true and p. Structs are comparable with == when every field is comparable (no slices/maps/funcs), comparing field by field. Because a == b, they hash to the same map key, so m[b] finds the value under a. If point held a slice field, both the == and the map-key use would fail to compile.

An interface equals nil only when both of its words are zero. Assigning a nil *T pointer sets the type word to *T while the data word stays nil — the interface is now a non-nil "typed nil". The classic trap is returning such a value from a function whose result type is an interface.

It prints i is nil then i value is nil — two lines. After i = t with t a nil *Type, the interface holds type word *Type and nil data, so i == nil is false and that branch is skipped. But i.(*Type) extracts the underlying pointer, which is nil, so that compares true. After t = &Type{} the pointer is non-nil, so the final branch is skipped.

Generics let you write one type-safe implementation that works over many types, checked at compile time. The old alternative — interface{} — loses static type safety: it needs runtime type assertions, boxes values (extra allocations), and pushes type errors to runtime. Generics also cut the copy-paste of writing the same function per concrete type.

An interface call indirects through the itab — a per (interface, concrete type) pair holding the concrete *_type plus a slice of function pointers for the method set. The call loads the target from that table and jumps: a small, predictable cost, not free, and not devirtualized in the general case.

Since Go 1.18 a function or type declares type parameters in square brackets, [T Constraint]. A constraint is an interface that may list a method set and/or a type union; comparable is a common one. The compiler instantiates generic code via GC-shape stenciling with dictionaries, not pure per-type monomorphization.