泛型详解：类型参数、约束与 GC Shape Stenciling 实现

本文以 Go 1.22 为基准版本，深入解析 Go 1.18 引入的泛型机制：类型参数语法、约束系统、类型推断算法、runtime 实现（GC shape stenciling）、泛型算法库设计与生产级最佳实践。适用于已掌握 Go 接口与反射、希望编写可复用类型安全代码的工程师。

1. 学习目标

本节使用 Bloom 分类法（Bloom’s Taxonomy）描述完成本文学习后应达到的认知层级。

1.1 Remember（记忆）

• 准确复述类型参数语法：func F[T any](x T) T、type Stack[T any] struct{...}。
• 列出 constraints 包提供的标准约束：Ordered、Signed、Unsigned、Integer、Float、Complex。
• 背诵泛型三要素：类型参数（type parameter）、类型实参（type argument）、类型约束（type constraint）。
• 复述 comparable 约束的语义：支持 == 与 != 比较。

1.2 Understand（理解）

• 解释类型推断算法：从函数实参推断类型参数的过程。
• 描述 GC shape stenciling 实现策略：按 GC 形状分组生成代码，而非每个类型生成一份。
• 阐述泛型与接口的区别：泛型是编译期多态，接口是运行期多态。
• 说明约束的底层机制：约束本质是 interface，可包含类型集合（type set）。

1.3 Apply（应用）

• 编写泛型容器：Stack[T]、Queue[T]、Set[T comparable]。
• 实现泛型算法：Map、Filter、Reduce、Sort。
• 使用 constraints.Ordered 约束编写通用比较函数。
• 设计泛型函数式工具：Option[T]、Result[T, E]。

1.4 Analyze（分析）

• 分析泛型与接口的性能差异：编译期单态化 vs 运行期虚函数调用。
• 推导类型推断算法的复杂度，指出推断失败的场景。
• 对比 Go 泛型与 C++ templates、Rust generics、Java generics 的实现差异。

1.5 Evaluate（评价）

• 评估”过度泛化”反模式的危害（如为单一类型引入泛型）。
• 评价 GC shape stenciling 的折衷：代码体积 vs 类型安全。
• 判断何时该用泛型而非接口（性能敏感路径用泛型，灵活性优先用接口）。

1.6 Create（创造）

• 设计一个类型安全的 ORM 框架，利用泛型避免 interface{} 转换。
• 实现一个泛型依赖注入容器，支持构造函数注入。
• 基于泛型设计一个分布式任务队列，支持自定义任务类型与结果类型。

2. 历史动机与发展脉络

2.1 设计动机（2010-2017）

Go 自 2009 年发布以来，一直缺少泛型支持。开发者通过以下方式模拟泛型：

1. interface{} + 类型断言：失去类型安全，运行时 panic 风险
2. 代码生成（go generate）：维护成本高，编译时间长
3. 复制粘贴：违反 DRY 原则

Robert Griesemer 与 Rob Pike 在 2010 年就开始研究泛型方案，但受以下因素制约：

• 编译速度：Go 的卖点之一是秒级编译，泛型不能破坏这一特性
• 语法简洁：不能引入复杂的 template<typename T> 语法
• 语义清晰：泛型应保持 Go 的”显式优于隐式”哲学

2.2 类型函数提案（2011-2015）

早期提案采用 type T 关键字：

// 早期提案（未采纳）
func Map(type T, U)(s []T, f func(T) U) []U

被否决原因：语法怪异、与现有语法不协调。

2.3 Contracts 提案（2018）

2018 年的 Contracts 提案引入 contract 关键字：

contract Ordered(T) {
    T < T
    T > T
}

func Max(T Ordered)(a, b T) T {
    if a > b {
        return a
    }
    return b
}

被否决原因：

1. 引入新关键字 contract，增加语言复杂度
2. 语法与 interface 重复
3. 学习成本高

2.4 Type Parameters 提案（2020）

2020 年由 Robert Griesemer 提交的 Type Parameters 提案（issue #43651）最终被采纳：

type Number interface {
    int | int64 | float64
}

func Sum[T Number](nums []T) T {
    var total T
    for _, n := range nums {
        total += n
    }
    return total
}

关键创新：

1. 复用 interface 语法：约束就是 interface，无需新关键字
2. 类型集合（type set）：interface 可包含类型联合 int | float64
3. 类型推断：调用时无需显式指定类型参数
4. 方括号语法：[T any] 避免与函数参数括号冲突

2.5 Go 1.18（2022-03）：泛型正式发布

Go 1.18 由 Matthew Dempsky、Robert Griesemer、Dan Scales 等人完成泛型实现。核心特性：

• 类型参数语法：func F[T any]、type Stack[T any]
• 类型约束：interface + 类型集合
• 标准库 constraints 包（在 golang.org/x/exp/constraints）
• 类型推断：从函数实参推断类型参数
• 泛型类型与方法

2.6 Go 1.19（2022-08）：minor 优化

• 修复泛型相关的内存逃逸问题
• 改进类型推断算法
• 性能优化：减少 GC shape stenciling 的代码体积

2.7 Go 1.20（2023-02）：可比性改进

• 引入 comparable 约束的精确语义
• 修复 comparable 与接口类型的交互问题
• 改进类型集合的算法

2.8 Go 1.21（2023-08）：标准库泛型化

Go 1.21 引入 maps、slices 标准库包，提供泛型工具：

// slices 包
func Sort[T cmp.Ordered](x []T)
func SortFunc[T any](x []T, cmp func(a, b T) int)
func Contains[T comparable](s []T, v T) bool

// maps 包
func Keys[K comparable, V any](m map[K]V) []K
func Values[K comparable, V any](m map[K]V) []V
func Clone[K comparable, V any](m map[K]V) map[K]V

