Know Go (John Arundel)（Z-Library）

# Know Go: A Comprehensive Guide to Go Generics and Iterators ## 【One-Line Pitch】 A practical, hands-on guide for Go developers who want to master generics and iterators—the language's most significant additions since its inception—covering everything from basic type parameters to advanced constraint design, with plenty of exercises to cement your understanding. ## 【Book Arc】 - **Opening (~0%–10%)**: Introduces the problem generics solve—the limitations of interfaces, type assertions, and type switches for writing truly polymorphic functions—and sets up why Go needed generics despite its simplicity-first philosophy. - **Early (~10%–23%)**: Covers the fundamentals of type parameters, generic functions, and generic types, including the crucial distinction between compile-time generics and runtime behavior, with exercises building confidence through practical implementation. - **Early-Middle (~23%–39%)**: Dives deep into constraints—the heart of Go generics—exploring method set constraints, type elements, interface literals, type approximations, and the critical difference between constraints and classes. - **Middle (~39%–48%)**: Explores advanced constraint patterns including ordered types, the cmp.Ordered constraint, multiple type parameters, and the comparable constraint, plus the elegant solution to the "infinitely many comparable types" problem. - **Late (~48%–70%)**: Covers abstract types, container types (sets, key-value stores, caches), and practical applications like the Greatest function, plus the standard library's cmp, slices, and maps packages. - **Ending (~70%–100%)**: Addresses the big questions: performance implications, whether to change existing code, why angle brackets weren't used, and what's still missing (like option types), concluding with new idioms for common operations. ## 【Key Takeaways】 - **Generics solve real polymorphism problems** (Early): Interfaces alone can't express constraints like "supports the + operator" or "returns the same type it receives"—generics fill this gap without sacrificing Go's simplicity. - **Type parameters are compile-time only** (Early): There are no generic types at runtime; you're always working with concrete types like []int or []string, which means no runtime overhead from abstraction. - **Constraints are not classes** (Early-Middle): Unlike class hierarchies in other languages, Go constraints define type sets, not inheritance relationships—you can't instantiate on a constraint interface. - **Type approximations (~) are essential** (Early-Middle): When working with derived types, you need the ~ symbol to include types based on the same underlying type, not just the exact type itself. - **The comparable constraint is predeclared for good reason** (Middle): The set of comparable types is infinite (structs, channels, arrays, interfaces), making it impossible to express as a type set—hence the special language support. - **Standard library packages (cmp, slices, maps) are generics-first** (Late): These packages provide ordered constraints, slice manipulation, and map operations that work across all types, eliminating the need for type-specific utilities. - **Generics don't require rewriting existing code** (Ending): The feature is additive—your existing Go code works unchanged, and you can adopt generics incrementally where they provide clear value. ## 【Reading Tips】 - **Work through every exercise**: The book is built around hands-on exercises (Group therapy, Lengthy proceedings, StringifyTo, IsGreater, etc.)—these are where the concepts click, not in the prose. - **Pay special attention to the constraint chapters (3 and 4)**: This is where most confusion arises; the distinction between type sets, approximations, and method sets is subtle but crucial. - **Skim the standard library chapters if you're experienced**: The cmp, slices, and maps package coverage is useful but largely reference material—focus on the idioms section for practical patterns. - **Read the final Questions chapter early if you're skeptical**: If you're wondering whether generics are worth learning or will change your workflow, the answers to "How much do I need to know?" and "Do I need to change my existing code?" will set your mind at ease. - **Keep the Go documentation handy**: The book references standard library constraints like cmp.Ordered and comparable—having the official docs open will help you verify and extend what you learn. ## 【Coverage Limits】 This guide covers the generics portion of the book comprehensively; the iterators content (mentioned in the introduction) is not covered in the sampled excerpts. Performance benchmarks and detailed compiler internals are also not covered in the available material. ##