Generics

Why This Matters - The Foundation of Type-Safe Reusability

When building a library that needs to work with different data types, developers before Go 1.18 faced an impossible choice: either write duplicate code for each type, lose type safety with interface{}, or maintain complex code generation tools. Go 1.18 generics changed everything.

The Real-World Impact:

• Kubernetes eliminated 50+ duplicate max(a, b) functions across their codebase
• Docker replaced separate StringSlice, IntSlice, Float64Slice types with one generic implementation
• Your code can now be both flexible AND safe, without runtime panics

💡 Key Takeaway: Generics are your superpower for writing code that adapts to any type while maintaining compile-time safety and zero runtime overhead.

Learning Objectives

By the end of this article, you will be able to:

• Write generic functions and types with type parameters and constraints
• Understand when to use generics vs interfaces vs code generation
• Apply generic constraints for building type-safe data structures
• Master advanced patterns like constraint composition and type inference
• Build production-ready generic libraries used in real Go projects

Core Concepts - Understanding the Foundation

Type Parameters: The Blueprint

Type parameters are the heart of generics. They let you write functions that work with any type while maintaining type safety.

 1package main
 2
 3import "fmt"
 4
 5// Basic generic function with type parameter T
 6func Identity[T any](value T) T {
 7    return value  // Returns the same type it received
 8}
 9
10func main() {
11    // Type inference: compiler automatically determines T
12    fmt.Println(Identity(42))        // Works with int
13    fmt.Println(Identity("hello"))    // Works with string
14    fmt.Println(Identity(3.14))     // Works with float64
15
16    // Explicit type specification
17    result := Identity[string]("generic")
18    fmt.Println(result)
19}
20// run

What's Happening:

• [T any] declares a type parameter T that can be any type
• The compiler generates specialized versions for each type used
• Type is preserved throughout - int stays int, no casting needed

Type Constraints: Setting the Rules

Constraints tell generics what operations are allowed on type parameters. Think of them as contracts.

 1package main
 2
 3import "fmt"
 4
 5// Built-in constraints
 6func Compare[T comparable](a, b T) bool {
 7    return a == b  // Works with any type that supports ==
 8}
 9
10// Union constraint
11func Sum[T int | float64](a, b T) T {
12    return a + b  // Works with int OR float64
13}
14
15// Custom constraint
16type Number interface {
17    int | int64 | float32 | float64
18}
19
20func Max[T Number](a, b T) T {
21    if a > b {
22        return a
23    }
24    return b
25}
26
27func main() {
28    fmt.Println(Compare("hello", "world"))  // false
29    fmt.Println(Compare(5, 5))              // true
30    fmt.Println(Sum(5, 7))                  // 12
31    fmt.Println(Sum(3.14, 2.86))            // 6.00
32    fmt.Println(Max(5, 10))                 // 10
33    fmt.Println(Max(3.14, 2.71))            // 3.14
34}
35// run

Key Constraint Types:

• any: No restrictions
• comparable: Types supporting == and !=
• Union types: int | float64
• Custom interfaces: Define your own constraints

Real-World Impact:

Type Safety Without Duplication:

• Kubernetes had 50+ duplicate implementations of max(a, b int) across the codebase
• Docker maintained separate StringSlice, IntSlice, Float64Slice types for sorting
• After generics: One Max[T Ordered](a, b T) replaces hundreds of lines

Performance Without interface{}:

 1// Before generics: Boxing/unboxing overhead
 2func Sum(values []interface{}) int {
 3    sum := 0
 4    for _, v := range values {
 5        sum += v.(int)  // Runtime type assertion = slow
 6    }
 7    return sum
 8}
 9
10// After generics: Zero-overhead abstraction
11func SumGeneric[T int | int64](values []T) T {
12    var sum T
13    for _, v := range values {
14        sum += v  // Compile-time type checking = fast
15    }
16    return sum
17}
18
19// Benchmark results:
20// ├─ interface{} version:  45ms
21// └─ Generic version:      12ms

Eliminates Code Generation:

• Before: go generate + stringer, mockgen, etc. = complex build process
• After: Generic Option[T], Result[T, E] types = simple, maintainable code

Go Generics vs Other Languages

Language	Go 1.18+	Java	C++	Rust	TypeScript
Compile-time type checking	✅	✅	✅	✅	❌
Zero runtime overhead	✅	❌	✅	✅	❌
Type inference	✅ Strong	⚠️ Limited	⚠️ Complex	✅ Strong	✅ Strong
Constraint syntax	Interface-based	Interface-based	SFINAE	Trait-based	Structural typing
Learning curve	Easy	Medium	Hard	Medium	Easy
Code bloat	✅ Monomorphization	❌	⚠️	⚠️	N/A

Why Go's Generics Design is Different:

1. Interface-based constraints - Natural extension of existing Go interfaces
2. No covariance/contravariance - Simpler mental model
3. No operator overloading - Constraints must be explicit
4. No specialization - One generic function = one implementation

Real-World Use Cases from Production Systems

1. HashiCorp's Terraform - Generic resource management:

1// Before: Separate types for AWS, GCP, Azure resources
2type AWSResource struct { /* fields */ }
3type GCPResource struct { /* fields */ }
4// 50+ more resource types...
5
6// After: Single generic resource manager
7type ResourceManager[T Resource] struct {
8    resources map[string]T
9}

2. Uber's Go Style Guide - Generic collections:

 1// Before: sync.Map with interface{} = runtime panics
 2var cache sync.Map
 3cache.Store("key", 42)
 4val, _ := cache.Load("key")
 5num := val.(int)  // Can panic at runtime!
 6
 7// After: Type-safe generic cache
 8type Cache[K comparable, V any] struct { /* impl */ }
 9cache := NewCache[string, int]()
10cache.Store("key", 42)
11num := cache.Load("key")  // Compile-time safety

3. Prometheus Client Library - Generic metrics:

1// Generic gauge for any numeric type
2type Gauge[T int | int64 | float32 | float64] struct {
3    value T
4}

When to Use Generics: The Golden Rules

Think of generics as a powerful tool that solves specific problems. Just like you wouldn't use a sledgehammer to crack a nut, you shouldn't use generics everywhere.

Real-world Example:
Consider building a library system where you need to catalog books, movies, and music albums. Each has an ID, title, and metadata, but different internal structures.

 1// Without generics: Three separate, nearly identical functions
 2func FindBook(books []Book, id string) *Book { /* duplicate code */ }
 3func FindMovie(movies []Movie, id string) *Movie { /* duplicate code */ }
 4func FindAlbum(albums []Album, id string) *Album { /* duplicate code */ }
 5
 6// With generics: One function handles everything
 7func FindItem[T any](items []T, id string, getId func(T) string) *T {
 8    for _, item := range items {
 9        if getId(item) == id {
10            return &item
11        }
12    }
13    return nil
14}

✅ Use Generics For:

• Data structures: Stack, Queue, Tree, Graph, Cache, Pool
• Functional utilities: Map, Filter, Reduce, Find, Contains
• Type-safe wrappers: Option[T], Result[T, E], Future[T]
• Generic algorithms: Sort, Search, Binary tree operations
• API clients: Generic HTTP client with typed responses

❌ Avoid Generics For:

• Single-use code: If only used with one type, don't genericize
• Interface-solvable problems: io.Reader works fine without generics
• Over-abstraction: Don't make code harder to read for marginal reuse
• Premature optimization: Wait for duplication before adding generics

⚠️ Important: Generics should make code simpler, not more complex. If your generic code is harder to understand than the duplicated version, step back and reconsider.

Decision Tree:

Do you have code duplication across types?
├─ No → Don't use generics yet
└─ Yes
    ├─ Can interfaces solve it?
    │   ├─ Yes → Use interfaces
    │   └─ No → Continue
    └─ Do you need type safety at compile time?
        ├─ No → interface{} might be okay
        └─ Yes → ✅ USE GENERICS

Why Generics? The Three-Headed Monster

Before generics, Go developers faced a painful three-headed monster. Imagine you need to find the maximum value in different types of collections:

1// Head 1: Code Duplication Monster
2func MaxInt(a, b int) int { if a > b { return a }; return b }
3func MaxFloat64(a, b float64) float64 { if a > b { return a }; return b }
4func MaxString(a, b string) string { if a > b { return a }; return b }
5// ... 20 more duplicate functions for different types!

 1// Head 2: Type Safety Monster
 2func Max(values []interface{}) interface{} {
 3    max := values[0]
 4    for _, v := range values[1:] {
 5        // Runtime panic waiting to happen!
 6        if v.(int) > max.(int) {  // What if it's not an int?
 7            max = v
 8        }
 9    }
10    return max
11}

1// Head 3: Build Complexity Monster
2//go:generate go run max_generator.go -type=int
3//go:generate go run max_generator.go -type=float64
4//go:generate go run max_generator.go -type=string
5// Now maintain complex build scripts and generated code!

💡 Generics slay all three monsters with one elegant solution that gives you:

• Zero duplication
• Full type safety
• Simple builds

Let's see how this magic works...

Basic Generic Functions

Simple Generic Function: Your First Taste of Magic

Let's start with a simple yet powerful example. Imagine you want to print any value along with its type information.

 1package main
 2
 3import "fmt"
 4
 5// Generic function that works with any type
 6func Print[T any](value T) {
 7    fmt.Printf("Value: %v, Type: %T\n", value, value)
 8}
 9
10func main() {
11    Print(42)        // works with int
12    Print("hello")   // works with string
13    Print(3.14)      // works with float64
14    Print(true)      // works with bool
15}
16// run

What's Happening Under the Hood:

Think of [T any] as a placeholder that says "I'll accept any type you give me." When you call Print(42), the compiler silently creates a specialized version:

 1// Compiler generates this automatically:
 2func Print_int(value int) {
 3    fmt.Printf("Value: %v, Type: %T\n", value, value)
 4}
 5
 6// And this:
 7func Print_string(value string) {
 8    fmt.Printf("Value: %v, Type: %T\n", value, value)
 9}
10
11// And so on for each type you use...

💡 Key Takeaway: The compiler does the heavy lifting at compile time, creating optimized versions for each type. This means:

• Zero runtime overhead
• Full type safety
• Clean, readable code

Common Pitfalls to Avoid:

❌ Don't overthink the syntax: [T any] just means "any type T"
✅ Focus on the pattern: One function, many types

❌ Don't confuse with interface{}: Generics keep type information
✅ Remember: No runtime type casting needed

Multiple Type Parameters

 1package main
 2
 3import "fmt"
 4
 5func Pair[T any, U any](first T, second U) {
 6    fmt.Printf("First: %v (%T), Second: %v (%T)\n", first, first, second, second)
 7}
 8
 9func main() {
10    Pair(1, "one")
11    Pair("hello", 42)
12    Pair(3.14, true)
13}
14// run

Generic Return Values

 1package main
 2
 3import "fmt"
 4
 5func First[T any](slice []T) T {
 6    if len(slice) == 0 {
 7        var zero T
 8        return zero // Return zero value
 9    }
10    return slice[0]
11}
12
13func main() {
14    nums := []int{1, 2, 3}
15    fmt.Println(First(nums)) // 1
16
17    words := []string{"hello", "world"}
18    fmt.Println(First(words)) // hello
19
20    empty := []float64{}
21    fmt.Println(First(empty)) // 0
22}
23// run

Type Constraints - Setting the Rules of the Game

Think of type constraints like a bouncer at a club. The bouncer doesn't let just anyone in—they have to meet certain criteria. Similarly, type constraints tell your generic functions what types are allowed to "enter."

Real-world Example:
When building a calculator, you want to add numbers but prevent someone from trying to "add" two strings together. Type constraints are your safety net.

Built-in Constraints: The Club's Basic Rules

 1package main
 2
 3import "fmt"
 4
 5// any is like saying "everyone's welcome" - no restrictions
 6func PrintAny[T any](v T) {
 7    fmt.Println(v)
 8}
 9