同时引入 cmp 包，提供 Ordered 约束与比较函数。

2.9 Go 1.22（2024-02）：range over function

Go 1.22 引入 range over function 实验特性，与泛型深度集成：

func Map[T, U any](s []T, f func(T) U) []U { ... }

// range over function
for v := range Map([]int{1,2,3}, func(x int) int { return x*2 }) {
    fmt.Println(v)
}

2.10 演进时间轴

2010-2017 ── 早期泛型研究（type function）
   │
2018 ─── Contracts 提案（被否决）
   │
2020 ─── Type Parameters 提案（采纳）
   │
2022 (Go 1.18) ── 泛型正式发布
   │
2023 (Go 1.20) ── comparable 改进
   │
2023 (Go 1.21) ── slices/maps 标准库
   │
2024 (Go 1.22) ── range over function

3. 形式化定义

3.1 类型参数的文法

Go 语言规范对类型参数的文法定义：

TypeParameter     = Identifier TypeConstraint .
TypeConstraint    = TypeElem .

TypeElem          = TypeTerm { "|" TypeTerm } .
TypeTerm          = Type | UnderlyingType .
UnderlyingType    = "~" Type .

TypeParameterList = TypeParameter { "," TypeParameter } .
TypeParameters    = "[" TypeParameterList [ "," ] "]" .

示例：

// 单类型参数
func F[T any](x T) T

// 多类型参数
func Map[T, U any](s []T, f func(T) U) []U

// 类型约束
func Sum[T Number](nums []T) T

// 类型集合（union）
type Number interface {
    int | int64 | float32 | float64
}

// 底层类型（~）
type Stringer interface {
    ~string
    String() string
}

3.2 类型集合（Type Set）的形式化

约束 $C$ 定义了一个类型集合 $\text{TypeSet}(C)$：

类型集合的运算：

• 联合：int | float64 → $\{ \text{int}, \text{float64} \}$
• 交集：interface { int; String() string } → $\{ T \mid T = \text{int} \land T \text{ has String()} \} = \emptyset$
• 底层类型：~string → $\{ T \mid \text{underlying}(T) = \text{string} \}$

3.3 类型可满足性

类型 $T$ 满足约束 $C$ 当且仅当：

或等价地：

3.4 类型推断算法

类型推断可形式化为约束求解问题。给定函数 F[T1, T2, ...] 与调用 F(arg1, arg2, ...)：

1. 为每个参数建立类型方程：$\text{type}(arg_i) = \text{paramType}_i(T_1, ..., T_n)$
2. 求解类型参数 $T_1, ..., T_n$
3. 若解唯一，则推断成功；否则失败

形式化：

3.5 GC Shape Stenciling

Go 泛型的实现策略是 GC shape stenciling，介于完全单态化（C++ templates）与完全装箱（Java generics）之间。

GC shape：类型的内存布局特征，包括：

• 大小（size）
• 对齐（alignment）
• GC 引用图（哪些字段是指针）

规则：所有具有相同 GC shape 的类型共享一份代码。

形式化：

示例：

• *int、*string、*MyStruct：GC shape 相同（都是指针），共享代码
• int、int64：GC shape 相同（都是 8 字节非指针），共享代码
• int、float64：GC shape 相同（都是 8 字节非指针），共享代码
• [8]byte、int64：GC shape 不同（数组 vs 标量），不同代码

3.6 类型系统视角

Go 泛型是 parametric polymorphism（参数化多态）的实现，与以下概念相关：

Go 泛型属于 let-polymorphism（Let 多态），即：

• 类型参数是全称量化（universally quantified）
• 不支持特化（specialization），与 C++ templates 不同
• 类型参数必须是约束范围内的任意类型

4. 理论推导与原理解析

4.1 类型推断算法详解

类型推断分为两个阶段：类型统一（type unification）与类型替换（type substitution）。

4.1.1 类型统一

给定函数签名 F[T1, T2](p1 P1, p2 P2) 与调用 F(a1, a2)，对每个参数建立方程：

求解 $T_1, T_2$ 使得所有方程成立。

示例：

func Map[T, U any](s []T, f func(T) U) []U
Map([]int{1,2,3}, func(x int) string { return fmt.Sprint(x) })

方程：

1. $\text{type}(\text{[]int}\{1,2,3\}) \equiv \text{[]T}$ → $T = \text{int}$
2. $\text{type}(\text{func(int) string}) \equiv \text{func(T) U}$ → $T = \text{int}$, $U = \text{string}$

解：$T = \text{int}$, $U = \text{string}$。

4.1.2 推断失败的常见场景

// 场景 1：从 nil 无法推断
func F[T any](x T) T { return x }
F(nil) // 错误：无法从 nil 推断 T

// 场景 2：未提供参数
func G[T any]() T { var zero T; return zero }
G() // 错误：无法推断 T

// 场景 3：类型冲突
func H[T any](a, b T) T { return a }
H(1, "string") // 错误：T 同时为 int 和 string

4.2 约束的实现机制

约束本质是 interface，编译器对约束进行特殊处理。

4.2.1 类型集合计算

type Number interface {
    int | int64 | float32 | float64
}

编译器计算 Number 的类型集合：

4.2.2 方法集 vs 类型集合

// 类型集合约束
type Stringer interface {
    ~string
    String() string
}

// 等价于
// 1. 底层类型是 string（如 type MyString string）
// 2. 实现 String() string 方法

类型集合与方法集的关系：

• 方法集：$\{ T \mid T \text{ has methods } \}$
• 类型集合：$\{ T \mid T \in \text{union} \land T \text{ has methods } \}$

4.2.3 comparable 约束

