1
func SumInts(numbers []int) int {
2
    var total int
3
    for _, n := range numbers {
4
        total += n
5
    }
6
    return total
7
}
8

9
func SumFloat64s(numbers []float64) float64 {
10
    var total float64
11
    for _, n := range numbers {
12
        total += n
13
    }
14
    return total
15
}
16

17
// 还需要为 int64、float32 等类型编写类似函数...

1
func Sum(numbers []any) (any, error) {
2
    if len(numbers) == 0 {
3
        return 0, nil
4
    }
5

6
    switch numbers[0].(type) {
7
    case int:
8
        var total int
9
        for _, n := range numbers {
10
            if v, ok := n.(int); ok {
11
                total += v
12
            }
13
        }
14
        return total, nil
15
    case float64:
16
        var total float64
17
        for _, n := range numbers {
18
            if v, ok := n.(float64); ok {
19
                total += v
20
            }
21
        }
22
        return total, nil
23
    default:
24
        return nil, fmt.Errorf("unsupported type")
25
    }
26
}

1
//go:generate go run gen_sum.go -type=int,float64
2

3
// 生成的代码会被写入 sum_int.go 和 sum_float64.go

1
// 泛型函数
2
func Sum[T int | float64](numbers []T) T {
3
    var total T
4
    for _, n := range numbers {
5
        total += n
6
    }
7
    return total
8
}
9

10
// 调用
11
ints := []int{1, 2, 3}
12
floats := []float64{1.5, 2.5, 3.5}
13

14
fmt.Println(Sum(ints))    // 6
15
fmt.Println(Sum(floats))  // 7.5

1
func Pair[K comparable, V any](key K, value V) map[K]V {
2
    return map[K]V{key: value}
3
}
4

5
// 调用
6
m := Pair("name", "Golang")  // map[string]string
7
m2 := Pair(1, 3.14)          // map[int]float64

1
// 显式指定类型参数
2
Sum[int]([]int{1, 2, 3})
3

4
// 编译器自动推断（推荐）
5
Sum([]int{1, 2, 3})

1
func Process[T any](value T) T { return value }
2

3
// 从参数推断
4
Process(42)        // T 推断为 int
5
Process("hello")   // T 推断为 string
6

7
// 从返回值推断
8
var result int = Process(42)  // T 推断为 int
9

10
// 无法推断时需要显式指定
11
Process[int](nil)  // 明确指定 T 为 int

1
func Example[T any]() {
2
    // T 在这里有效
3
    var x T
4

5
    // 嵌套函数可以使用外层的 T
6
    f := func(v T) T {
7
        return v
8
    }
9
    _ = f
10
}
11

12
// 类型参数不能用于声明新的类型参数
13
// 错误示例：
14
// func Wrong[T any, U T]() {}  // 编译错误：T 不是类型

1
// 类型约束定义了类型参数的能力
2
type Number interface {
3
    int | int8 | int16 | int32 | int64 |
4
    uint | uint8 | uint16 | uint32 | uint64 |
5
    float32 | float64
6
}
7

8
func Sum[T Number](numbers []T) T {
9
    var total T
10
    for _, n := range numbers {
11
        total += n
12
    }
13
    return total
14
}

1
// 要求类型必须实现 String() 方法
2
type Stringer interface {
3
    String() string
4
}
5

6
// 组合类型联合与方法集
7
type StringableOrdered interface {
8
    Ordered        // 嵌入其他约束
9
    String() string // 方法要求
10
}
11

12
func PrintAndCompare[T StringableOrdered](a, b T) {
13
    fmt.Printf("a: %s, b: %s\n", a.String(), b.String())
14
    if a > b {
15
        fmt.Println("a is greater")
16
    } else if a < b {
17
        fmt.Println("b is greater")
18
    } else {
19
        fmt.Println("equal")
20
    }
21
}

1
type MyInt int
2

3
// 不使用 ~：MyInt 不匹配
4
func WithoutTilde[T int](v T) T { return v }
5
// WithoutTilde(MyInt(42))  // 编译错误！
6

