Know Go Interfaces, Generics, and Iterators (John Arundel)（Z-Library）

【One-Line Pitch】 A focused, practical guide to the three features that define modern Go—interfaces, generics, and iterators—for developers who already write Go and want to understand type parameters, constraints, and sequence functions well enough to use them correctly. 【Book Arc】 - **Opening (~0%–10%)**: Frames the problem: interfaces give flexibility but can't express operators like `+`, and `any` is too broad to compute with—setting up why generics exist. - **Early (~10%–30%)**: Introduces type parameters, instantiation and inference, the "stencilling" compilation model, and the core constraint toolkit—method sets, named types, unions, and approximations. - **Middle (~30%–50%)**: Moves into operations and types: arithmetic and ordered constraints, `cmp.Ordered`, `comparable`, multiple type parameters, generic slices/maps/structs, and the limits of methods and self-reference. - **Late (~50%–70%)**: Applies generics to real utility code—generic `Contains`, `Dupes`, and container helpers—showing what was painful or impossible before generics. - **Ending (~70%–100%)**: Covers iterators (`iter.Seq`, `iter.Seq2`, error handling, cleanup), plus a candid discussion of generics' downsides and what Go still lacks (option types, enums, parameterised methods). 【Key Takeaways】 - **Interfaces describe behavior, not data** (Opening): A function taking `io.Writer` promises to call `Write`, so Go rejects types lacking that method—flexibility comes from many concrete types satisfying one contract. - **`any` is too weak to compute with** (Opening): You can assign and return `any` values, but operators like `+` and `==` aren't defined on all types, so broad constraints buy flexibility at the cost of usable operations. - **Constraints are the heart of generics** (Early): Method sets, named-type unions, and approximations (`~int`) progressively narrow the type set until the operations you need are legal; an over-narrow union can even produce an empty, unsatisfiable type set. - **Generics are stencilled, not boxed** (Early): Each instantiation produces concrete code with no interface indirection, which is why generic code can be efficient—and why there's no such thing as an uninstantiated `Identity[T]`. - **Type inference usually saves you brackets** (Early): Go infers `T` from arguments in most calls; explicit instantiation like `Something[int]()` is the fallback when inference fails. - **Derived types can surprise you** (Middle): A generic `Identity[[]E]` returning a `StringList` argument may hand back a plain `[]string`, because the function is instantiated on the underlying slice type—a subtle trap worth internalizing. - **Methods cannot have type parameters** (Middle): Generic methods are disallowed, and self-referential instantiation is blocked because only concrete instantiations exist—shaping how you design generic types. - **Iterators standardize traversal** (Ending): `iter.Seq` and `iter.Seq2` give one function signature for ranging over sequences, with patterns for propagating errors and cleaning up resources. 【Reading Tips】 - **Skim the interface recap, deep-read constraints**: If you already know Go interfaces, move quickly to the constraint chapters—unions, approximations, and `comparable` are where the real learning is. - **Do the exercises**: The book is exercise-driven (`Len`, `Intish`, `Dupes`, `Greater`); attempting them before reading solutions is where the constraint intuition sticks. - **Watch the edge cases**: Pay special attention to derived slice types, empty type sets, and the "methods can't have type parameters" rule—these are the traps that bite in real code. - **Treat the downsides chapter as design guidance**: The discussion of missing features (no enums, option types, parameterised methods) helps you decide when generics are the right tool and when they aren't. 【Coverage Limits】 The excerpts cover the book's structure and core themes but do not include full chapter text, so specific code listings, iterator cleanup details, and later-chapter depth are only partially represented here.