type comparable interface {
    comparable // 内置约束
}

comparable 的类型集合是所有支持 == 与 != 的类型：

• 标量类型：int、float64、string、bool、pointer、channel
• 结构体（所有字段 comparable）
• 数组（元素 comparable）

不包括：

• slice、map、func

4.3 GC Shape Stenciling 实现细节

4.3.1 代码生成策略

对每个泛型函数 F[T]，编译器按 GC shape 分组生成代码：

// 源代码
func Max[T constraints.Ordered](a, b T) T {
    if a > b {
        return a
    }
    return b
}

// 编译后（伪代码）
func Max_int(a, b int) int {
    if a > b { return a }
    return b
}

func Max_float64(a, b float64) float64 {
    if a > b { return a }
    return b
}

func Max_string(a, b string) string {
    if a > b { return a }
    return b
}

// 指针类型共享一份代码
func Max_ptr(a, b unsafe.Pointer) unsafe.Pointer {
    // 通过字典（dictionary）传递类型信息
    if comparePtrs(a, b, dict) > 0 { return a }
    return b
}

4.3.2 字典（Dictionary）传递

对于需要运行时类型信息的操作（如 >、<、==），编译器生成一个字典，包含：

• 类型大小（size）
• 对齐（alignment）
• 比较函数指针
• 哈希函数指针
• GC 引用图

// 字典结构（伪代码）
type Dictionary struct {
    typ      *_type           // 类型信息
    equal    func(a, b unsafe.Pointer) bool
    hash     func(ptr unsafe.Pointer) uint64
    compare  func(a, b unsafe.Pointer) int
    // ...
}

4.3.3 性能权衡

Go 的选择动机：

1. 编译速度：避免完全单态化的代码爆炸
2. 二进制体积：GC shape 分组减少重复代码
3. 性能：避免装箱开销
4. GC 兼容：GC shape 包含引用图信息

4.4 泛型函数的内联

泛型函数的内联策略与普通函数不同：

// 普通函数：可内联
func Add(a, b int) int { return a + b }

// 泛型函数：默认不内联
func Add[T Number](a, b T) T { return a + b }

原因：

• 泛型函数通过字典调用，难以内联
• 完全内联会导致代码爆炸

Go 1.22 改进：对部分简单泛型函数支持内联。

4.5 泛型类型的内存布局

type Stack[T any] struct {
    items []T
}

Stack[int] 与 Stack[string] 是不同类型，但内存布局相同（都是 struct{ items []T }，T 通过字典区分）。

var s1 Stack[int]
var s2 Stack[string]
// s1 与 s2 不能互相赋值（类型不同）
// 但 sizeof(s1) == sizeof(s2)（都是 24 字节：slice header）

4.6 类型断言与泛型

泛型类型参数不能直接用于类型断言：

func F[T any](x T) {
    // 错误：不能对类型参数做类型断言
    if s, ok := x.(string); ok { // 编译错误
        fmt.Println(s)
    }

    // 正确：先转为 interface{}
    if s, ok := any(x).(string); ok {
        fmt.Println(s)
    }
}

原因：类型参数 T 在编译期是抽象的，运行时通过字典传递，无法直接断言。

5. 代码示例

5.1 go.mod 配置

// go.mod
module github.com/fandex/go-generic-demo

go 1.22

require (
    golang.org/x/exp v0.0.0-20240112132812-7b3056b8e1e6
)

5.2 基础：泛型函数

// generic_basic.go
package main

import (
    "fmt"
    "strings"
)

// 1. 单类型参数
func Identity[T any](x T) T {
    return x
}

// 2. 多类型参数
func Map[T, U any](s []T, f func(T) U) []U {
    result := make([]U, len(s))
    for i, v := range s {
        result[i] = f(v)
    }
    return result
}

// 3. 泛型过滤
func Filter[T any](s []T, pred func(T) bool) []T {
    result := make([]T, 0, len(s))
    for _, v := range s {
        if pred(v) {
            result = append(result, v)
        }
    }
    return result
}

// 4. 泛型归约
func Reduce[T, U any](s []T, init U, f func(U, T) U) U {
    result := init
    for _, v := range s {
        result = f(result, v)
    }
    return result
}

func main() {
    // 1. Identity
    fmt.Println(Identity(42))         // 42
    fmt.Println(Identity("hello"))    // hello

    // 2. Map
    nums := []int{1, 2, 3, 4, 5}
    doubled := Map(nums, func(n int) int { return n * 2 })
    fmt.Println(doubled) // [2 4 6 8 10]

    strs := Map(nums, func(n int) string {
        return fmt.Sprintf("num-%d", n)
    })
    fmt.Println(strs) // [num-1 num-2 num-3 num-4 num-5]

    // 3. Filter
    evens := Filter(nums, func(n int) bool { return n%2 == 0 })
    fmt.Println(evens) // [2 4]

    // 4. Reduce
    sum := Reduce(nums, 0, func(acc, n int) int { return acc + n })
    fmt.Println(sum) // 15

    concat := Reduce([]string{"a", "b", "c"}, "", func(acc, s string) string {
        return acc + s
    })
    fmt.Println(concat) // abc

    // 5. 链式调用
    result := Reduce(
        Filter(
            Map(nums, func(n int) int { return n * n }),
            func(n int) bool { return n > 5 },
        ),
        0,
        func(acc, n int) int { return acc + n },
    )
    fmt.Println(result) // 9 + 16 + 25 = 50

    _ = strings.Builder{}
}

5.3 约束（Constraints）

// generic_constraints.go
package main

import (
    "fmt"
    "golang.org/x/exp/constraints"
)

// 1. 使用标准约束
func Max[T constraints.Ordered](a, b T) T {
    if a > b {
        return a
    }
    return b
}