10// comparable is like requiring "must have ID to enter"
11// Only types that can be compared with == and != are allowed
12func Equal[T comparable](a, b T) bool {
13    return a == b
14}
15
16func main() {
17    fmt.Println(Equal(5, 5))         // true - numbers can be compared
18    fmt.Println(Equal("hi", "bye"))  // false - strings can be compared
19    fmt.Println(Equal(3.14, 3.14))   // true - floats can be compared
20
21    // This would fail to compile - slices can't be compared!
22    // Equal([]int{1}, []int{1}) // ERROR: []int doesn't satisfy comparable
23}
24// run

⚠️ Important: Not all types can be compared! Slices, maps, and functions can't use == because there's no clear definition of what "equal" means for complex data structures.

Union Constraints: The VIP List

Union constraints are like creating a VIP list for your function. You specify exactly which types are allowed, and the bouncer turns away everyone else.

 1package main
 2
 3import "fmt"
 4
 5// Only accepts int or float64 - like a VIP list with just two names
 6func Sum[T int | float64](a, b T) T {
 7    return a + b
 8}
 9
10func main() {
11    fmt.Println(Sum(5, 10))        // 15 - int is on the VIP list
12    fmt.Println(Sum(3.14, 2.86))   // 6.00 - float64 is also on the list
13
14    // This would fail to compile - string is not on the VIP list!
15    // Sum("hello", "world") // ERROR: string doesn't satisfy int | float64
16}
17// run

Real-world Example:
Think about a payment processing system. You might want to accept different numeric types but reject everything else:

1// Payment processor that accepts whole dollars or precise amounts
2func ProcessPayment[T int | float64](amount T) string {
3    return fmt.Sprintf("Processing payment: $%v", amount)
4}
5
6// ProcessPayment(100)     // $100 whole dollars
7// ProcessPayment(99.99)   // $99.99 precise amount
8// ProcessPayment("free") // ERROR: Can't process "free" as payment!

💡 Key Takeaway: Union constraints give you precise control over which types are allowed, making your code safer and more predictable.

Custom Constraints

 1package main
 2
 3import "fmt"
 4
 5// Define a custom constraint
 6type Number interface {
 7    int | int64 | float32 | float64
 8}
 9
10func Min[T Number](a, b T) T {
11    if a < b {
12        return a
13    }
14    return b
15}
16
17func Max[T Number](a, b T) T {
18    if a > b {
19        return a
20    }
21    return b
22}
23
24func main() {
25    fmt.Println(Min(5, 10))          // 5
26    fmt.Println(Max(3.14, 2.86))     // 3.14
27    fmt.Println(Min(int64(100), int64(200))) // 100
28}
29// run

Constraint with Methods

 1package main
 2
 3import (
 4    "fmt"
 5)
 6
 7// Constraint requiring a String() method
 8type Stringer interface {
 9    String() string
10}
11
12func PrintString[T Stringer](v T) {
13    fmt.Println(v.String())
14}
15
16type Person struct {
17    Name string
18    Age  int
19}
20
21func (p Person) String() string {
22    return fmt.Sprintf("%s (age %d)", p.Name, p.Age)
23}
24
25func main() {
26    p := Person{Name: "Alice", Age: 30}
27    PrintString(p) // Alice (age 30)
28}
29// run

Generic Types

Generic Slice

 1package main
 2
 3import "fmt"
 4
 5type Stack[T any] struct {
 6    items []T
 7}
 8
 9func (s *Stack[T]) Push(item T) {
10    s.items = append(s.items, item)
11}
12
13func (s *Stack[T]) Pop() (T, bool) {
14    if len(s.items) == 0 {
15        var zero T
16        return zero, false
17    }
18
19    item := s.items[len(s.items)-1]
20    s.items = s.items[:len(s.items)-1]
21    return item, true
22}
23
24func (s *Stack[T]) Peek() (T, bool) {
25    if len(s.items) == 0 {
26        var zero T
27        return zero, false
28    }
29    return s.items[len(s.items)-1], true
30}
31
32func (s *Stack[T]) IsEmpty() bool {
33    return len(s.items) == 0
34}
35
36func main() {
37    // Integer stack
38    intStack := Stack[int]{}
39    intStack.Push(1)
40    intStack.Push(2)
41    intStack.Push(3)
42
43    if val, ok := intStack.Pop(); ok {
44        fmt.Println("Popped:", val) // 3
45    }
46
47    // String stack
48    strStack := Stack[string]{}
49    strStack.Push("hello")
50    strStack.Push("world")
51
52    if val, ok := strStack.Pop(); ok {
53        fmt.Println("Popped:", val) // world
54    }
55}
56// run

Generic Map

 1package main
 2
 3import "fmt"
 4
 5type Cache[K comparable, V any] struct {
 6    data map[K]V
 7}
 8
 9func NewCache[K comparable, V any]() *Cache[K, V] {
10    return &Cache[K, V]{
11        data: make(map[K]V),
12    }
13}
14
15func (c *Cache[K, V]) Set(key K, value V) {
16    c.data[key] = value
17}
18
19func (c *Cache[K, V]) Get(key K) (V, bool) {
20    val, exists := c.data[key]
21    return val, exists
22}
23
24func (c *Cache[K, V]) Delete(key K) {
25    delete(c.data, key)
26}
27
28func main() {
29    // String -> Int cache
30    cache1 := NewCache[string, int]()
31    cache1.Set("age", 30)
32    cache1.Set("year", 2024)
33
34    if val, ok := cache1.Get("age"); ok {
35        fmt.Println("Age:", val)
36    }
37
38    // Int -> String cache
39    cache2 := NewCache[int, string]()
40    cache2.Set(1, "one")
41    cache2.Set(2, "two")
42
43    if val, ok := cache2.Get(1); ok {
44        fmt.Println("Value:", val)
45    }
46}
47// run

Generic Methods

 1package main
 2
 3import "fmt"
 4
 5type Container[T any] struct {
 6    value T
 7}
 8
 9func (c *Container[T]) Set(v T) {
10    c.value = v
11}
12
13func (c *Container[T]) Get() T {
14    return c.value
15}
16
17// Generic method on generic type
18func (c *Container[T]) Transform[U any](fn func(T) U) Container[U] {
19    return Container[U]{value: fn(c.value)}
20}
21
22func main() {
23    c := Container[int]{value: 42}
24    fmt.Println(c.Get()) // 42
25
26    // Transform int to string
27    strContainer := c.Transform(func(i int) string {
28        return fmt.Sprintf("Number: %d", i)
29    })
30    fmt.Println(strContainer.Get()) // Number: 42
31}
32// run

Common Generic Functions

Map Function

 1package main
 2
 3import "fmt"
 4
 5func Map[T any, U any](slice []T, fn func(T) U) []U {
 6    result := make([]U, len(slice))
 7    for i, v := range slice {
 8        result[i] = fn(v)
 9    }
10    return result
11}
12
13func main() {
14    nums := []int{1, 2, 3, 4, 5}
15
16    // Square all numbers
17    squared := Map(nums, func(n int) int {
18        return n * n
19    })
20    fmt.Println(squared) // [1 4 9 16 25]
21
22    // Convert to strings
23    strs := Map(nums, func(n int) string {
24        return fmt.Sprintf("num_%d", n)
25    })
26    fmt.Println(strs) // [num_1 num_2 num_3 num_4 num_5]
27}
28// run

Filter Function

 1package main
 2
 3import "fmt"
 4
 5func Filter[T any](slice []T, predicate func(T) bool) []T {
 6    result := []T{}
 7    for _, v := range slice {
 8        if predicate(v) {
 9            result = append(result, v)
10        }
11    }
12    return result
13}
14
15func main() {
16    nums := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
17
18    // Get even numbers
19    evens := Filter(nums, func(n int) bool {
20        return n%2 == 0
21    })
22    fmt.Println(evens) // [2 4 6 8 10]
23
24    // Get numbers greater than 5
25    greaterThan5 := Filter(nums, func(n int) bool {
26        return n > 5
27    })
28    fmt.Println(greaterThan5) // [6 7 8 9 10]
29}
30// run

Reduce Function

 1package main
 2
 3import "fmt"
 4
 5func Reduce[T any, U any](slice []T, initial U, fn func(U, T) U) U {
 6    result := initial
 7    for _, v := range slice {
 8        result = fn(result, v)
 9    }
10    return result
11}
12
13func main() {
14    nums := []int{1, 2, 3, 4, 5}
15
16    // Sum
17    sum := Reduce(nums, 0, func(acc, n int) int {
18        return acc + n
19    })
20    fmt.Println("Sum:", sum) // 15
21
22    // Product
23    product := Reduce(nums, 1, func(acc, n int) int {
24        return acc * n
25    })
26    fmt.Println("Product:", product) // 120
27
28    // Concatenate strings
29    words := []string{"Hello", "World", "Go"}
30    sentence := Reduce(words, "", func(acc, word string) string {
31        if acc == "" {
32            return word
33        }
34        return acc + " " + word
35    })
36    fmt.Println(sentence) // Hello World Go
37}
38// run

Generics vs Reflection - The Superhero Comparison

Both generics and reflection give you special powers, but they're like different superheroes with different abilities:

🦸 Generics:

• Superpower: Lightning-fast compile-time type safety
• Specialty: Write once, use many times with zero runtime cost
• Weakness: Only works with types you know about beforehand

🦸‍♂️ Reflection:

• Superpower: See and modify anything at runtime
• Specialty: Handle unknown types, inspect structures, magical flexibility
• Weakness: Slower runtime performance

Real-World Decision Matrix

 1// Use GENERICS when: You know the types and care about performance
 2func FindMax[T constraints.Ordered](slice []T) T {
 3    max := slice[0]
 4    for _, v := range slice[1:] {
 5        if v > max { max = v }
 6    }
 7    return max
 8}
 9
10// Use REFLECTION when: You need to handle unknown structures
11func PrintStructFields(obj interface{}) {
12    v := reflect.ValueOf(obj)
13    for i := 0; i < v.NumField(); i++ {
14        fmt.Printf("%s: %v\n", v.Type().Field(i).Name, v.Field(i).Interface())
15    }
16}

Quick Decision Guide

Need to handle unknown types at runtime?
├─ Yes → ✅ REFLECTION
└─ No → Is performance critical?
    ├─ Yes → ✅ GENERICS
    └─ No → Is this a library/framework?
        ├─ Yes → ✅ REFLECTION
        └─ No → ✅ GENERICS

Type Inference

Go can often infer type parameters from arguments:

 1package main
 2
 3import "fmt"
 4
 5func Identity[T any](v T) T {
 6    return v
 7}
 8
 9func main() {
10    // Explicit type parameter
11    result1 := Identity[int](42)
12    fmt.Println(result1)
13
14    // Type inferred from argument
15    result2 := Identity(42)
16    fmt.Println(result2)
17
18    // Type inferred from argument
19    result3 := Identity("hello")
20    fmt.Println(result3)
21}
22// run

Constraints Package

Go 1.18+ provides golang.org/x/exp/constraints package with common constraints:

 1package main
 2
 3import (
 4    "fmt"
 5    "golang.org/x/exp/constraints"
 6)
 7
 8func Sum[T constraints.Integer](values []T) T {
 9    var sum T
10    for _, v := range values {
11        sum += v
12    }
13    return sum
14}
15
16func Average[T constraints.Float](values []T) T {
17    if len(values) == 0 {
18        return 0
19    }
20    var sum T
21    for _, v := range values {
22        sum += v
23    }
24    return sum / T(len(values))
25}
26
27func main() {
28    ints := []int{1, 2, 3, 4, 5}
29    fmt.Println("Sum:", Sum(ints)) // 15
30
31    floats := []float64{1.5, 2.5, 3.5}
32    fmt.Println("Average:", Average(floats)) // 2.5
33}
34// run

Best Practices

1. Use Constraints Package for Common Patterns