7
// 使用 ~：MyInt 匹配
8
func WithTilde[T ~int](v T) T { return v }
9
WithTilde(MyInt(42))  // 正确！
10

11
// 实际应用
12
type Signed interface {
13
    ~int | ~int8 | ~int16 | ~int32 | ~int64
14
}

1
// 错误示例
2
type Bad interface {
3
    ~[]T        // 错误：T 未定义
4
    ~*int       // 错误：不能是指针
5
    ~MyInterface // 错误：不能是接口
6
}

1
// 函数名[类型参数列表](参数列表) 返回值列表
2
func Map[T, U any](slice []T, f func(T) U) []U {
3
    result := make([]U, len(slice))
4
    for i, v := range slice {
5
        result[i] = f(v)
6
    }
7
    return result
8
}
9

10
// 调用
11
nums := []int{1, 2, 3}
12
strs := Map(nums, func(n int) string {
13
    return strconv.Itoa(n)
14
})
15
// strs = ["1", "2", "3"]

1
// 错误示例：方法不能有类型参数
2
type MySlice[T any] []T
3

4
// 错误！方法不能有额外的类型参数
5
// func (s MySlice[T]) Map[U any](f func(T) U) []U { ... }
6

7
// 正确方式：类型参数在类型定义时指定
8
type Slice[T any] []T
9

10
func (s Slice[T]) Filter(predicate func(T) bool) Slice[T] {
11
    result := make(Slice[T], 0)
12
    for _, v := range s {
13
        if predicate(v) {
14
            result = append(result, v)
15
        }
16
    }
17
    return result
18
}

1
// 泛型结构体
2
type Stack[T any] struct {
3
    elements []T
4
}
5

6
// 方法
7
func (s *Stack[T]) Push(v T) {
8
    s.elements = append(s.elements, v)
9
}
10

11
func (s *Stack[T]) Pop() (T, bool) {
12
    var zero T
13
    if len(s.elements) == 0 {
14
        return zero, false
15
    }
16
    index := len(s.elements) - 1
17
    element := s.elements[index]
18
    s.elements = s.elements[:index]
19
    return element, true
20
}
21

22
func (s *Stack[T]) IsEmpty() bool {
23
    return len(s.elements) == 0
24
}
25

26
// 使用
27
stack := Stack[int]{}
28
stack.Push(1)
29
stack.Push(2)
30
v, ok := stack.Pop()  // v=2, ok=true

1
type Node[T any] struct {
2
    Value T
3
    Next  *Node[T]
4
}
5

6
type List[T any] struct {
7
    head *Node[T]
8
    size int
9
}
10

11
func (l *List[T]) Add(value T) {
12
    newNode := &Node[T]{Value: value}
13
    if l.head == nil {
14
        l.head = newNode
15
    } else {
16
        current := l.head
17
        for current.Next != nil {
18
            current = current.Next
19
        }
20
        current.Next = newNode
21
    }
22
    l.size++
23
}
24

25
func (l *List[T]) ForEach(f func(T)) {
26
    for current := l.head; current != nil; current = current.Next {
27
        f(current.Value)
28
    }
29
}
30

31
// 使用
32
list := List[string]{}
33
list.Add("hello")
34
list.Add("world")
35
list.ForEach(func(s string) {
36
    fmt.Println(s)
37
})

1
type Queue[T any] struct {
2
    items []T
3
}
4

5
func (q *Queue[T]) Enqueue(v T) {
6
    q.items = append(q.items, v)
7
}
8

9
func (q *Queue[T]) Dequeue() (T, bool) {
10
    var zero T
11
    if len(q.items) == 0 {
12
        return zero, false
13
    }
14
    item := q.items[0]
15
    q.items = q.items[1:]
16
    return item, true
17
}
18

19
func (q *Queue[T]) Peek() (T, bool) {
20
    var zero T
21
    if len(q.items) == 0 {
22
        return zero, false
23
    }
24
    return q.items[0], true
25
}
26

27
func (q *Queue[T]) Size() int {
28
    return len(q.items)
29
}

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

6
type Map[K comparable, V any] struct {
7
    pairs []Pair[K, V]
8
}
9