func Min[T constraints.Ordered](a, b T) T {
    if a < b {
        return a
    }
    return b
}

// 2. 自定义约束
type Number interface {
    int | int8 | int16 | int32 | int64 |
    float32 | float64
}

func Sum[T Number](nums []T) T {
    var total T
    for _, n := range nums {
        total += n
    }
    return total
}

// 3. 嵌套约束
type Integer interface {
    constraints.Signed | constraints.Unsigned
}

func Abs[T Integer](x T) T {
    if x < 0 {
        return -x
    }
    return x
}

// 4. 底层类型约束（~）
type MyString string

type Stringer interface {
    ~string
}

func Length[T Stringer](s T) int {
    return len(string(s))
}

// 5. comparable 约束
func Contains[T comparable](s []T, target T) bool {
    for _, v := range s {
        if v == target {
            return true
        }
    }
    return false
}

func Unique[T comparable](s []T) []T {
    seen := make(map[T]bool)
    result := make([]T, 0, len(s))
    for _, v := range s {
        if !seen[v] {
            seen[v] = true
            result = append(result, v)
        }
    }
    return result
}

func main() {
    // 1. Ordered 约束
    fmt.Println(Max(3, 5))           // 5
    fmt.Println(Max("apple", "banana")) // banana
    fmt.Println(Max(3.14, 2.71))     // 3.14

    // 2. 自定义 Number 约束
    fmt.Println(Sum([]int{1, 2, 3}))           // 6
    fmt.Println(Sum([]float64{1.1, 2.2}))      // 3.3

    // 3. Integer 约束
    fmt.Println(Abs(-5))  // 5
    fmt.Println(Abs(5))   // 5

    // 4. 底层类型约束
    var s MyString = "hello"
    fmt.Println(Length(s)) // 5

    // 5. comparable
    fmt.Println(Contains([]int{1, 2, 3}, 2)) // true
    fmt.Println(Unique([]int{1, 2, 2, 3, 3, 3})) // [1 2 3]
}

5.4 泛型类型

// generic_types.go
package main

import (
    "fmt"
)

// 1. 泛型栈
type Stack[T any] struct {
    items []T
}

func (s *Stack[T]) Push(item T) {
    s.items = append(s.items, item)
}

func (s *Stack[T]) Pop() (T, bool) {
    var zero T
    if len(s.items) == 0 {
        return zero, false
    }
    top := s.items[len(s.items)-1]
    s.items = s.items[:len(s.items)-1]
    return top, true
}

func (s *Stack[T]) Len() int {
    return len(s.items)
}

// 2. 泛型队列
type Queue[T any] struct {
    items []T
}

func (q *Queue[T]) Enqueue(item T) {
    q.items = append(q.items, item)
}

func (q *Queue[T]) Dequeue() (T, bool) {
    var zero T
    if len(q.items) == 0 {
        return zero, false
    }
    front := q.items[0]
    q.items = q.items[1:]
    return front, true
}

// 3. 泛型集合（Set）
type Set[T comparable] struct {
    items map[T]struct{}
}

func NewSet[T comparable]() *Set[T] {
    return &Set[T]{items: make(map[T]struct{})}
}

func (s *Set[T]) Add(item T) {
    s.items[item] = struct{}{}
}

func (s *Set[T]) Remove(item T) {
    delete(s.items, item)
}

func (s *Set[T]) Contains(item T) bool {
    _, ok := s.items[item]
    return ok
}

func (s *Set[T]) Size() int {
    return len(s.items)
}

// 4. 泛型键值对
type Pair[K comparable, V any] struct {
    Key   K
    Value V
}

func NewPair[K comparable, V any](k K, v V) *Pair[K, V] {
    return &Pair[K, V]{Key: k, Value: v}
}

// 5. 泛型 Optional
type Optional[T any] struct {
    value T
    ok    bool
}

func Some[T any](v T) Optional[T] {
    return Optional[T]{value: v, ok: true}
}

func None[T any]() Optional[T] {
    return Optional[T]{ok: false}
}

func (o Optional[T]) Get() (T, bool) {
    return o.value, o.ok
}

func (o Optional[T]) IsPresent() bool {
    return o.ok
}

func main() {
    // 1. Stack
    stack := &Stack[int]{}
    stack.Push(1)
    stack.Push(2)
    stack.Push(3)
    fmt.Println(stack.Len()) // 3
    if v, ok := stack.Pop(); ok {
        fmt.Println(v) // 3
    }

    // 2. Queue
    queue := &Queue[string]{}
    queue.Enqueue("a")
    queue.Enqueue("b")
    if v, ok := queue.Dequeue(); ok {
        fmt.Println(v) // a
    }

    // 3. Set
    set := NewSet[int]()
    set.Add(1)
    set.Add(2)
    set.Add(1) // 重复
    fmt.Println(set.Size()) // 2
    fmt.Println(set.Contains(1)) // true

    // 4. Pair
    p := NewPair("name", "Alice")
    fmt.Printf("%s: %s\n", p.Key, p.Value)

    // 5. Optional
    opt := Some(42)
    if v, ok := opt.Get(); ok {
        fmt.Println(v) // 42
    }

    empty := None[string]()
    fmt.Println(empty.IsPresent()) // false
}

5.5 函数式工具：Option 与 Result

// functional.go
package main

import (
    "errors"
    "fmt"
)

// Result 类型（类似 Rust 的 Result<T, E>）
type Result[T any, E error] struct {
    value T
    err   E
}

func Ok[T any, E error](v T) Result[T, E] {
    return Result[T, E]{value: v}
}

func Err[T any, E error](err E) Result[T, E] {
    return Result[T, E]{err: err}
}