✅ Correct: Use golang.org/x/exp/constraints

 1import "golang.org/x/exp/constraints"
 2
 3func Max[T constraints.Ordered](a, b T) T {
 4    if a > b {
 5        return a
 6    }
 7    return b
 8}
 9
10// Works with all ordered types
11Max(5, 10)              // int
12Max(3.14, 2.71)         // float64
13Max("apple", "banana")  // string

❌ Wrong: Manually listing all numeric types

1type Numeric interface {
2    int | int8 | int16 | int32 | int64 |
3    uint | uint8 | uint16 | uint32 | uint64 |
4    float32 | float64  // Verbose, error-prone
5}

Why: constraints.Ordered, constraints.Integer, constraints.Float cover 99% of use cases. Don't reinvent the wheel.

---

2. Prefer Type Inference

✅ Correct: Let compiler infer types

1func Identity[T any](v T) T {
2    return v
3}
4
5// Type inferred from argument
6result := Identity(42)        // T = int
7name := Identity("Alice")     // T = string

❌ Wrong: Explicit type parameters everywhere

1result := Identity[int](42)           // Unnecessary verbosity
2name := Identity[string]("Alice")     // Harder to read

Why: Type inference makes code cleaner. Only specify types when compiler can't infer or for clarity.

---

3. Constrain to Minimum Required Interface

✅ Correct: Minimal constraint

1func Contains[T comparable](slice []T, value T) bool {
2    for _, v := range slice {
3        if v == value {  // Only needs ==
4            return true
5        }
6    }
7    return false
8}

❌ Wrong: Over-constrained

1func Contains[T constraints.Ordered](slice []T, value T) bool {
2    // Only uses ==, but requires < > as well
3    for _, v := range slice {
4        if v == value {
5            return true
6        }
7    }
8    return false
9}

Why: comparable allows structs with comparable fields. Ordered only allows primitives. Constrain to what you actually use.

---

4. Use Generic Types for Data Structures

✅ Correct: Type-safe collections

 1type Stack[T any] struct {
 2    items []T
 3}
 4
 5func (s *Stack[T]) Push(item T) {
 6    s.items = append(s.items, item)
 7}
 8
 9func (s *Stack[T]) Pop() (T, bool) {
10    if len(s.items) == 0 {
11        var zero T
12        return zero, false
13    }
14    item := s.items[len(s.items)-1]
15    s.items = s.items[:len(s.items)-1]
16    return item, true
17}
18
19// Type-safe usage
20intStack := Stack[int]{}
21intStack.Push(42)
22val, _ := intStack.Pop()  // val is int, no casting needed

❌ Wrong: interface{} with runtime type assertions

 1type Stack struct {
 2    items []interface{}
 3}
 4
 5func (s *Stack) Push(item interface{}) {
 6    s.items = append(s.items, item)
 7}
 8
 9func (s *Stack) Pop() (interface{}, bool) {
10    // ... implementation
11}
12
13// Runtime type assertions required
14stack := Stack{}
15stack.Push(42)
16val, _ := stack.Pop()
17num := val.(int)  // Can panic at runtime!

Why: Generic data structures eliminate runtime type assertions and catch errors at compile time.

---

5. Return Zero Values for Empty Results

✅ Correct: Return zero value when no result

 1func First[T any](slice []T) T {
 2    if len(slice) == 0 {
 3        var zero T  // Zero value for type T
 4        return zero
 5    }
 6    return slice[0]
 7}
 8
 9First([]int{})      // Returns 0
10First([]string{})   // Returns ""
11First([]*User{})    // Returns nil

❌ Wrong: Panic on empty

1func First[T any](slice []T) T {
2    return slice[0]  // PANIC if empty!
3}

Why: Zero values are Go's way of handling absence. Panics are for unrecoverable errors only.

---

6. Use Type Parameters for Transformations

✅ Correct: Generic transformation functions

 1func Map[T any, U any](slice []T, fn func(T) U) []U {
 2    result := make([]U, len(slice))
 3    for i, v := range slice {
 4        result[i] = fn(v)
 5    }
 6    return result
 7}
 8
 9nums := []int{1, 2, 3}
10strs := Map(nums, func(n int) string {
11    return fmt.Sprintf("num_%d", n)
12})
13// strs = ["num_1", "num_2", "num_3"]

❌ Wrong: Duplicate code for each type

1func MapIntToString(slice []int, fn func(int) string) []string {
2    // ...
3}
4
5func MapStringToInt(slice []string, fn func(string) int) []int {
6    // ...
7}
8// ... 10 more variations

Why: One generic function replaces dozens of type-specific duplicates.

---

7. Document Constraint Requirements

✅ Correct: Clear documentation

1// Sorter requires types that support < and > operators.
2// Supported types: int, int64, float64, string, and other ordered types.
3type Sorter[T constraints.Ordered] struct {
4    items []T
5}
6
7func (s *Sorter[T]) Sort() {
8    // Implementation using < and >
9}

❌ Wrong: No documentation

1type Sorter[T constraints.Ordered] struct {
2    items []T
3}
4// User doesn't know what Ordered means or what types work

Why: Constraints aren't always obvious. Documentation helps users understand what types are valid.

---

8. Avoid Too Many Type Parameters

✅ Correct: 1-2 type parameters

1type Pair[K comparable, V any] struct {
2    Key   K
3    Value V
4}

❌ Wrong: Excessive type parameters

1type DataStore[K, V, E, M, S, T any] struct {
2    // What do all these mean?!
3}

Why: More than 2-3 type parameters become unreadable. Refactor into multiple types or use structs.

---

9. Prefer Generics Over Code Generation

✅ Correct: Generic implementation

 1type Set[T comparable] struct {
 2    items map[T]struct{}
 3}
 4
 5func (s *Set[T]) Add(item T)        { s.items[item] = struct{}{} }
 6func (s *Set[T]) Contains(item T) bool { _, ok := s.items[item]; return ok }
 7
 8// Works for any comparable type
 9intSet := NewSet[int]()
10stringSet := NewSet[string]()

❌ Wrong: go generate + templates

1//go:generate gen-set -type=int
2//go:generate gen-set -type=string
3// ... generate 20 more files
4
5// Requires maintaining code generator
6// Complex build process
7// Hard to debug generated code

Why: Generics are simpler, faster to compile, and easier to debug than code generation.

---

10. Use Method Sets with Constraints

✅ Correct: Constraint with required methods

 1type Serializer interface {
 2    Serialize() ([]byte, error)
 3    Deserialize([]byte) error
 4}
 5
 6func SaveToFile[T Serializer](filename string, data T) error {
 7    bytes, err := data.Serialize()  // Method guaranteed to exist
 8    if err != nil {
 9        return err
10    }
11    return os.WriteFile(filename, bytes, 0644)
12}
13
14// Works with any type that implements Serializer
15SaveToFile("user.dat", user)
16SaveToFile("config.dat", config)

❌ Wrong: Checking methods at runtime

1func SaveToFile(filename string, data interface{}) error {
2    if s, ok := data.(Serializer); ok {
3        bytes, _ := s.Serialize()
4        return os.WriteFile(filename, bytes, 0644)
5    }
6    return fmt.Errorf("type does not implement Serializer")  // Runtime error!
7}

Why: Generic constraints enforce method requirements at compile time. No runtime checks needed.

Common Pitfalls

1. Using Generics When Not Needed

❌ Problem: Over-genericizing single-use code

1// Only ever used with strings
2func ProcessNames[T ~string](names []T) []T {
3    // Generic for no reason - only called with []string
4    result := make([]T, len(names))
5    for i, name := range names {
6        result[i] = T(strings.ToUpper(string(name)))
7    }
8    return result
9}

✅ Solution: Use concrete types

1func ProcessNames(names []string) []string {
2    result := make([]string, len(names))
3    for i, name := range names {
4        result[i] = strings.ToUpper(name)
5    }
6    return result
7}

Why: Generics add complexity. Only use them when you have multiple concrete uses or actual duplication.

---

2. Forgetting Zero Values

❌ Problem: Assuming generic values are initialized

1func GetOrDefault[T any](m map[string]T, key string) T {
2    if val, ok := m[key]; ok {
3        return val
4    }
5    return ???  // What should default be? Can't know without constraint!
6}
7
8// Caller gets unexpected zero values
9num := GetOrDefault(ages, "missing")  // Returns 0, not obvious

✅ Solution: Accept default parameter

1func GetOrDefault[T any](m map[string]T, key string, defaultValue T) T {
2    if val, ok := m[key]; ok {
3        return val
4    }
5    return defaultValue
6}
7
8num := GetOrDefault(ages, "missing", -1)  // Explicit default

Why: Generic zero values may not be appropriate defaults. Let caller decide.

---

3. Not Constraining Enough

❌ Problem: Using any when operations require constraints

1func Sum[T any](values []T) T {
2    var sum T
3    for _, v := range values {
4        sum += v  // COMPILE ERROR: + not defined for any
5    }
6    return sum
7}

✅ Solution: Use appropriate constraint

1func Sum[T constraints.Integer | constraints.Float](values []T) T {
2    var sum T
3    for _, v := range values {
4        sum += v  // Works: + defined for numeric types
5    }
6    return sum
7}

Why: any means no operations. Constrain to what you actually need.

---

4. Circular Type Constraints

❌ Problem: Constraint depends on type parameter

1type Comparable[T any] interface {
2    CompareTo(T) int  // ERROR: Can't reference T here!
3}
4
5func Sort[T Comparable[T]](items []T) {
6    // Doesn't compile
7}

✅ Solution: Use methods on the type itself

 1type Comparator[T any] interface {
 2    CompareTo(other T) int
 3}
 4
 5type Person struct{ Age int }
 6
 7func (p Person) CompareTo(other Person) int {
 8    return p.Age - other.Age
 9}
10
11func Sort[T Comparator[T]](items []T) {
12    // Works!
13}

Why: Constraints can't directly reference their own type parameters. Define methods on concrete types.

---

5. Misusing comparable Constraint

❌ Problem: Assuming comparable means all types

 1func Contains[T comparable](slice []T, value T) bool {
 2    for _, v := range slice {
 3        if v == value {
 4            return true
 5        }
 6    }
 7    return false
 8}
 9
10type User struct {
11    Name string
12    Tags []string  // Slices are NOT comparable
13}
14
15users := []User{{Name: "Alice", Tags: []string{"admin"}}}
16Contains(users, User{Name: "Alice"})  // COMPILE ERROR!

✅ Solution: Use custom equality function

 1func Contains[T any](slice []T, value T, equal func(T, T) bool) bool {
 2    for _, v := range slice {
 3        if equal(v, value) {
 4            return true
 5        }
 6    }
 7    return false
 8}
 9
10users := []User{{Name: "Alice", Tags: []string{"admin"}}}
11Contains(users, User{Name: "Alice"}, func(a, b User) bool {
12    return a.Name == b.Name  // Custom equality
13})

Why: comparable only includes types where == works. Structs with slices/maps are not comparable.

---

6. Type Inference Ambiguity

❌ Problem: Compiler can't infer type

1func Make[T any]() T {
2    var zero T
3    return zero
4}
5
6// ERROR: Can't infer T from empty argument list
7result := Make()  // COMPILE ERROR: cannot infer T

✅ Solution: Specify type explicitly

1result := Make[int]()      // T = int
2user := Make[User]()       // T = User
3cache := Make[*Cache]()    // T = *Cache

Why: Compiler can only infer types from arguments. No arguments = must specify type.

---

7. Over-Constraining with Union Types

❌ Problem: Listing every possible type

1type ID interface {
2    int | int64 | uint | uint64 | string | UUID
3}
4
5func GetByID[T ID](id T) {
6    // Only supports 6 exact types - what about custom ID types?
7}

✅ Solution: Use interface with methods

 1type Identifier interface {
 2    String() string
 3}
 4
 5func GetByID[T Identifier](id T) {
 6    // Works with ANY type that has String() method
 7}
 8
 9// Custom types automatically work