10
func (m *Map[K, V]) Set(key K, value V) {
11
    for i, p := range m.pairs {
12
        if p.Key == key {
13
            m.pairs[i].Value = value
14
            return
15
        }
16
    }
17
    m.pairs = append(m.pairs, Pair[K, V]{Key: key, Value: value})
18
}
19

20
func (m *Map[K, V]) Get(key K) (V, bool) {
21
    for _, p := range m.pairs {
22
        if p.Key == key {
23
            return p.Value, true
24
        }
25
    }
26
    var zero V
27
    return zero, false
28
}
29

30
func (m *Map[K, V]) Delete(key K) bool {
31
    for i, p := range m.pairs {
32
        if p.Key == key {
33
            m.pairs = append(m.pairs[:i], m.pairs[i+1:]...)
34
            return true
35
        }
36
    }
37
    return false
38
}

1
// any 等价于 interface{}
2
func Print[T any](v T) {
3
    fmt.Println(v)
4
}
5

6
// 以下调用都合法
7
Print(42)
8
Print("hello")
9
Print([]int{1, 2, 3})
10
Print(struct{ Name string }{"Golang"})

1
// 泛型容器
2
type Box[T any] struct {
3
    Value T
4
}
5

6
// 泛型函数，不关心具体类型
7
func First[T any](slice []T) (T, bool) {
8
    var zero T
9
    if len(slice) == 0 {
10
        return zero, false
11
    }
12
    return slice[0], true
13
}

1
// comparable 支持的类型：
2
// - 布尔值、数值、字符串
3
// - 指针、channel
4
// - 元素类型为 comparable 的数组
5
// - 字段类型都为 comparable 的结构体
6
// 注意：切片、map、函数不可比较
7

8
func Index[T comparable](slice []T, target T) int {
9
    for i, v := range slice {
10
        if v == target {
11
            return i
12
        }
13
    }
14
    return -1
15
}
16

17
// 使用
18
strs := []string{"a", "b", "c"}
19
fmt.Println(Index(strs, "b"))  // 1
20

21
nums := []int{1, 2, 3}
22
fmt.Println(Index(nums, 4))    // -1

1
func Keys[K comparable, V any](m map[K]V) []K {
2
    keys := make([]K, 0, len(m))
3
    for k := range m {
4
        keys = append(keys, k)
5
    }
6
    return keys
7
}
8

9
func Values[K comparable, V any](m map[K]V) []V {
10
    values := make([]V, 0, len(m))
11
    for _, v := range m {
12
        values = append(values, v)
13
    }
14
    return values
15
}
16

17
// 使用
18
m := map[string]int{"a": 1, "b": 2}
19
fmt.Println(Keys(m))    // [a b]（顺序可能不同）
20
fmt.Println(Values(m))  // [1 2]

1
// comparable + Ordered 的组合
2
type ComparableOrdered interface {
3
    comparable
4
    Ordered
5
}
6

7
// 集合操作
8
func Union[T comparable](a, b []T) []T {
9
    seen := make(map[T]bool)
10
    result := make([]T, 0)
11

12
    for _, v := range a {
13
        if !seen[v] {
14
            seen[v] = true
15
            result = append(result, v)
16
        }
17
    }
18
    for _, v := range b {
19
        if !seen[v] {
20
            seen[v] = true
21
            result = append(result, v)
22
        }
23
    }
24
    return result
25
}
26

27
func Intersection[T comparable](a, b []T) []T {
28
    seen := make(map[T]bool)
29
    for _, v := range a {
30
        seen[v] = true
31
    }
32

33
    result := make([]T, 0)
34
    for _, v := range b {
35
        if seen[v] {
36
            result = append(result, v)
37
            seen[v] = false // 避免重复
38
        }
39
    }
40
    return result
41
}

1
import "slices"
2