func (r Result[T, E]) Unwrap() T {
    if r.err != nil {
        panic(r.err)
    }
    return r.value
}

func (r Result[T, E]) UnwrapOr(defaultValue T) T {
    if r.err != nil {
        return defaultValue
    }
    return r.value
}

func (r Result[T, E]) IsOk() bool {
    return r.err == nil
}

func (r Result[T, E]) Map(f func(T) T) Result[T, E] {
    if r.err != nil {
        return r
    }
    return Ok[T, E](f(r.value))
}

func (r Result[T, E]) AndThen(f func(T) Result[T, E]) Result[T, E] {
    if r.err != nil {
        return r
    }
    return f(r.value)
}

// 业务错误
type BusinessError struct {
    Code int
    Msg  string
}

func (e *BusinessError) Error() string {
    return fmt.Sprintf("[%d] %s", e.Code, e.Msg)
}

// 模拟数据库查询
func queryUser(id int) Result[string, *BusinessError] {
    if id <= 0 {
        return Err[string, *BusinessError](&BusinessError{Code: 400, Msg: "invalid id"})
    }
    return Ok[string, *BusinessError](fmt.Sprintf("user-%d", id))
}

func main() {
    // 使用 Result
    result := queryUser(42)
    if result.IsOk() {
        fmt.Println("found:", result.Unwrap())
    }

    // 链式调用
    chain := queryUser(42).
        Map(func(s string) string { return "Mr. " + s }).
        AndThen(func(s string) Result[string, *BusinessError] {
            if len(s) > 10 {
                return Err[string, *BusinessError](&BusinessError{Code: 413, Msg: "too long"})
            }
            return Ok[string, *BusinessError](s)
        })

    fmt.Println(chain.UnwrapOr("default"))

    // 错误处理
    errResult := queryUser(-1)
    if !errResult.IsOk() {
        fmt.Println("error:", errResult.err)
    }

    _ = errors.New
}

5.6 泛型与接口结合

// generic_interface.go
package main

import (
    "fmt"
)

// 泛型接口
type Repository[T any] interface {
    Get(id int) (T, error)
    Save(item T) error
    Delete(id int) error
    List() ([]T, error)
}

// User 类型
type User struct {
    ID   int
    Name string
}

// UserRepository 实现 Repository[User]
type UserRepository struct {
    users map[int]User
}

func NewUserRepository() *UserRepository {
    return &UserRepository{users: make(map[int]User)}
}

func (r *UserRepository) Get(id int) (User, error) {
    if u, ok := r.users[id]; ok {
        return u, nil
    }
    return User{}, fmt.Errorf("user %d not found", id)
}

func (r *UserRepository) Save(item User) error {
    r.users[item.ID] = item
    return nil
}

func (r *UserRepository) Delete(id int) error {
    if _, ok := r.users[id]; !ok {
        return fmt.Errorf("user %d not found", id)
    }
    delete(r.users, id)
    return nil
}

func (r *UserRepository) List() ([]User, error) {
    result := make([]User, 0, len(r.users))
    for _, u := range r.users {
        result = append(result, u)
    }
    return result, nil
}

// 泛型服务
type Service[T any] struct {
    repo Repository[T]
}

func NewService[T any](repo Repository[T]) *Service[T] {
    return &Service[T]{repo: repo}
}

func (s *Service[T]) GetItem(id int) (T, error) {
    return s.repo.Get(id)
}

func (s *Service[T]) SaveItem(item T) error {
    return s.repo.Save(item)
}

func main() {
    repo := NewUserRepository()
    repo.Save(User{ID: 1, Name: "Alice"})
    repo.Save(User{ID: 2, Name: "Bob"})

    service := NewService[User](repo)
    user, err := service.GetItem(1)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(user) // {1 Alice}

    users, _ := repo.List()
    fmt.Println(users) // [{1 Alice} {2 Bob}]
}

5.7 泛型并发工具

// generic_concurrent.go
package main

import (
    "context"
    "fmt"
    "sync"
    "time"
)

// 并发 Map
func ConcurrentMap[T, U any](ctx context.Context, items []T, worker int, f func(T) U) []U {
    results := make([]U, len(items))
    sem := make(chan struct{}, worker)
    var wg sync.WaitGroup

    for i, item := range items {
        wg.Add(1)
        sem <- struct{}{}
        go func(idx int, v T) {
            defer wg.Done()
            defer func() { <-sem }()
            select {
            case <-ctx.Done():
                return
            default:
                results[idx] = f(v)
            }
        }(i, item)
    }
    wg.Wait()
    return results
}

// 泛型 Future
type Future[T any] struct {
    result chan T
    err    chan error
}

func NewFuture[T any](f func() (T, error)) *Future[T] {
    fut := &Future[T]{
        result: make(chan T, 1),
        err:    make(chan error, 1),
    }
    go func() {
        v, err := f()
        fut.result <- v
        fut.err <- err
    }()
    return fut
}

func (f *Future[T]) Await() (T, error) {
    var zero T
    select {
    case v := <-f.result:
        return v, <-f.err
    case err := <-f.err:
        return zero, err
    }
}

// 泛型 Worker Pool
type WorkerPool[Job any, Result any] struct {
    jobs    chan Job
    results chan Result
    worker  func(Job) Result
    wg      sync.WaitGroup
}

func NewWorkerPool[Job any, Result any](size int, worker func(Job) Result) *WorkerPool[Job, Result] {
    p := &WorkerPool[Job, Result]{
        jobs:    make(chan Job, size*2),
        results: make(chan Result, size*2),
        worker:  worker,
    }
    for i := 0; i < size; i++ {
        p.wg.Add(1)
        go func() {
            defer p.wg.Done()
            for job := range p.jobs {
                p.results <- p.worker(job)
            }
        }()
    }
    return p
}