10type OrderID struct{ Value int }
11func (o OrderID) String() string { return fmt.Sprintf("ORD-%d", o.Value) }
12
13GetByID(OrderID{Value: 123})  // Works!

Why: Union types are closed. Interface constraints are open.

---

8. Generic Methods on Generic Types

❌ Problem: Generic methods can't add new type parameters

1type Container[T any] struct {
2    value T
3}
4
5// ERROR: Method can't introduce new type parameter independent of T
6func (c *Container[T]) ConvertTo[U any](fn func(T) U) *Container[U] {
7    // Doesn't compile
8}

✅ Solution: Use package-level function

1func Convert[T any, U any](c *Container[T], fn func(T) U) *Container[U] {
2    return &Container[U]{value: fn(c.value)}
3}
4
5intContainer := &Container[int]{value: 42}
6strContainer := Convert(intContainer, func(i int) string {
7    return fmt.Sprintf("%d", i)
8})

Why: Methods on generic types can only use the type's parameters. Use functions for additional parameters.

---

9. Pointer vs Value Receivers Confusion

❌ Problem: Forgetting pointer receiver requirements

 1type Counter struct {
 2    count int
 3}
 4
 5// Value receiver - doesn't modify original
 6func (c Counter) Increment() {
 7    c.count++  // Modifies copy, not original!
 8}
 9
10func ProcessCounters[T interface{ Increment() }](counters []T) {
11    for i := range counters {
12        counters[i].Increment()  // No effect!
13    }
14}
15
16counters := []Counter{{count: 0}, {count: 0}}
17ProcessCounters(counters)
18// counters still [{0}, {0}] - not modified!

✅ Solution: Use pointer receiver

 1func (c *Counter) Increment() {
 2    c.count++  // Modifies original
 3}
 4
 5func ProcessCounters[T interface{ Increment() }](counters []T) {
 6    for i := range counters {
 7        counters[i].Increment()
 8    }
 9}
10
11counters := []*Counter{{count: 0}, {count: 0}}  // Pointers!
12ProcessCounters(counters)
13// counters now [{1}, {1}] - modified correctly

Why: Generic constraints with methods require careful attention to pointer vs value receivers.

---

10. Ignoring Compilation Performance

❌ Problem: Deeply nested generics

 1type Wrapper[T any] struct{ value T }
 2
 3// Exponential compile time growth
 4type Level1[T any] Wrapper[T]
 5type Level2[T any] Wrapper[Level1[T]]
 6type Level3[T any] Wrapper[Level2[T]]
 7type Level4[T any] Wrapper[Level3[T]]
 8type Level5[T any] Wrapper[Level4[T]]  // Compile time explodes!
 9
10var x Level5[int]  // Takes 10+ seconds to compile

✅ Solution: Flatten structure

1type Wrapper[T any] struct {
2    value T
3    level int
4}
5
6// Single level - fast compilation
7var x Wrapper[int] = Wrapper[int]{value: 42, level: 5}

Why: Each level of generic nesting multiplies compile time. Keep generic types shallow.

When to Use Generics

Good use cases:

• Data structures
• Utility functions
• Algorithms that work on multiple types
• Type-safe wrappers

When NOT to use generics:

• Code that only works with one type
• When interfaces solve the problem better
• When it makes code harder to read
• Over-abstracting simple code

Advanced Generic Data Structures

Generic Graph Implementation

A production-ready generic graph with adjacency list representation:

  1package main
  2
  3import (
  4	"fmt"
  5	"golang.org/x/exp/constraints"
  6)
  7
  8// Edge represents a weighted edge in the graph
  9type Edge[T comparable, W constraints.Ordered] struct {
 10	To     T
 11	Weight W
 12}
 13
 14// Graph represents a generic directed graph
 15type Graph[T comparable, W constraints.Ordered] struct {
 16	adjacencyList map[T][]Edge[T, W]
 17	vertices      map[T]bool
 18}
 19
 20// NewGraph creates a new graph
 21func NewGraph[T comparable, W constraints.Ordered]() *Graph[T, W] {
 22	return &Graph[T, W]{
 23		adjacencyList: make(map[T][]Edge[T, W]),
 24		vertices:      make(map[T]bool),
 25	}
 26}
 27
 28// AddVertex adds a vertex to the graph
 29func (g *Graph[T, W]) AddVertex(vertex T) {
 30	if !g.vertices[vertex] {
 31		g.vertices[vertex] = true
 32		g.adjacencyList[vertex] = []Edge[T, W]{}
 33	}
 34}
 35
 36// AddEdge adds a weighted edge between two vertices
 37func (g *Graph[T, W]) AddEdge(from, to T, weight W) {
 38	g.AddVertex(from)
 39	g.AddVertex(to)
 40	g.adjacencyList[from] = append(g.adjacencyList[from], Edge[T, W]{To: to, Weight: weight})
 41}
 42
 43// GetNeighbors returns all neighbors of a vertex
 44func (g *Graph[T, W]) GetNeighbors(vertex T) []Edge[T, W] {
 45	return g.adjacencyList[vertex]
 46}
 47
 48// BFS performs breadth-first search starting from a vertex
 49func (g *Graph[T, W]) BFS(start T, visit func(T)) {
 50	if !g.vertices[start] {
 51		return
 52	}
 53
 54	visited := make(map[T]bool)
 55	queue := []T{start}
 56	visited[start] = true
 57
 58	for len(queue) > 0 {
 59		current := queue[0]
 60		queue = queue[1:]
 61		visit(current)
 62
 63		for _, edge := range g.adjacencyList[current] {
 64			if !visited[edge.To] {
 65				visited[edge.To] = true
 66				queue = append(queue, edge.To)
 67			}
 68		}
 69	}
 70}
 71
 72// DFS performs depth-first search starting from a vertex
 73func (g *Graph[T, W]) DFS(start T, visit func(T)) {
 74	if !g.vertices[start] {
 75		return
 76	}
 77
 78	visited := make(map[T]bool)
 79	g.dfsHelper(start, visited, visit)
 80}
 81
 82func (g *Graph[T, W]) dfsHelper(vertex T, visited map[T]bool, visit func(T)) {
 83	visited[vertex] = true
 84	visit(vertex)
 85
 86	for _, edge := range g.adjacencyList[vertex] {
 87		if !visited[edge.To] {
 88			g.dfsHelper(edge.To, visited, visit)
 89		}
 90	}
 91}
 92
 93func main() {
 94	// String graph with integer weights
 95	cityGraph := NewGraph[string, int]()
 96	cityGraph.AddEdge("NYC", "LA", 2800)
 97	cityGraph.AddEdge("NYC", "Chicago", 790)
 98	cityGraph.AddEdge("LA", "SF", 380)
 99	cityGraph.AddEdge("Chicago", "Denver", 1000)
100
101	fmt.Println("BFS from NYC:")
102	cityGraph.BFS("NYC", func(city string) {
103		fmt.Println("-", city)
104	})
105
106	// Integer graph with float weights
107	nodeGraph := NewGraph[int, float64]()
108	nodeGraph.AddEdge(1, 2, 1.5)
109	nodeGraph.AddEdge(1, 3, 2.0)
110	nodeGraph.AddEdge(2, 4, 3.5)
111
112	fmt.Println("\nDFS from node 1:")
113	nodeGraph.DFS(1, func(node int) {
114		fmt.Println("-", node)
115	})
116}
117// run

Generic Priority Queue

A heap-based priority queue with custom comparator:

  1package main
  2
  3import (
  4	"container/heap"
  5	"fmt"
  6)
  7
  8// Item represents an item in the priority queue
  9type Item[T any, P any] struct {
 10	Value    T
 11	Priority P
 12	index    int
 13}
 14
 15// PriorityQueue implements a generic priority queue
 16type PriorityQueue[T any, P any] struct {
 17	items []Item[T, P]
 18	less  func(P, P) bool
 19}
 20
 21// NewPriorityQueue creates a new priority queue
 22func NewPriorityQueue[T any, P any](less func(P, P) bool) *PriorityQueue[T, P] {
 23	pq := &PriorityQueue[T, P]{
 24		items: make([]Item[T, P], 0),
 25		less:  less,
 26	}
 27	heap.Init(pq)
 28	return pq
 29}
 30
 31// Implement heap.Interface
 32func (pq *PriorityQueue[T, P]) Len() int { return len(pq.items) }
 33
 34func (pq *PriorityQueue[T, P]) Less(i, j int) bool {
 35	return pq.less(pq.items[i].Priority, pq.items[j].Priority)
 36}
 37
 38func (pq *PriorityQueue[T, P]) Swap(i, j int) {
 39	pq.items[i], pq.items[j] = pq.items[j], pq.items[i]
 40	pq.items[i].index = i
 41	pq.items[j].index = j
 42}
 43
 44func (pq *PriorityQueue[T, P]) Push(x interface{}) {
 45	n := len(pq.items)
 46	item := x.(Item[T, P])
 47	item.index = n
 48	pq.items = append(pq.items, item)
 49}
 50
 51func (pq *PriorityQueue[T, P]) Pop() interface{} {
 52	old := pq.items
 53	n := len(old)
 54	item := old[n-1]
 55	item.index = -1
 56	pq.items = old[0 : n-1]
 57	return item
 58}
 59
 60// Enqueue adds an item with priority
 61func (pq *PriorityQueue[T, P]) Enqueue(value T, priority P) {
 62	item := Item[T, P]{
 63		Value:    value,
 64		Priority: priority,
 65	}
 66	heap.Push(pq, item)
 67}
 68
 69// Dequeue removes and returns the highest priority item
 70func (pq *PriorityQueue[T, P]) Dequeue() (T, P, bool) {
 71	if pq.Len() == 0 {
 72		var zeroT T
 73		var zeroP P
 74		return zeroT, zeroP, false
 75	}
 76	item := heap.Pop(pq).(Item[T, P])
 77	return item.Value, item.Priority, true
 78}
 79
 80func main() {
 81	// Task queue with integer priorities
 82	taskQueue := NewPriorityQueue[string, int](func(a, b int) bool {
 83		return a < b
 84	})
 85
 86	taskQueue.Enqueue("Send email", 3)
 87	taskQueue.Enqueue("Fix critical bug", 1)
 88	taskQueue.Enqueue("Update docs", 5)
 89	taskQueue.Enqueue("Security patch", 1)
 90
 91	fmt.Println("Processing tasks by priority:")
 92	for taskQueue.Len() > 0 {
 93		task, priority, _ := taskQueue.Dequeue()
 94		fmt.Printf("Priority %d: %s\n", priority, task)
 95	}
 96
 97	// Event queue with time priorities
 98	eventQueue := NewPriorityQueue[string, float64](func(a, b float64) bool {
 99		return a < b
100	})
101
102	eventQueue.Enqueue("Event A", 10.5)
103	eventQueue.Enqueue("Event B", 5.2)
104	eventQueue.Enqueue("Event C", 7.8)
105
106	fmt.Println("\nProcessing events by time:")
107	for eventQueue.Len() > 0 {
108		event, time, _ := eventQueue.Dequeue()
109		fmt.Printf("Time %.1f: %s\n", time, event)
110	}
111}
112// run

Generic Trie