3
func main() {
4
    nums := []int{3, 1, 4, 1, 5, 9, 2, 6}
5

6
    // 排序
7
    slices.Sort(nums)
8
    fmt.Println(nums)  // [1 1 2 3 4 5 6 9]
9

10
    // 搜索
11
    idx := slices.BinarySearch(nums, 5)
12
    fmt.Println(idx)  // 5
13

14
    // 包含
15
    fmt.Println(slices.Contains(nums, 4))  // true
16
    fmt.Println(slices.Contains(nums, 7))  // false
17

18
    // 比较
19
    a := []int{1, 2, 3}
20
    b := []int{1, 2, 3}
21
    fmt.Println(slices.Equal(a, b))  // true
22

23
    // 删除
24
    nums = slices.Delete(nums, 0, 2)  // 删除索引 0 和 1
25
    fmt.Println(nums)  // [2 3 4 5 6 9]
26

27
    // 反转
28
    slices.Reverse(nums)
29
    fmt.Println(nums)  // [9 6 5 4 3 2]
30

31
    // 复制
32
    copied := slices.Clone(nums)
33
    fmt.Println(copied)
34

35
    // 插入
36
    nums = slices.Insert(nums, 0, 0, 1)
37
    fmt.Println(nums)  // [0 1 9 6 5 4 3 2]
38
}

1
import "maps"
2

3
func main() {
4
    m1 := map[string]int{"a": 1, "b": 2, "c": 3}
5
    m2 := map[string]int{"a": 1, "b": 2, "c": 3}
6

7
    // 比较
8
    fmt.Println(maps.Equal(m1, m2))  // true
9

10
    // 复制
11
    m3 := maps.Clone(m1)
12
    fmt.Println(m3)  // map[a:1 b:2 c:3]
13

14
    // 复制到另一个 map
15
    m4 := map[string]int{"d": 4}
16
    maps.Copy(m4, m1)
17
    fmt.Println(m4)  // map[a:1 b:2 c:3 d:4]
18

19
    // 删除键
20
    maps.DeleteFunc(m1, func(k string, v int) bool {
21
        return v < 2
22
    })
23
    fmt.Println(m1)  // map[b:2 c:3]
24
}

1
type Set[T comparable] struct {
2
    items map[T]struct{}
3
}
4

5
func NewSet[T comparable]() *Set[T] {
6
    return &Set[T]{
7
        items: make(map[T]struct{}),
8
    }
9
}
10

11
func NewSetFrom[T comparable](items []T) *Set[T] {
12
    s := NewSet[T]()
13
    for _, item := range items {
14
        s.Add(item)
15
    }
16
    return s
17
}
18

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

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

27
func (s *Set[T]) Contains(item T) bool {
28
    _, exists := s.items[item]
29
    return exists
30
}
31

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

36
func (s *Set[T]) ToSlice() []T {
37
    result := make([]T, 0, len(s.items))
38
    for item := range s.items {
39
        result = append(result, item)
40
    }
41
    return result
42
}
43

44
func (s *Set[T]) Union(other *Set[T]) *Set[T] {
45
    result := NewSet[T]()
46
    for item := range s.items {
47
        result.Add(item)
48
    }
49
    for item := range other.items {
50
        result.Add(item)
51
    }
52
    return result
53
}
54

55
func (s *Set[T]) Intersection(other *Set[T]) *Set[T] {
56
    result := NewSet[T]()
57
    for item := range s.items {
58
        if other.Contains(item) {
59
            result.Add(item)
60
        }
61
    }
62
    return result
63
}
64

65
func (s *Set[T]) Difference(other *Set[T]) *Set[T] {
66
    result := NewSet[T]()
67
    for item := range s.items {
68
        if !other.Contains(item) {
69
            result.Add(item)
70
        }
71
    }
72
    return result
73
}
74

75
// 使用
76
set1 := NewSetFrom([]int{1, 2, 3, 4})
77
set2 := NewSetFrom([]int{3, 4, 5, 6})
78

79
union := set1.Union(set2)           // {1, 2, 3, 4, 5, 6}
80
intersection := set1.Intersection(set2)  // {3, 4}
81
difference := set1.Difference(set2)       // {1, 2}

1
源代码：
2
func Sum[T int | float64](numbers []T) T { ... }
3

4
Go 的实际实现（GCshape 分组）：
5
- int 和 float64 的 GC 形状相同（都是 8 字节纯数据）
6
- 编译器可能共享同一个特化版本，通过字典区分
7
- 字典中包含类型信息、方法集、零值等
8