func (p *WorkerPool[Job, Result]) Submit(job Job) {
    p.jobs <- job
}

func (p *WorkerPool[Job, Result]) Results() <-chan Result {
    return p.results
}

func (p *WorkerPool[Job, Result]) Shutdown() {
    close(p.jobs)
    p.wg.Wait()
    close(p.results)
}

func main() {
    // 1. ConcurrentMap
    ctx := context.Background()
    nums := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    squares := ConcurrentMap(ctx, nums, 4, func(n int) int {
        time.Sleep(10 * time.Millisecond)
        return n * n
    })
    fmt.Println(squares)

    // 2. Future
    fut := NewFuture(func() (int, error) {
        time.Sleep(50 * time.Millisecond)
        return 42, nil
    })
    v, err := fut.Await()
    fmt.Println(v, err) // 42 <nil>

    // 3. Worker Pool
    pool := NewWorkerPool(3, func(n int) string {
        return fmt.Sprintf("job-%d", n)
    })
    for i := 1; i <= 5; i++ {
        pool.Submit(i)
    }
    go func() {
        for r := range pool.Results() {
            fmt.Println(r)
        }
    }()
    pool.Shutdown()
    time.Sleep(100 * time.Millisecond)
}

5.8 使用标准库 slices 与 maps

// stdlib_generics.go
package main

import (
    "cmp"
    "fmt"
    "maps"
    "slices"
)

func main() {
    // 1. slices.Sort
    nums := []int{3, 1, 4, 1, 5, 9, 2, 6}
    slices.Sort(nums)
    fmt.Println(nums) // [1 1 2 3 4 5 6 9]

    // 2. slices.SortFunc（自定义比较）
    type Person struct {
        Name string
        Age  int
    }
    people := []Person{
        {"Alice", 30},
        {"Bob", 25},
        {"Charlie", 35},
    }
    slices.SortFunc(people, func(a, b Person) int {
        return cmp.Compare(a.Age, b.Age)
    })
    fmt.Println(people) // [{Bob 25} {Alice 30} {Charlie 35}]

    // 3. slices.Contains
    fmt.Println(slices.Contains(nums, 4)) // true
    fmt.Println(slices.Contains(nums, 100)) // false

    // 4. slices.Reverse
    slices.Reverse(nums)
    fmt.Println(nums) // [9 6 5 4 3 2 1 1]

    // 5. slices.Index
    fmt.Println(slices.Index(nums, 5)) // 2

    // 6. maps.Keys
    m := map[string]int{"a": 1, "b": 2, "c": 3}
    keys := maps.Keys(m)
    slices.Sort(keys)
    fmt.Println(keys) // [a b c]

    // 7. maps.Values
    values := maps.Values(m)
    slices.Sort(values)
    fmt.Println(values) // [1 2 3]

    // 8. maps.Clone
    cloned := maps.Clone(m)
    fmt.Println(cloned)

    // 9. slices.Clone
    src := []int{1, 2, 3}
    dst := slices.Clone(src)
    fmt.Println(dst)
}

5.9 Benchmark：泛型 vs 接口

// generic_bench_test.go
package main

import (
    "testing"
)

// 接口版本
type Adder interface {
    Add(b int) int
}

type IntAdder int

func (a IntAdder) Add(b int) int {
    return int(a) + b
}

func SumInterface(s []Adder) int {
    total := 0
    for _, v := range s {
        total += v.Add(1)
    }
    return total
}

// 泛型版本
func SumGeneric[T ~int](s []T) T {
    var total T
    for _, v := range s {
        total += v + 1
    }
    return total
}

// 直接版本（非泛型）
func SumDirect(s []int) int {
    total := 0
    for _, v := range s {
        total += v + 1
    }
    return total
}

// BenchmarkInterface 接口版本
func BenchmarkInterface(b *testing.B) {
    s := make([]Adder, 1000)
    for i := range s {
        s[i] = IntAdder(i)
    }
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        _ = SumInterface(s)
    }
}

// BenchmarkGeneric 泛型版本
func BenchmarkGeneric(b *testing.B) {
    s := make([]int, 1000)
    for i := range s {
        s[i] = i
    }
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        _ = SumGeneric(s)
    }
}

// BenchmarkDirect 直接版本
func BenchmarkDirect(b *testing.B) {
    s := make([]int, 1000)
    for i := range s {
        s[i] = i
    }
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        _ = SumDirect(s)
    }
}

典型结果（Go 1.22, MacBook Pro M2）：

BenchmarkInterface-8   5000000   240 ns/op
BenchmarkGeneric-8     20000000  60 ns/op
BenchmarkDirect-8      20000000  58 ns/op

结论：泛型版本性能接近直接版本，比接口版本快 4 倍（无虚函数调用开销）。

6. 对比分析

6.1 与 C++ Templates 对比

C++ 示例：

template<typename T>
T sum(const std::vector<T>& nums) {
    T total = T();
    for (const auto& n : nums) total += n;
    return total;
}

// 特化（Go 不支持）
template<>
std::string sum<std::string>(const std::vector<std::string>& strs) {
    std::string result;
    for (const auto& s : strs) result += s;
    return result;
}

6.2 与 Rust Generics 对比

Rust 示例：

fn sum<T: std::ops::Add<Output = T> + Default>(nums: &[T]) -> T {
    nums.iter().fold(T::default(), |acc, n| acc + *n)
}

// 关联类型（Go 不支持）
trait Container {
    type Item;
    fn get(&self, idx: usize) -> Option<&Self::Item>;
}

6.3 与 Java Generics 对比

Java 示例：

