Know Go - Generics (John Arundel) (Z-Library)

# Know Go: Generics — Reading Guide ## 【One-Line Pitch】 A practical, friendly guide to Go's generics and iterators—type parameters, constraints, and the new iterator pattern—written for working Go developers who want to use these features confidently in real code without a CS degree. ## 【Book Arc】 - **Opening (~0%–9%)**: Sets the stage by explaining why generics matter for modern Go, what generic programming means, and what you'll learn—type parameters, constraints, implementation details, and iterators. Includes a table of contents mapping the full journey from basics to advanced topics. - **Early (~9%–25%)**: Builds the conceptual foundation by contrasting specific programming (fixed types) with polymorphism via interfaces. Shows why interfaces alone fail for operations like `+` or identity functions that must preserve type relationships, motivating the need for type parameters. - **Early–Middle (~25%–38%)**: Introduces generic functions with `[T any]` syntax, composite types (slices, channels, variadic functions), and generic types like `Group[E]`. Then pivots to constraints—why `any` is too loose, and how method-set constraints (like `fmt.Stringer`) give Go enough information to allow operations. - **Middle (~38%–47%)**: Dives into type-set constraints: writing interfaces that list allowed types directly (like `interface { int }`), using `~` for type approximations, handling empty type sets, and the crucial pattern of interface literals that reference type parameters (e.g., `interface{ Equal(T) bool }`). - **Late (~47%–end)**: Covers operations enabled by constraints (arithmetic on numeric types), discusses implementation trade-offs, addresses common questions (compile speed, why not angle brackets), and introduces iterators—`iter.Seq`, `iter.Seq2`, error handling, cleanup, composition, and when iterators beat channels. ## 【Key Takeaways】 - **Interfaces give polymorphism but not type preservation** (Early): An `io.Writer` parameter accepts many concrete types, but you can't write a function that returns the *same* concrete type it received. This limitation motivates generics. - **Type parameters express relationships `any` cannot** (Early): `func Identity[T any](v T) T` guarantees the return type matches the input type—something impossible with `any` or interfaces. Go instantiates a concrete version per type at compile time. - **Constraints are the key to useful generic code** (Middle): Constraining `T` to `any` means you can't add, compare, or call methods. Method-set constraints like `fmt.Stringer` unlock real operations while keeping type safety. - **Type-set constraints allow non-method restrictions** (Middle): `interface { int }` lets you restrict to specific types (not just method holders), enabling arithmetic on generic values. The `~` symbol extends this to derived types like `type MyInt int`. - **Interface literals can reference type parameters** (Middle): `func Contains[T interface{ Equal(T) bool }](s []T, v T) bool` is the *only* way to write constraints where the method signature involves `T` itself—named interfaces can't express this. - **Empty type sets are a real failure mode** (Middle): `interface { int; string }` has no satisfiable types; Go reports "empty type set." Understanding this error helps debug over-constrained generic code. - **Iterators are a new composition tool** (Late): `iter.Seq` and `iter.Seq2` provide a function-based iteration pattern that composes well, handles errors cleanly, and often beats channels for sequential data processing. - **Generics have deliberate limitations** (Late): No parameterized methods, no generic packages, no macros, no union types. Understanding what Go *doesn't* do helps you choose idiomatic alternatives. ## 【Reading Tips】 - **Skim the early interface review** (~10%–16%) if you're comfortable with Go interfaces; it's groundwork for the generics motivation but moves quickly. - **Deep-read the constraints chapters** (~34%–47%): This is the conceptual core. Work through the `Double`, `Contains`, and `StringifyTo` examples by hand—they illustrate the three constraint styles (method set, type set, approximation). - **Do the exercises** (like `Group`, `intish`, `product`): They're confidence-builders that cement syntax and constraint patterns. The test-driven examples show how generics integrate with normal Go testing. - **Pay attention to error messages** (Middle): The book unpacks cryptic errors like "operator + not defined on T" and "empty type set"—learning to read these will save you hours. - **The iterator chapter** (~Late) is practical and standalone; if you're primarily interested in iterators, you can read it after the constraints chapters without losing context. ## 【Coverage Limits】 This guide synthesizes the book's core progression through generics and iterators. The excerpts don't cover the full implementation details of generics in the Go compiler, nor the complete standard library iterator changes—those sections are referenced but not fully excerpted. ##