9
概念上的编译输出：
10
func Sum.int(stub *dict, numbers []int) int { ... }   // int 特化
11
func Sum.float64(stub *dict, numbers []float64) float64 { ... }  // float64 特化

1
// 泛型版本
2
func SumGeneric[T int | float64](numbers []T) T {
3
    var total T
4
    for _, n := range numbers {
5
        total += n
6
    }
7
    return total
8
}
9

10
// 手写特化版本
11
func SumInt(numbers []int) int {
12
    var total int
13
    for _, n := range numbers {
14
        total += n
15
    }
16
    return total
17
}
18

19
// 接口版本（作为对比）
20
func SumInterface(numbers []any, zero any, add func(a, b any) any) any {
21
    total := zero
22
    for _, n := range numbers {
23
        total = add(total, n)
24
    }
25
    return total
26
}

1
泛型版本 vs 手写特化版本：几乎相同（差异 < 1%）
2
接口版本 vs 泛型版本：慢 2-5 倍（由于装箱/拆箱和类型断言）

1
// 好的泛型使用
2
type Stack[T any] struct { ... }
3
func Sort[T Ordered](slice []T) { ... }
4
func Contains[T comparable](slice []T, v T) bool { ... }

1
// 使用接口：运行时多态，行为抽象
2
type Writer interface {
3
    Write([]byte) (int, error)
4
}
5

6
func SaveData(w Writer, data []byte) error {
7
    _, err := w.Write(data)
8
    return err
9
}
10

11
// 使用泛型：编译时多态，数据抽象
12
func Process[T any](data []T, f func(T) T) []T {
13
    result := make([]T, len(data))
14
    for i, v := range data {
15
        result[i] = f(v)
16
    }
17
    return result
18
}

1
// 单字母类型参数：适用于简单场景
2
func Map[T any](slice []T, f func(T) T) []T
3

4
// 描述性名称：适用于多个类型参数或复杂约束
5
func Convert[From, To any](v From) To
6

7
// 约束性命名：清晰表达意图
8
func Lookup[Key comparable, Value any](m map[Key]Value, k Key) Value

1
// 好的实践：约束最小化
2
func Contains[T comparable](slice []T, v T) bool {
3
    // 只需要 == 比较，使用 comparable
4
}
5

6
// 不好的实践：过度约束
7
func ContainsBad[T Ordered](slice []T, v T) bool {
8
    // Ordered 包含 < > 等，但我们只用 ==
9
    // 过度约束限制了可用类型
10
}
11

12
// 好的实践：语义化约束命名
13
type Numeric interface {
14
    ~int | ~int8 | ~int16 | ~int32 | ~int64 |
15
    ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 |
16
    ~float32 | ~float64
17
}

1
// 过度使用：为单一类型使用泛型
2
func GetUserName[T string](id int) T {
3
    // T 永远是 string，泛型毫无意义
4
    return "user_" + strconv.Itoa(id)
5
}
6

7
// 合理使用：确实需要类型参数
8
func ParseNumber[T Numeric](s string) (T, error) {
9
    // 不同数值类型有不同的解析需求
10
    var result T
11
    // ...
12
    return result, nil
13
}

1
// 错误方式：使用 nil（可能不是零值）
2
func Pop[T any](stack []T) T {
3
    if len(stack) == 0 {
4
        return nil  // 编译错误！T 可能不是指针类型
5
    }
6
    // ...
7
}
8

9
// 正确方式：声明零值变量
10
func Pop[T any](stack []T) (T, bool) {
11
    var zero T  // 正确获取类型 T 的零值
12
    if len(stack) == 0 {
13
        return zero, false
14
    }
15
    // ...
16
    return stack[len(stack)-1], true
17
}
18

19
// 使用指针表示可选值
20
func PopPtr[T any](stack []T) *T {
21
    if len(stack) == 0 {
22
        return nil  // nil 对于任何指针类型都有效
23
    }
24
    v := stack[len(stack)-1]
25
    return &v
26
}