public static <T extends Number> T sum(List<T> nums) {
    T total = ...; // 无法直接创建 T 的实例
    for (T n : nums) {
        // total += n; // 编译错误，T 不保证有 += 操作
    }
    return total;
}

// 类型擦除后等价于
public static Number sum(List nums) { ... }

6.4 与 C# Generics 对比

C# 示例：

public static T Sum<T>(List<T> nums) where T : struct, IAddable<T> {
    T total = default(T);
    foreach (var n in nums) total += n;
    return total;
}

6.5 综合评价

7. 常见陷阱与最佳实践

7.1 陷阱一：过度泛化

// 反模式：为单一类型引入泛型
type UserIDs struct{} // 仅用于 int
func (u *UserIDs) Add(id int) { ... }

// 过度泛化：泛型不增加任何价值
type IDs[T any] struct{}
func (u *IDs[T]) Add(id T) { ... } // 但实际只用 int

// 正确：直接使用具体类型
type UserIDs struct{}
func (u *UserIDs) Add(id int) { ... }

7.2 陷阱二：约束过宽

// 反模式：约束过宽，无法使用具体方法
func Print[T any](x T) {
    // x.String() // 编译错误，T 不保证有 String()
    fmt.Println(x)
}

// 正确：使用具体约束
type Stringer interface {
    String() string
}

func Print[T Stringer](x T) {
    fmt.Println(x.String())
}

7.3 陷阱三：忽略类型推断失败

// 反模式：依赖类型推断，但推断失败
func F[T any](x T) T { return x }
result := F(nil) // 错误：无法从 nil 推断 T

// 正确：显式指定类型
result := F[int](0)

7.4 陷阱四：泛型方法接收者类型不一致

// 反模式：方法接收者类型不一致
type Stack[T any] struct {
    items []T
}

// 错误：接收者是 *Stack[T]，但调用时可能是值
func (s Stack[T]) Pop() (T, bool) { // 接收者是值
    // 修改 s.items 不影响原 Stack
    ...
}

// 正确：修改状态用指针接收者
func (s *Stack[T]) Pop() (T, bool) {
    ...
}

7.5 陷阱五：在泛型函数中使用类型断言

// 反模式：直接对类型参数断言
func F[T any](x T) {
    if s, ok := x.(string); ok { // 编译错误
        fmt.Println(s)
    }
}

// 正确：先转为 any
func F[T any](x T) {
    if s, ok := any(x).(string); ok {
        fmt.Println(s)
    }
}

7.6 陷阱六：约束嵌套过深

// 反模式：约束嵌套导致复杂度爆炸
type ComplexConstraint interface {
    comparable
    ~int | ~int64 | ~float64
    String() string
    Hash() uint64
}

// 正确：拆分约束
type Hashable interface {
    comparable
    Hash() uint64
}

7.7 陷阱七：泛型与 goroutine 泄漏

// 反模式：泛型函数中启动 goroutine 但未处理取消
func Process[T any](items []T, f func(T)) {
    for _, item := range items {
        go f(item) // goroutine 泄漏风险
    }
}

// 正确：使用 context 与 WaitGroup
func Process[T any](ctx context.Context, items []T, f func(context.Context, T)) {
    var wg sync.WaitGroup
    for _, item := range items {
        wg.Add(1)
        go func(item T) {
            defer wg.Done()
            f(ctx, item)
        }(item)
    }
    wg.Wait()
}

7.8 最佳实践清单

1. 优先使用具体类型：泛型不是银弹，单一类型用具体类型
2. 约束最小化：只声明必需的方法与类型
3. 复用标准库：slices、maps、cmp 优先
4. 避免类型断言：泛型函数内尽量不用 any(x).(T)
5. 指针接收者：修改状态的方法用 *Stack[T]
6. 显式指定类型：推断失败时显式指定
7. 测试覆盖：泛型代码需多类型测试
8. 性能验证：关键路径用 benchmark 验证
9. 文档清晰：约束的语义需明确说明
10. 避免过度抽象：YAGNI（You Aren’t Gonna Need It）

8. 工程实践

8.1 项目组织

go-generic-demo/
├── go.mod
├── go.sum
├── constraints/
│   └── constraints.go  # 自定义约束
├── containers/
│   ├── stack.go        # 泛型栈
│   ├── queue.go        # 泛型队列
│   ├── set.go          # 泛型集合
│   └── *_test.go
├── functional/
│   ├── option.go       # Optional[T]
│   ├── result.go       # Result[T, E]
│   ├── map_filter.go   # Map/Filter/Reduce
│   └── *_test.go
├── repository/
│   ├── repository.go   # 泛型 Repository 接口
│   ├── memory.go       # 内存实现
│   └── *_test.go
└── cmd/
    └── server/
        └── main.go

8.2 泛型 Repository 模式

// repository/repository.go
package repository

import (
    "context"
    "errors"
)

// Entity 实体接口
type Entity interface {
    GetID() int
}

// Repository 泛型仓库接口
type Repository[T Entity] interface {
    Get(ctx context.Context, id int) (T, error)
    Save(ctx context.Context, item T) error
    Delete(ctx context.Context, id int) error
    List(ctx context.Context) ([]T, error)
}

// ErrNotFound 未找到错误
var ErrNotFound = errors.New("not found")

// MemoryRepository 内存仓库实现
type MemoryRepository[T Entity] struct {
    items map[int]T
}

func NewMemoryRepository[T Entity]() *MemoryRepository[T] {
    return &MemoryRepository[T]{items: make(map[int]T)}
}

func (r *MemoryRepository[T]) Get(ctx context.Context, id int) (T, error) {
    var zero T
    select {
    case <-ctx.Done():
        return zero, ctx.Err()
    default:
    }
    if item, ok := r.items[id]; ok {
        return item, nil
    }
    return zero, ErrNotFound
}