A trie implementation for efficient prefix operations:

  1package main
  2
  3import (
  4	"fmt"
  5	"strings"
  6)
  7
  8// TrieNode represents a node in the trie
  9type TrieNode[T any] struct {
 10	children map[rune]*TrieNode[T]
 11	isEnd    bool
 12	value    *T
 13}
 14
 15// Trie is a generic prefix tree
 16type Trie[T any] struct {
 17	root *TrieNode[T]
 18}
 19
 20// NewTrie creates a new trie
 21func NewTrie[T any]() *Trie[T] {
 22	return &Trie[T]{
 23		root: &TrieNode[T]{
 24			children: make(map[rune]*TrieNode[T]),
 25		},
 26	}
 27}
 28
 29// Insert adds a word with associated value to the trie
 30func (t *Trie[T]) Insert(word string, value T) {
 31	node := t.root
 32	for _, ch := range word {
 33		if node.children[ch] == nil {
 34			node.children[ch] = &TrieNode[T]{
 35				children: make(map[rune]*TrieNode[T]),
 36			}
 37		}
 38		node = node.children[ch]
 39	}
 40	node.isEnd = true
 41	node.value = &value
 42}
 43
 44// Search finds a word and returns its value
 45func (t *Trie[T]) Search(word string) (*T, bool) {
 46	node := t.root
 47	for _, ch := range word {
 48		if node.children[ch] == nil {
 49			return nil, false
 50		}
 51		node = node.children[ch]
 52	}
 53	if node.isEnd && node.value != nil {
 54		return node.value, true
 55	}
 56	return nil, false
 57}
 58
 59// StartsWith returns all words with the given prefix
 60func (t *Trie[T]) StartsWith(prefix string) []string {
 61	node := t.root
 62	for _, ch := range prefix {
 63		if node.children[ch] == nil {
 64			return []string{}
 65		}
 66		node = node.children[ch]
 67	}
 68
 69	var results []string
 70	t.collectWords(node, prefix, &results)
 71	return results
 72}
 73
 74func (t *Trie[T]) collectWords(node *TrieNode[T], prefix string, results *[]string) {
 75	if node.isEnd {
 76		*results = append(*results, prefix)
 77	}
 78
 79	for ch, child := range node.children {
 80		t.collectWords(child, prefix+string(ch), results)
 81	}
 82}
 83
 84// Delete removes a word from the trie
 85func (t *Trie[T]) Delete(word string) bool {
 86	return t.deleteHelper(t.root, word, 0)
 87}
 88
 89func (t *Trie[T]) deleteHelper(node *TrieNode[T], word string, index int) bool {
 90	if index == len(word) {
 91		if !node.isEnd {
 92			return false
 93		}
 94		node.isEnd = false
 95		node.value = nil
 96		return len(node.children) == 0
 97	}
 98
 99	ch := rune(word[index])
100	child, exists := node.children[ch]
101	if !exists {
102		return false
103	}
104
105	shouldDeleteChild := t.deleteHelper(child, word, index+1)
106
107	if shouldDeleteChild {
108		delete(node.children, ch)
109		return len(node.children) == 0 && !node.isEnd
110	}
111
112	return false
113}
114
115func main() {
116	// Dictionary with word definitions
117	dict := NewTrie[string]()
118	dict.Insert("apple", "A fruit")
119	dict.Insert("app", "Application software")
120	dict.Insert("application", "A formal request")
121	dict.Insert("apply", "To make a request")
122	dict.Insert("banana", "A yellow fruit")
123
124	// Search for words
125	if def, found := dict.Search("apple"); found {
126		fmt.Printf("apple: %s\n", *def)
127	}
128
129	// Find all words with prefix "app"
130	fmt.Println("\nWords starting with 'app':")
131	for _, word := range dict.StartsWith("app") {
132		if def, found := dict.Search(word); found {
133			fmt.Printf("- %s: %s\n", word, *def)
134		}
135	}
136
137	// Delete a word
138	dict.Delete("app")
139	fmt.Println("\nAfter deleting 'app':")
140	for _, word := range dict.StartsWith("app") {
141		fmt.Println("-", word)
142	}
143}
144// run

Advanced Constraint Techniques

Constraint Composition

Combining multiple constraints for complex requirements:

 1package main
 2
 3import (
 4	"fmt"
 5	"golang.org/x/exp/constraints"
 6)
 7
 8// Numeric combines integer and float constraints
 9type Numeric interface {
10	constraints.Integer | constraints.Float
11}
12
13// Serializable requires both String() and Bytes() methods
14type Serializable interface {
15	String() string
16	Bytes() []byte
17}
18
19// ComparableNumber is both comparable and numeric
20type ComparableNumber interface {
21	comparable
22	Numeric
23}
24
25// ProcessNumbers works with any comparable numeric type
26func ProcessNumbers[T ComparableNumber](numbers []T) (T, T, T) {
27	if len(numbers) == 0 {
28		var zero T
29		return zero, zero, zero
30	}
31
32	min, max, sum := numbers[0], numbers[0], numbers[0]
33	for _, num := range numbers[1:] {
34		if num < min {
35			min = num
36		}
37		if num > max {
38			max = num
39		}
40		sum += num
41	}
42	return min, max, sum
43}
44
45// Constraint with type parameter
46type Transformer[T any, U any] interface {
47	Transform() U
48}
49
50// ChainTransformers applies transformations in sequence
51func ChainTransformers[T any, U any, V any](
52	value T,
53	first func(T) U,
54	second func(U) V,
55) V {
56	return second(first(value))
57}
58
59func main() {
60	ints := []int{3, 1, 4, 1, 5, 9, 2, 6}
61	min, max, sum := ProcessNumbers(ints)
62	fmt.Printf("Ints - Min: %d, Max: %d, Sum: %d\n", min, max, sum)
63
64	floats := []float64{3.14, 1.41, 2.71, 1.73}
65	minF, maxF, sumF := ProcessNumbers(floats)
66	fmt.Printf("Floats - Min: %.2f, Max: %.2f, Sum: %.2f\n", minF, maxF, sumF)
67
68	// Transform chain: int -> string -> bool
69	result := ChainTransformers(42,
70		func(i int) string { return fmt.Sprintf("%d", i) },
71		func(s string) bool { return len(s) > 1 },
72	)
73	fmt.Printf("Transform result: %v\n", result)
74}
75// run

Approximation Constraints

Using ~ to allow custom types based on built-ins:

 1package main
 2
 3import "fmt"
 4
 5// UserID is a custom type based on string
 6type UserID string
 7
 8// OrderID is a custom type based on int
 9type OrderID int
10
11// Without ~: only works with exact type string
12type ExactString interface {
13	string
14}
15
16// With ~: works with any type based on string
17type AnyString interface {
18	~string
19}
20
21// PrintExact only accepts string, not UserID
22func PrintExact[T ExactString](value T) {
23	fmt.Println("Exact:", value)
24}
25
26// PrintAny accepts string, UserID, and any ~string type
27func PrintAny[T AnyString](value T) {
28	fmt.Println("Any:", value)
29}
30
31// Numeric constraint with ~
32type Number interface {
33	~int | ~int64 | ~float64
34}
35
36func Add[T Number](a, b T) T {
37	return a + b
38}
39
40func main() {
41	// These work
42	PrintAny("hello")           // string
43	PrintAny(UserID("user123")) // custom type based on string
44
45	// This would NOT compile:
46	// PrintExact(UserID("user123"))  // ERROR: UserID is not string
47
48	// Custom numeric types
49	var order1 OrderID = 100
50	var order2 OrderID = 200
51	total := Add(order1, order2) // Works because OrderID is ~int
52	fmt.Printf("Total orders: %d\n", total)
53}
54// run

Self-Referential Constraints

Constraints that reference the constrained type:

 1package main
 2
 3import "fmt"
 4
 5// Comparable with self-reference
 6type SelfComparable[T any] interface {
 7	CompareTo(T) int
 8	*T  // Constraint must be pointer to T
 9}
10
11// Person implements self-comparable
12type Person struct {
13	Name string
14	Age  int
15}
16
17func (p *Person) CompareTo(other *Person) int {
18	if p.Age < other.Age {
19		return -1
20	}
21	if p.Age > other.Age {
22		return 1
23	}
24	return 0
25}
26
27// Sort using self-comparable interface
28func Sort[T any, PT SelfComparable[T]](items []T) {
29	for i := 0; i < len(items)-1; i++ {
30		for j := i + 1; j < len(items); j++ {
31			pi := PT(&items[i])
32			pj := PT(&items[j])
33			if pi.CompareTo(pj) > 0 {
34				items[i], items[j] = items[j], items[i]
35			}
36		}
37	}
38}
39
40func main() {
41	people := []Person{
42		{Name: "Alice", Age: 30},
43		{Name: "Bob", Age: 25},
44		{Name: "Charlie", Age: 35},
45	}
46
47	fmt.Println("Before sort:", people)
48	Sort[Person, *Person](people)
49	fmt.Println("After sort:", people)
50}
51// run

Type Inference Edge Cases

Ambiguous Type Inference

Understanding when the compiler needs help:

 1package main
 2
 3import "fmt"
 4
 5func MakePair[T any, U any](first T, second U) (T, U) {
 6	return first, second
 7}
 8
 9func MakeSlice[T any](size int) []T {
10	return make([]T, size)
11}
12
13func Convert[T any, U any](value T, converter func(T) U) U {
14	return converter(value)
15}
16
17func main() {
18	// ✅ Inference works: types determined from arguments
19	pair := MakePair(42, "hello")
20	fmt.Printf("Pair: %v\n", pair)
21
22	// ❌ Inference fails: no argument to infer T from
23	// slice := MakeSlice(10)  // COMPILE ERROR
24
25	// ✅ Must specify type explicitly
26	slice := MakeSlice[int](10)
27	fmt.Printf("Slice length: %d\n", len(slice))
28
29	// ✅ Inference works: T from first arg, U from return
30	str := Convert(42, func(i int) string {
31		return fmt.Sprintf("Number: %d", i)
32	})
33	fmt.Println(str)
34
35	// ❌ Ambiguous without explicit types
36	// result := Convert(42, func(x int) interface{} {
37	//     return x
38	// })
39
40	// ✅ Explicit U type resolves ambiguity
41	result := Convert[int, interface{}](42, func(x int) interface{} {
42		return x
43	})
44	fmt.Printf("Result: %v\n", result)
45}
46// run

Constraint Inference

The compiler can infer constraints from usage:

 1package main
 2
 3import (
 4	"fmt"
 5	"golang.org/x/exp/constraints"
 6)
 7
 8// Compiler infers T must be Ordered because of < operator
 9func FindSmallest[T constraints.Ordered](values []T) T {
10	if len(values) == 0 {
11		var zero T
12		return zero
13	}
14
15	smallest := values[0]
16	for _, v := range values[1:] {
17		if v < smallest { // This requires T to be Ordered
18			smallest = v
19		}
20	}
21	return smallest
22}
23
24// Multiple constraints inferred from usage
25func Average[T constraints.Integer | constraints.Float](values []T) float64 {
26	if len(values) == 0 {
27		return 0
28	}
29
30	var sum T
31	for _, v := range values {
32		sum += v // Requires numeric type
33	}
34
35	// Convert to float64 for division
36	return float64(sum) / float64(len(values))
37}
38
39func main() {
40	// Compiler infers T = int from argument
41	nums := []int{5, 2, 8, 1, 9}
42	smallest := FindSmallest(nums)
43	fmt.Printf("Smallest: %d\n", smallest)
44
45	// Works with different ordered types
46	words := []string{"zebra", "apple", "mango"}
47	firstWord := FindSmallest(words)
48	fmt.Printf("First word: %s\n", firstWord)
49
50	// Average with integers
51	intAvg := Average(nums)
52	fmt.Printf("Integer average: %.2f\n", intAvg)
53
54	// Average with floats
55	floats := []float64{3.14, 2.71, 1.41}
56	floatAvg := Average(floats)
57	fmt.Printf("Float average: %.2f\n", floatAvg)
58}
59// run

Production Patterns with Generics

Generic Repository Pattern

Database-agnostic repository with generics:

  1package main
  2
  3import (
  4	"errors"
  5	"fmt"
  6	"sync"
  7)
  8
  9// Entity interface for database entities
 10type Entity interface {
 11	comparable
 12	GetID() string
 13}
 14
 15// Repository provides CRUD operations for any entity
 16type Repository[T Entity] struct {
 17	mu    sync.RWMutex
 18	store map[string]T
 19}
 20
 21// NewRepository creates a new repository
 22func NewRepository[T Entity]() *Repository[T] {
 23	return &Repository[T]{
 24		store: make(map[string]T),
 25	}
 26}
 27
 28// Create adds a new entity
 29func (r *Repository[T]) Create(entity T) error {
 30	r.mu.Lock()
 31	defer r.mu.Unlock()
 32
 33	id := entity.GetID()
 34	if _, exists := r.store[id]; exists {
 35		return errors.New("entity already exists")
 36	}
 37
 38	r.store[id] = entity
 39	return nil
 40}
 41
 42// Get retrieves an entity by ID
 43func (r *Repository[T]) Get(id string) (T, error) {
 44	r.mu.RLock()
 45	defer r.mu.RUnlock()
 46
 47	entity, exists := r.store[id]
 48	if !exists {
 49		var zero T
 50		return zero, errors.New("entity not found")
 51	}
 52
 53	return entity, nil
 54}
 55
 56// Update modifies an existing entity
 57func (r *Repository[T]) Update(entity T) error {
 58	r.mu.Lock()
 59	defer r.mu.Unlock()
 60
 61	id := entity.GetID()
 62	if _, exists := r.store[id]; !exists {
 63		return errors.New("entity not found")
 64	}
 65
 66	r.store[id] = entity
 67	return nil
 68}
 69
 70// Delete removes an entity
 71func (r *Repository[T]) Delete(id string) error {
 72	r.mu.Lock()
 73	defer r.mu.Unlock()
 74
 75	if _, exists := r.store[id]; !exists {
 76		return errors.New("entity not found")
 77	}
 78
 79	delete(r.store, id)
 80	return nil
 81}
 82
 83// List returns all entities
 84func (r *Repository[T]) List() []T {
 85	r.mu.RLock()
 86	defer r.mu.RUnlock()
 87
 88	entities := make([]T, 0, len(r.store))
 89	for _, entity := range r.store {
 90		entities = append(entities, entity)
 91	}
 92	return entities
 93}
 94
 95// User entity
 96type User struct {
 97	ID    string
 98	Name  string
 99	Email string
100}
101
102func (u User) GetID() string { return u.ID }
103
104// Product entity
105type Product struct {
106	ID    string
107	Name  string
108	Price float64
109}
110
111func (p Product) GetID() string { return p.ID }
112
113func main() {
114	// User repository
115	userRepo := NewRepository[User]()
116	userRepo.Create(User{ID: "1", Name: "Alice", Email: "alice@example.com"})
117	userRepo.Create(User{ID: "2", Name: "Bob", Email: "bob@example.com"})
118
119	if user, err := userRepo.Get("1"); err == nil {
120		fmt.Printf("Found user: %s (%s)\n", user.Name, user.Email)
121	}
122
123	// Product repository
124	productRepo := NewRepository[Product]()
125	productRepo.Create(Product{ID: "p1", Name: "Laptop", Price: 999.99})
126	productRepo.Create(Product{ID: "p2", Name: "Mouse", Price: 29.99})
127
128	fmt.Println("\nAll products:")
129	for _, product := range productRepo.List() {
130		fmt.Printf("- %s: $%.2f\n", product.Name, product.Price)
131	}
132}
133// run

Generic Builder Pattern

Fluent API with type safety:

 1package main
 2
 3import "fmt"
 4
 5// Builder for constructing complex objects
 6type Builder[T any] struct {
 7	value T
 8	steps []func(*T)
 9}
10
11// NewBuilder creates a new builder
12func NewBuilder[T any](initial T) *Builder[T] {
13	return &Builder[T]{
14		value: initial,
15		steps: make([]func(*T), 0),
16	}
17}
18
19// With adds a configuration step
20func (b *Builder[T]) With(fn func(*T)) *Builder[T] {
21	b.steps = append(b.steps, fn)
22	return b
23}
24
25// Build constructs the final object
26func (b *Builder[T]) Build() T {
27	result := b.value
28	for _, step := range b.steps {
29		step(&result)
30	}
31	return result
32}
33
34// Example: HTTP Client configuration
35type HTTPClient struct {
36	BaseURL    string
37	Timeout    int
38	Headers    map[string]string
39	RetryCount int
40}
41
42func main() {
43	// Build HTTP client with fluent API
44	client := NewBuilder(HTTPClient{}).
45		With(func(c *HTTPClient) {
46			c.BaseURL = "https://api.example.com"
47		}).
48		With(func(c *HTTPClient) {
49			c.Timeout = 30
50		}).
51		With(func(c *HTTPClient) {
52			c.Headers = map[string]string{
53				"Authorization": "Bearer token",
54				"Content-Type":  "application/json",
55			}
56		}).
57		With(func(c *HTTPClient) {
58			c.RetryCount = 3
59		}).
60		Build()
61
62	fmt.Printf("HTTP Client: %+v\n", client)
63
64	// Build database connection
65	type DBConfig struct {
66		Host     string
67		Port     int
68		Database string
69		User     string
70	}
71
72	dbConfig := NewBuilder(DBConfig{}).
73		With(func(db *DBConfig) { db.Host = "localhost" }).
74		With(func(db *DBConfig) { db.Port = 5432 }).
75		With(func(db *DBConfig) { db.Database = "myapp" }).
76		With(func(db *DBConfig) { db.User = "admin" }).
77		Build()
78
79	fmt.Printf("\nDB Config: %+v\n", dbConfig)
80}
81// run

Generic Result Type for Error Handling

Railway-oriented programming with Result type:

  1package main
  2
  3import (
  4	"errors"
  5	"fmt"
  6	"strconv"
  7)
  8
  9// Result represents either success or failure
 10type Result[T any] struct {
 11	value T
 12	err   error
 13}
 14
 15// Ok creates a successful result
 16func Ok[T any](value T) Result[T] {
 17	return Result[T]{value: value, err: nil}
 18}
 19
 20// Err creates a failed result
 21func Err[T any](err error) Result[T] {
 22	var zero T
 23	return Result[T]{value: zero, err: err}
 24}
 25
 26// IsOk checks if result is successful
 27func (r Result[T]) IsOk() bool {
 28	return r.err == nil
 29}
 30
 31// IsErr checks if result is a failure
 32func (r Result[T]) IsErr() bool {
 33	return r.err != nil
 34}
 35
 36// Unwrap returns value or panics
 37func (r Result[T]) Unwrap() T {
 38	if r.IsErr() {
 39		panic("called Unwrap on error result")
 40	}
 41	return r.value
 42}
 43
 44// UnwrapOr returns value or default
 45func (r Result[T]) UnwrapOr(defaultValue T) T {
 46	if r.IsOk() {
 47		return r.value
 48	}
 49	return defaultValue
 50}
 51
 52// Map transforms the value if Ok
 53func (r Result[T]) Map[U any](fn func(T) U) Result[U] {
 54	if r.IsErr() {
 55		return Err[U](r.err)
 56	}
 57	return Ok(fn(r.value))
 58}
 59
 60// AndThen chains operations that may fail
 61func (r Result[T]) AndThen[U any](fn func(T) Result[U]) Result[U] {
 62	if r.IsErr() {
 63		return Err[U](r.err)
 64	}
 65	return fn(r.value)
 66}
 67
 68// Example: Parse and validate user input
 69func parseAge(s string) Result[int] {
 70	age, err := strconv.Atoi(s)
 71	if err != nil {
 72		return Err[int](fmt.Errorf("invalid age: %w", err))
 73	}
 74	return Ok(age)
 75}
 76
 77func validateAge(age int) Result[int] {
 78	if age < 0 || age > 150 {
 79		return Err[int](errors.New("age out of range"))
 80	}
 81	return Ok(age)
 82}
 83
 84func categorizeAge(age int) Result[string] {
 85	var category string
 86	switch {
 87	case age < 18:
 88		category = "minor"
 89	case age < 65:
 90		category = "adult"
 91	default:
 92		category = "senior"
 93	}
 94	return Ok(category)
 95}
 96
 97func main() {
 98	// Success path
 99	result1 := parseAge("30").
100		AndThen(validateAge).
101		AndThen(categorizeAge)
102
103	if result1.IsOk() {
104		fmt.Printf("Age category: %s\n", result1.Unwrap())
105	}
106
107	// Error path - invalid format
108	result2 := parseAge("abc").
109		AndThen(validateAge).
110		AndThen(categorizeAge)
111
112	fmt.Printf("Result 2 error: %v\n", result2.err)
113
114	// Error path - out of range
115	result3 := parseAge("200").
116		AndThen(validateAge).
117		AndThen(categorizeAge)
118
119	fmt.Printf("Result 3 error: %v\n", result3.err)
120
121	// Using Map for transformation
122	doubled := Ok(21).Map(func(n int) int {
123		return n * 2
124	})
125	fmt.Printf("Doubled: %d\n", doubled.Unwrap())
126
127	// UnwrapOr for defaults
128	invalid := parseAge("xyz")
129	age := invalid.UnwrapOr(-1)
130	fmt.Printf("Age with default: %d\n", age)
131}
132// run

Performance Considerations

Generic Code and Optimization

Understanding how generics affect performance:

 1package main
 2
 3import (
 4	"fmt"
 5	"time"
 6)
 7
 8// Generic sum - monomorphized at compile time
 9func SumGeneric[T int | int64 | float64](values []T) T {
10	var sum T
11	for _, v := range values {
12		sum += v
13	}
14	return sum
15}
16
17// Interface-based sum - runtime overhead
18func SumInterface(values []interface{}) float64 {
19	var sum float64
20	for _, v := range values {
21		sum += v.(float64) // Type assertion at runtime
22	}
23	return sum
24}
25
26// Concrete sum - no abstraction overhead
27func SumConcrete(values []int) int {
28	var sum int
29	for _, v := range values {
30		sum += v
31	}
32	return sum
33}
34
35func benchmark(name string, fn func()) {
36	start := time.Now()
37	fn()
38	elapsed := time.Since(start)
39	fmt.Printf("%s: %v\n", name, elapsed)
40}
41
42func main() {
43	const size = 10_000_000
44	ints := make([]int, size)
45	floats := make([]float64, size)
46	interfaces := make([]interface{}, size)
47
48	for i := 0; i < size; i++ {
49		ints[i] = i
50		floats[i] = float64(i)
51		interfaces[i] = float64(i)
52	}
53
54	fmt.Println("Performance comparison:")
55
56	benchmark("Concrete int", func() {
57		_ = SumConcrete(ints)
58	})
59
60	benchmark("Generic int", func() {
61		_ = SumGeneric(ints)
62	})
63
64	benchmark("Generic float64", func() {
65		_ = SumGeneric(floats)
66	})
67
68	benchmark("Interface float64", func() {
69		_ = SumInterface(interfaces)
70	})
71
72	// Results:
73	// Concrete int:      ~8ms
74	// Generic int:       ~8ms
75	// Generic float64:   ~8ms
76	// Interface float64: ~45ms
77}
78// run

Key Takeaways:

• Generic code has zero runtime overhead - it's monomorphized at compile time
• Performance is identical to hand-written concrete types
• Much faster than interface{} which requires runtime type assertions and boxing
• Compile time increases slightly with many generic instantiations
• Binary size increases slightly

Avoiding Generic Anti-Patterns

 1package main
 2
 3// ❌ Anti-pattern: Unnecessary generic wrapper
 4type StringWrapper[T ~string] struct {
 5	value T
 6}
 7
 8// ✅ Better: Use string directly
 9type StringValue string
10
11// ❌ Anti-pattern: Too many type parameters
12type Processor[A, B, C, D, E, F any] struct{}
13
14// ✅ Better: Group related types
15type Config struct {
16	InputA  interface{}
17	InputB  interface{}
18	Output  interface{}
19}
20type Processor2[C Config] struct{}
21
22// ❌ Anti-pattern: Generic for single use
23func OnlyUsedWithInt[T any](x T) T { return x }
24
25// ✅ Better: Concrete type
26func OnlyUsedWithIntConcrete(x int) int { return x }
27
28func main() {
29	// Examples of when NOT to use generics
30}