func (r *MemoryRepository[T]) Save(ctx context.Context, item T) error {
    select {
    case <-ctx.Done():
        return ctx.Err()
    default:
    }
    r.items[item.GetID()] = item
    return nil
}

func (r *MemoryRepository[T]) Delete(ctx context.Context, id int) error {
    select {
    case <-ctx.Done():
        return ctx.Err()
    default:
    }
    if _, ok := r.items[id]; !ok {
        return ErrNotFound
    }
    delete(r.items, id)
    return nil
}

func (r *MemoryRepository[T]) List(ctx context.Context) ([]T, error) {
    select {
    case <-ctx.Done():
        return nil, ctx.Err()
    default:
    }
    result := make([]T, 0, len(r.items))
    for _, item := range r.items {
        result = append(result, item)
    }
    return result, nil
}

8.3 泛型 ORM 设计

// orm/orm.go
package orm

import (
    "context"
    "database/sql"
    "reflect"
)

// Model 模型接口
type Model interface {
    TableName() string
}

// DB 泛型数据库
type DB[T Model] struct {
    conn *sql.DB
}

func New[T Model](conn *sql.DB) *DB[T] {
    return &DB[T]{conn: conn}
}

// Query 查询
func (db *DB[T]) Query(ctx context.Context, query string, args ...any) ([]T, error) {
    rows, err := db.conn.QueryContext(ctx, query, args...)
    if err != nil {
        return nil, err
    }
    defer rows.Close()

    var result []T
    for rows.Next() {
        var item T
        // 使用反射扫描行（实际 ORM 用代码生成）
        if err := scanRow(rows, &item); err != nil {
            return nil, err
        }
        result = append(result, item)
    }
    return result, nil
}

// Insert 插入
func (db *DB[T]) Insert(ctx context.Context, item T) error {
    // 简化实现
    _, err := db.conn.ExecContext(ctx, "INSERT INTO "+item.TableName()+" VALUES (?)", item)
    return err
}

func scanRow(rows *sql.Rows, dest any) error {
    // 实际实现使用反射
    v := reflect.ValueOf(dest).Elem()
    _ = v
    return rows.Scan(dest)
}

8.4 pprof 分析泛型开销

// pprof_generics.go
package main

import (
    "log"
    "net/http"
    _ "net/http/pprof"
)

func heavyGeneric[T int](n int) T {
    var result T
    for i := 0; i < n; i++ {
        result += T(i)
    }
    return result
}

func main() {
    go func() {
        log.Println(http.ListenAndServe("localhost:6060", nil))
    }()
    for i := 0; i < 1000000; i++ {
        _ = heavyGeneric[int](1000)
    }
}

分析：

go tool pprof http://localhost:6060/debug/pprof/profile
(pprof) top
(pprof) list heavyGeneric

8.5 泛型测试策略

// stack_test.go
package main

import (
    "testing"
)

func TestStackInt(t *testing.T) {
    s := &Stack[int]{}
    s.Push(1)
    s.Push(2)
    if v, ok := s.Pop(); !ok || v != 2 {
        t.Errorf("expected 2, got %v", v)
    }
}

func TestStackString(t *testing.T) {
    s := &Stack[string]{}
    s.Push("a")
    s.Push("b")
    if v, ok := s.Pop(); !ok || v != "b" {
        t.Errorf("expected b, got %v", v)
    }
}

// 泛型测试助手
func TestStackGeneric[T comparable](t *testing.T, items []T) {
    s := &Stack[T]{}
    for _, item := range items {
        s.Push(item)
    }
    for i := len(items) - 1; i >= 0; i-- {
        v, ok := s.Pop()
        if !ok || v != items[i] {
            t.Errorf("expected %v, got %v", items[i], v)
        }
    }
}

func TestStackAllTypes(t *testing.T) {
    t.Run("int", func(t *testing.T) {
        TestStackGeneric(t, []int{1, 2, 3})
    })
    t.Run("string", func(t *testing.T) {
        TestStackGeneric(t, []string{"a", "b", "c"})
    })
}

8.6 调试技巧

8.6.1 查看泛型实例化

# 查看泛型实例化
go build -gcflags='-m' ./...

# 输出类似：
# ./main.go:10:6: instantiated Sum[int]
# ./main.go:10:6: instantiated Sum[float64]

8.6.2 使用 go tool objdump

go build -o app ./cmd/server
go tool objdump -s Sum app | head
# 查看实际生成的代码

8.6.3 类型断言调试

// 调试类型参数
func DebugType[T any](x T) {
    fmt.Printf("type: %T, value: %v\n", x, x)
}

9. 案例研究

9.1 标准库 slices 包

Go 1.21 引入的 slices 包是泛型的典型应用（slices/slices.go）：

// slices/slices.go
func Sort[T cmp.Ordered](x []T) {
    n := len(x)
    if n <= 1 {
        return
    }
    // 使用 pdqsort（pattern-defeating quicksort）
    pdqsort(x, 0, n, 0)
}

func SortFunc[T any](x []T, cmp func(a, b T) int) {
    n := len(x)
    if n <= 1 {
        return
    }
    // 自定义比较函数的 pdqsort
    pdqsortFunc(x, 0, n, 0, cmp)
}

func Contains[T comparable](s []T, v T) bool {
    return Index(s, v) >= 0
}

func Index[T comparable](s []T, v T) int {
    for i, x := range s {
        if v == x {
            return i
        }
    }
    return -1
}

func Clone[T any](s []T) []T {
    return append([]T(nil), s...)
}

func Reverse[T any](s []T) {
    for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {
        s[i], s[j] = s[j], s[i]
    }
}