Real-World Generic Patterns

Generic Builder Pattern

The builder pattern is incredibly useful for constructing complex objects with many configuration options. Generics make it easy to create type-safe builders that work across multiple types:

 1package main
 2
 3import "fmt"
 4
 5// Generic builder for flexible object construction
 6type Builder[T any] struct {
 7	instance T
 8	errors   []error
 9}
10
11// NewBuilder creates a new generic builder
12func NewBuilder[T any]() *Builder[T] {
13	return &Builder[T]{
14		errors: make([]error, 0),
15	}
16}
17
18// Set allows building with a configuration function
19func (b *Builder[T]) Set(fn func(*T) error) *Builder[T] {
20	if err := fn(&b.instance); err != nil {
21		b.errors = append(b.errors, err)
22	}
23	return b
24}
25
26// Build returns the instance and any errors that occurred
27func (b *Builder[T]) Build() (T, error) {
28	if len(b.errors) > 0 {
29		return b.instance, fmt.Errorf("build failed: %v", b.errors[0])
30	}
31	return b.instance, nil
32}
33
34// Example types
35type User struct {
36	Name  string
37	Email string
38	Age   int
39}
40
41type Config struct {
42	Host     string
43	Port     int
44	MaxConns int
45}
46
47func main() {
48	// Generic builder for User
49	user, err := NewBuilder[User]().
50		Set(func(u *User) error {
51			u.Name = "Alice"
52			return nil
53		}).
54		Set(func(u *User) error {
55			u.Email = "alice@example.com"
56			return nil
57		}).
58		Set(func(u *User) error {
59			u.Age = 30
60			return nil
61		}).
62		Build()
63
64	if err != nil {
65		fmt.Println("Error:", err)
66	} else {
67		fmt.Printf("User: %+v\n", user)
68	}
69
70	// Same builder works for Config
71	cfg, err := NewBuilder[Config]().
72		Set(func(c *Config) error {
73			c.Host = "localhost"
74			return nil
75		}).
76		Set(func(c *Config) error {
77			c.Port = 8080
78			return nil
79		}).
80		Build()
81
82	if err == nil {
83		fmt.Printf("Config: %+v\n", cfg)
84	}
85}
86// run

Generic Pipeline Processing

Processing data through a series of transformations is a common pattern. Generics allow creating type-safe pipelines that transform data while maintaining compile-time type safety:

 1package main
 2
 3import (
 4	"fmt"
 5	"strings"
 6)
 7
 8// Pipeline represents a series of transformation stages
 9type Pipeline[T any] struct {
10	transforms []func(T) T
11}
12
13// NewPipeline creates a new processing pipeline
14func NewPipeline[T any]() *Pipeline[T] {
15	return &Pipeline[T]{
16		transforms: make([]func(T) T, 0),
17	}
18}
19
20// Add appends a transformation stage to the pipeline
21func (p *Pipeline[T]) Add(transform func(T) T) *Pipeline[T] {
22	p.transforms = append(p.transforms, transform)
23	return p
24}
25
26// Process applies all transformations in sequence
27func (p *Pipeline[T]) Process(input T) T {
28	result := input
29	for _, transform := range p.transforms {
30		result = transform(result)
31	}
32	return result
33}
34
35// Example with strings
36func main() {
37	stringPipeline := NewPipeline[string]().
38		Add(func(s string) string {
39			return strings.ToLower(s)
40		}).
41		Add(func(s string) string {
42			return strings.TrimSpace(s)
43		}).
44		Add(func(s string) string {
45			return strings.ReplaceAll(s, " ", "_")
46		})
47
48	result := stringPipeline.Process("  HELLO WORLD  ")
49	fmt.Println(result) // hello_world
50
51	// Example with numbers
52	numberPipeline := NewPipeline[int]().
53		Add(func(n int) int { return n * 2 }).
54		Add(func(n int) int { return n + 10 }).
55		Add(func(n int) int { return n / 2 })
56
57	numResult := numberPipeline.Process(5)
58	fmt.Println(numResult) // 10
59}
60// run

Generic Repository Pattern

Data access layers benefit greatly from generics. You can create a single, type-safe repository that works with any entity:

  1package main
  2
  3import (
  4	"fmt"
  5	"sync"
  6)
  7
  8// Entity defines the interface for stored objects
  9type Entity interface {
 10	GetID() string
 11}
 12
 13// Repository provides generic CRUD operations
 14type Repository[T Entity] struct {
 15	data map[string]T
 16	mu   sync.RWMutex
 17}
 18
 19// NewRepository creates a new repository
 20func NewRepository[T Entity]() *Repository[T] {
 21	return &Repository[T]{
 22		data: make(map[string]T),
 23	}
 24}
 25
 26// Create adds an entity to the repository
 27func (r *Repository[T]) Create(entity T) error {
 28	r.mu.Lock()
 29	defer r.mu.Unlock()
 30	r.data[entity.GetID()] = entity
 31	return nil
 32}
 33
 34// Get retrieves an entity by ID
 35func (r *Repository[T]) Get(id string) (T, bool) {
 36	r.mu.RLock()
 37	defer r.mu.RUnlock()
 38	entity, exists := r.data[id]
 39	return entity, exists
 40}
 41
 42// Update modifies an existing entity
 43func (r *Repository[T]) Update(entity T) error {
 44	r.mu.Lock()
 45	defer r.mu.Unlock()
 46	if _, exists := r.data[entity.GetID()]; !exists {
 47		return fmt.Errorf("entity not found")
 48	}
 49	r.data[entity.GetID()] = entity
 50	return nil
 51}
 52
 53// Delete removes an entity
 54func (r *Repository[T]) Delete(id string) error {
 55	r.mu.Lock()
 56	defer r.mu.Unlock()
 57	if _, exists := r.data[id]; !exists {
 58		return fmt.Errorf("entity not found")
 59	}
 60	delete(r.data, id)
 61	return nil
 62}
 63
 64// List returns all entities
 65func (r *Repository[T]) List() []T {
 66	r.mu.RLock()
 67	defer r.mu.RUnlock()
 68	result := make([]T, 0, len(r.data))
 69	for _, v := range r.data {
 70		result = append(result, v)
 71	}
 72	return result
 73}
 74
 75// Example entities
 76type User struct {
 77	ID   string
 78	Name string
 79}
 80
 81func (u User) GetID() string { return u.ID }
 82
 83type Product struct {
 84	ID    string
 85	Title string
 86	Price float64
 87}
 88
 89func (p Product) GetID() string { return p.ID }
 90
 91func main() {
 92	// User repository
 93	userRepo := NewRepository[User]()
 94	userRepo.Create(User{ID: "1", Name: "Alice"})
 95	userRepo.Create(User{ID: "2", Name: "Bob"})
 96
 97	if user, ok := userRepo.Get("1"); ok {
 98		fmt.Printf("Found user: %+v\n", user)
 99	}
100
101	// Product repository - same implementation
102	productRepo := NewRepository[Product]()
103	productRepo.Create(Product{ID: "p1", Title: "Laptop", Price: 999.99})
104
105	if product, ok := productRepo.Get("p1"); ok {
106		fmt.Printf("Found product: %+v\n", product)
107	}
108}
109// run

Integration and Mastery - Advanced Generic Techniques

Constraint Composition for Complex Requirements

When you need to work with types that satisfy multiple constraints, you can compose them:

 1package main
 2
 3import "fmt"
 4
 5// Serializable types can be converted to string format
 6type Serializable interface {
 7	Serialize() string
 8}
 9
10// Deserializable types can be created from string format
11type Deserializable interface {
12	Deserialize(string) error
13}
14
15// SerializableDeserializable requires both capabilities
16type SerializableDeserializable interface {
17	Serializable
18	Deserializable
19}
20
21// GenericHandler works with types that are both serializable and ordered
22type GenericHandler[T interface {
23	comparable
24	Serializable
25	Deserializable
26}] struct {
27	data T
28}
29
30// Example implementation
31type ConfigEntry struct {
32	Value string
33}
34
35func (c ConfigEntry) Serialize() string {
36	return "config:" + c.Value
37}
38
39func (c *ConfigEntry) Deserialize(s string) error {
40	c.Value = s[7:] // Remove "config:"
41	return nil
42}
43
44func main() {
45	handler := GenericHandler[ConfigEntry]{
46		data: ConfigEntry{Value: "setting1"},
47	}
48
49	serialized := handler.data.Serialize()
50	fmt.Println(serialized)
51}
52// run

Summary - Mastering Go Generics

Generics represent a fundamental shift in how you write Go code. They solve one of Go's long-standing pain points: the need to choose between code duplication, loss of type safety with interface{}, or complex code generation tooling.

Core Benefits

• Type Safety: Generics give you the benefits of static typing without sacrificing flexibility. The compiler catches type errors at compile time, not at runtime with panics.
• Code Reuse: Write libraries that work with any type while maintaining performance. A single generic function replaces dozens of duplicated implementations.
• Reduced Boilerplate: No more code generation or interface{} with type assertions. Your code is simpler and more maintainable.
• Zero Runtime Overhead: Generics are monomorphized at compile time, meaning the compiler generates specialized versions for each type. Your code performs identically to hand-written concrete types.
• Real-World Patterns: Builders, pipelines, repositories, and other patterns work beautifully with generics. These patterns are production-tested in major Go projects.
• Constraint Power: Use constraints to express exactly what operations your generic types support. This replaces ad-hoc interface documentation with actual compile-time contracts.
• Composition: Combine constraints and interfaces for sophisticated type hierarchies. Your abstractions become more powerful and expressive.

When to Use Generics

Use generics when:

• You're writing reusable library code that works with multiple types
• You want compile-time type safety instead of interface{}
• You're implementing standard data structures (stacks, queues, trees, graphs)
• You need type-specific performance optimizations
• You're building frameworks or middleware

Don't use generics when:

• You're writing application-specific business logic for one type
• The complexity isn't worth the abstraction
• You only need to work with interface{}
• A simpler non-generic solution exists

Production Practices

1. Test thoroughly: Generics should be tested with multiple types to ensure correct behavior
2. Document constraints clearly: Explain what constraints require and why
3. Consider backward compatibility: Generic code is easy to extend but harder to break
4. Cache reflection results: If mixing generics with reflection, cache type information
5. Use version management: Ensure users have Go 1.18+ if they use your generic libraries

The Future of Go

Generics are the foundation for more advanced features coming to Go. Future versions may include:

• Generic methods with different type parameters than their receivers
• Better constraint syntax and built-in generic types
• Generic interfaces with more powerful capabilities
• Standard library expansion with generic utilities

Master generics and write more reusable, type-safe Go code! Your libraries will be cleaner, faster, and more maintainable than ever before.

Practice Exercises

Exercise 1: Generic Min/Max

Difficulty: Intermediate | Time: 15-20 minutes

Learning Objectives:

• Understand how to use type constraints with generic functions
• Practice working with variadic generic parameters
• Learn to handle edge cases in generic algorithms

Real-World Context:
Generic Min/Max functions are fundamental building blocks in many applications. They're used in data processing pipelines to find outliers, in gaming systems to determine high scores, in financial applications to analyze price ranges, and in monitoring systems to track performance metrics. Understanding how to implement these generic functions will help you create reusable, type-safe utilities that work across different data types without code duplication.

Task:
Implement generic Min and Max functions that work with any ordered type, including proper handling of empty input cases and variadic parameters.

Solution

 1package main
 2
 3import (
 4    "fmt"
 5    "golang.org/x/exp/constraints"
 6)
 7
 8func Min[T constraints.Ordered](values ...T) T {
 9    if len(values) == 0 {
10        var zero T
11        return zero
12    }
13
14    min := values[0]
15    for _, v := range values[1:] {
16        if v < min {
17            min = v
18        }
19    }
20    return min
21}
22
23func Max[T constraints.Ordered](values ...T) T {
24    if len(values) == 0 {
25        var zero T
26        return zero
27    }
28
29    max := values[0]
30    for _, v := range values[1:] {
31        if v > max {
32            max = v
33        }
34    }
35    return max
36}
37
38func main() {
39    fmt.Println(Min(5, 2, 8, 1, 9))           // 1
40    fmt.Println(Max(5, 2, 8, 1, 9))           // 9
41    fmt.Println(Min(3.14, 2.71, 1.41))        // 1.41
42    fmt.Println(Max("apple", "banana", "cherry")) // cherry
43}

Exercise 2: Generic Linked List

Difficulty: Intermediate | Time: 25-30 minutes

Learning Objectives:

• Master generic struct definitions and methods
• Understand pointer management in generic data structures
• Practice implementing fundamental data structure operations generically

Real-World Context:
Generic linked lists are crucial in many real-world scenarios. They're used in implementing queues for task scheduling systems, managing memory allocations in operating systems, creating undo/redo functionality in text editors, and building music playlist applications. By implementing a generic linked list, you'll learn how to create reusable data structures that can store any type of data while maintaining type safety and performance.

Task:
Implement a generic singly-linked list with add, remove, and find methods that work with any data type, including proper memory management and edge case handling.

Solution

 1package main
 2
 3import "fmt"
 4
 5type Node[T any] struct {
 6    value T
 7    next  *Node[T]
 8}
 9
10type LinkedList[T comparable] struct {
11    head *Node[T]
12    size int
13}
14
15func (l *LinkedList[T]) Add(value T) {
16    newNode := &Node[T]{value: value}
17
18    if l.head == nil {
19        l.head = newNode
20    } else {
21        current := l.head
22        for current.next != nil {
23            current = current.next
24        }
25        current.next = newNode
26    }
27
28    l.size++
29}
30
31func (l *LinkedList[T]) Remove(value T) bool {
32    if l.head == nil {
33        return false
34    }
35
36    if l.head.value == value {
37        l.head = l.head.next
38        l.size--
39        return true
40    }
41
42    current := l.head
43    for current.next != nil {
44        if current.next.value == value {
45            current.next = current.next.next
46            l.size--
47            return true
48        }
49        current = current.next
50    }
51
52    return false
53}
54
55func (l *LinkedList[T]) Find(value T) bool {
56    current := l.head
57    for current != nil {
58        if current.value == value {
59            return true
60        }
61        current = current.next
62    }
63    return false
64}
65
66func (l *LinkedList[T]) ToSlice() []T {
67    result := make([]T, 0, l.size)
68    current := l.head
69    for current != nil {
70        result = append(result, current.value)
71        current = current.next
72    }
73    return result
74}
75
76func main() {
77    list := LinkedList[int]{}
78    list.Add(1)
79    list.Add(2)
80    list.Add(3)
81
82    fmt.Println("List:", list.ToSlice())    // [1 2 3]
83    fmt.Println("Find 2:", list.Find(2))    // true
84    fmt.Println("Find 5:", list.Find(5))    // false
85
86    list.Remove(2)
87    fmt.Println("After remove:", list.ToSlice()) // [1 3]
88}

Exercise 3: Generic Set

Difficulty: Advanced | Time: 30-35 minutes

Learning Objectives:

• Implement generic data structures with complex operations
• Understand set theory concepts in programming
• Master working with comparable types and hash-based collections

Real-World Context:
Generic sets are essential in modern software development. They're used in database query optimization for eliminating duplicates, in permission systems for managing user roles, in configuration management for handling feature flags, and in data analysis pipelines for filtering unique values. Understanding how to implement a generic set will help you build efficient, type-safe systems for managing collections of unique items across various domains.

Task:
Implement a generic set with add, remove, contains, and set operations that works with any comparable type, including efficient lookup operations and proper handling of duplicates.

Solution

 1package main
 2
 3import "fmt"
 4
 5type Set[T comparable] struct {
 6    items map[T]struct{}
 7}
 8
 9func NewSet[T comparable]() *Set[T] {
10    return &Set[T]{
11        items: make(map[T]struct{}),
12    }
13}
14
15func (s *Set[T]) Add(item T) {
16    s.items[item] = struct{}{}
17}
18
19func (s *Set[T]) Remove(item T) {
20    delete(s.items, item)
21}
22
23func (s *Set[T]) Contains(item T) bool {
24    _, exists := s.items[item]
25    return exists
26}
27
28func (s *Set[T]) Size() int {
29    return len(s.items)
30}
31
32func (s *Set[T]) ToSlice() []T {
33    result := make([]T, 0, len(s.items))
34    for item := range s.items {
35        result = append(result, item)
36    }
37    return result
38}
39
40func (s *Set[T]) Union(other *Set[T]) *Set[T] {
41    result := NewSet[T]()
42    for item := range s.items {
43        result.Add(item)
44    }
45    for item := range other.items {
46        result.Add(item)
47    }
48    return result
49}
50
51func (s *Set[T]) Intersection(other *Set[T]) *Set[T] {
52    result := NewSet[T]()
53    for item := range s.items {
54        if other.Contains(item) {
55            result.Add(item)
56        }
57    }
58    return result
59}
60
61func main() {
62    set1 := NewSet[int]()
63    set1.Add(1)
64    set1.Add(2)
65    set1.Add(3)
66
67    set2 := NewSet[int]()
68    set2.Add(2)
69    set2.Add(3)
70    set2.Add(4)
71
72    fmt.Println("Set 1:", set1.ToSlice())
73    fmt.Println("Set 2:", set2.ToSlice())
74
75    union := set1.Union(set2)
76    fmt.Println("Union:", union.ToSlice())
77
78    intersection := set1.Intersection(set2)
79    fmt.Println("Intersection:", intersection.ToSlice())
80}

Exercise 4: Generic Tree

Difficulty: Advanced | Time: 35-40 minutes

Learning Objectives:

• Master recursive generic data structures
• Understand tree traversal algorithms
• Practice implementing ordered data structures with constraints

Real-World Context:
Generic binary search trees are fundamental in computer science and used extensively in real applications. They power database indexing systems, implement symbol tables in compilers, enable autocompletion in text editors, and drive file system organization. By implementing a generic BST, you'll understand how to create efficient search structures that maintain order and performance across different data types, which is crucial for building scalable applications.

Task:
Implement a generic binary search tree with insert, search, and traversal operations that works with any ordered type, including proper handling of duplicate values and balanced tree operations.

Solution

 1package main
 2
 3import (
 4    "fmt"
 5    "golang.org/x/exp/constraints"
 6)
 7
 8type TreeNode[T constraints.Ordered] struct {
 9    value T
10    left  *TreeNode[T]
11    right *TreeNode[T]
12}
13
14type BST[T constraints.Ordered] struct {
15    root *TreeNode[T]
16}
17
18func (t *BST[T]) Insert(value T) {
19    t.root = t.insertNode(t.root, value)
20}
21
22func (t *BST[T]) insertNode(node *TreeNode[T], value T) *TreeNode[T] {
23    if node == nil {
24        return &TreeNode[T]{value: value}
25    }
26
27    if value < node.value {
28        node.left = t.insertNode(node.left, value)
29    } else if value > node.value {
30        node.right = t.insertNode(node.right, value)
31    }
32
33    return node
34}
35
36func (t *BST[T]) Contains(value T) bool {
37    return t.search(t.root, value)
38}
39
40func (t *BST[T]) search(node *TreeNode[T], value T) bool {
41    if node == nil {
42        return false
43    }
44
45    if value == node.value {
46        return true
47    } else if value < node.value {
48        return t.search(node.left, value)
49    } else {
50        return t.search(node.right, value)
51    }
52}
53
54func (t *BST[T]) InOrder() []T {
55    var result []T
56    t.inOrder(t.root, &result)
57    return result
58}
59
60func (t *BST[T]) inOrder(node *TreeNode[T], result *[]T) {
61    if node == nil {
62        return
63    }
64
65    t.inOrder(node.left, result)
66    *result = append(*result, node.value)
67    t.inOrder(node.right, result)
68}
69
70func main() {
71    tree := BST[int]{}
72    tree.Insert(5)
73    tree.Insert(3)
74    tree.Insert(7)
75    tree.Insert(1)
76    tree.Insert(9)
77
78    fmt.Println("In-order:", tree.InOrder())      // [1 3 5 7 9]
79    fmt.Println("Contains 3:", tree.Contains(3))   // true
80    fmt.Println("Contains 6:", tree.Contains(6))   // false
81}

Exercise 5: Generic Optional/Result Type

Difficulty: Expert | Time: 40-45 minutes

Learning Objectives:

• Master advanced generic patterns for error handling
• Understand functional programming concepts in Go
• Practice implementing monadic patterns and method chaining

Real-World Context:
Generic Optional/Result types are revolutionizing error handling in modern software development. They're used in API clients for handling response parsing, in configuration loaders for managing missing values, in database operations for query results, and in file processing systems for handling I/O operations. Understanding how to implement these patterns will help you write more robust, expressive code that eliminates null pointer exceptions and makes error handling explicit and type-safe.

Task:
Implement a generic Option type with methods for handling presence/absence of values, including map, flatMap, and conditional operations that work with any data type.

Solution

 1package main
 2
 3import (
 4    "fmt"
 5)
 6
 7type Option[T any] struct {
 8    value   T
 9    hasValue bool
10}
11
12func Some[T any](value T) Option[T] {
13    return Option[T]{value: value, hasValue: true}
14}
15
16func None[T any]() Option[T] {
17    return Option[T]{hasValue: false}
18}
19
20func (o Option[T]) IsSome() bool {
21    return o.hasValue
22}
23
24func (o Option[T]) IsNone() bool {
25    return !o.hasValue
26}
27
28func (o Option[T]) Unwrap() T {
29    if !o.hasValue {
30        panic("called Unwrap on None")
31    }
32    return o.value
33}
34
35func (o Option[T]) UnwrapOr(defaultValue T) T {
36    if o.hasValue {
37        return o.value
38    }
39    return defaultValue
40}
41
42func (o Option[T]) UnwrapOrElse(fn func() T) T {
43    if o.hasValue {
44        return o.value
45    }
46    return fn()
47}
48
49func (o Option[T]) Map[U any](fn func(T) U) Option[U] {
50    if !o.hasValue {
51        return None[U]()
52    }
53    return Some(fn(o.value))
54}
55
56func divide(a, b float64) Option[float64] {
57    if b == 0 {
58        return None[float64]()
59    }
60    return Some(a / b)
61}
62
63func main() {
64    result1 := divide(10, 2)
65    if result1.IsSome() {
66        fmt.Println("Result:", result1.Unwrap()) // 5
67    }
68
69    result2 := divide(10, 0)
70    fmt.Println("Has value:", result2.IsSome())  // false
71    fmt.Println("Default:", result2.UnwrapOr(0.0)) // 0
72
73    // Using Map
74    result3 := divide(10, 2).Map(func(v float64) string {
75        return fmt.Sprintf("Result: %.2f", v)
76    })
77    fmt.Println(result3.UnwrapOr("No result")) // Result: 5.00
78}

Summary

• Generics allow writing type-safe, reusable code
• Use [T any] for any type, [T comparable] for comparable types
• Create custom constraints with interfaces
• Generic types enable type-safe data structures
• Use constraints.Ordered, constraints.Integer, etc. from experimental package
• Type inference often eliminates need for explicit type parameters
• Use generics for algorithms and data structures, not everything
• Keep it simple - add generics when you have actual duplication
• Generics vs Reflection: Use generics for known types needing performance, reflection for unknown types needing flexibility
• Advanced patterns: Generic graphs, priority queues, tries, and repositories
• Constraint composition: Combine multiple constraints for complex requirements
• Type inference: Understand when compiler needs explicit types
• Production patterns: Result types, builders, and repositories with generics
• Performance: Zero runtime overhead - same as concrete types

Master generics and write more reusable, type-safe Go code!