1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// ① 类型参数列表写在函数名之后，约束写在类型参数名之后
func Map[T, U any](xs []T, f func(T) U) []U {
	out := make([]U, 0, len(xs))
	for _, x := range xs {
		out = append(out, f(x))
	}
	return out
}

// ② 泛型类型：类型参数写在类型名之后
type Pair[K comparable, V any] struct {
	Key K
	Val V
}

// ③ 泛型类型的方法：可以使用类型的类型参数，也可以【再声明】自己的 ⚠️ 与很多资料说法不同
func (b Box[T]) Map[U any](f func(T) U) Box[U] { return Box[U]{f(b.v)} }

1

fmt.Println(Map([]int{1, 2, 3}, func(n int) string { return fmt.Sprint(n * 2) }))

1

[2 4 6]

1
2

fmt.Println(Sum[int]([]int{4, 5}))       // 显式指定 T=int
p := NewPair[string, int]("z", 9)        // 多个类型参数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

type Number interface {
	~int | ~int8 | ~int16 | ~int32 | ~int64 |
		~float32 | ~float64
}

type Celsius float64
type MyInt int

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

fmt.Println(Sum([]int{1, 2, 3}))          // 6
fmt.Println(Sum([]float64{1.5, 2.5}))     // 4
fmt.Println(Sum([]Celsius{1.5, 2.5}))     // 4  ← ~float64 让自定义类型也能进来 🔥
fmt.Println(Sum([]MyInt{1, 2, 3}))        // 6

1
2
3
4

6
4
4
6

1
2
3
4
5
6
7
8
9

type Stringer interface{ String() string }

func Join[T Stringer](xs []T, sep string) string {
	parts := make([]string, len(xs))
	for i, x := range xs {
		parts[i] = x.String()      // ✅ 约束里有 String()，所以能调
	}
	return strings.Join(parts, sep)
}

1
2
3
4

// 🛑 编译错误：interface method must have no type parameters
type Mapper interface {
	Map[U any](f func(int) U) U
}

1
2
3
4
5
6
7

fmt.Println(NewPair("a", 1))          // ✅ 推断 K=string, V=int
fmt.Println(NewPair("a", 1).String()) // ✅

// 推断不出来时必须显式
var empty []int
fmt.Println(Sum(empty))               // ✅ 从参数推断 T=int
fmt.Println(Sum[int](nil))            // ✅ nil 推断不出来，必须显式

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 类型安全的 Set
type Set[T comparable] map[T]struct{}

func (s Set[T]) Add(v T)       { s[v] = struct{}{} }
func (s Set[T]) Has(v T) bool  { _, ok := s[v]; return ok }
func (s Set[T]) Len() int      { return len(s) }

s := Set[string]{}
s.Add("a")
fmt.Println(s.Has("a"), s.Len())      // true 1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// 去重
func Unique[T comparable](xs []T) []T {
	seen := make(map[T]struct{}, len(xs))
	var out []T
	for _, x := range xs {
		if _, ok := seen[x]; !ok {
			seen[x] = struct{}{}
			out = append(out, x)
		}
	}
	return out
}

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

1
2

// 🛑 编译错误：[]int does not satisfy comparable
fmt.Println(Eq([]int{1}, []int{1}))

1
2
3

cmp.Compare(a, b)     // -1 / 0 / +1，要求 cmp.Ordered
cmp.Less(a, b)        // a < b
cmp.Or(a, b, c)       // 返回第一个非零值，用于默认值 🔥

1

fmt.Println(cmp.Compare(1, 2), cmp.Or("", "fallback"))

1

-1 fallback

1
2
3
4
5
6
7
8

// 按值排序 map 的键
m := map[string]int{"c": 3, "a": 1, "b": 2}
keys := slices.SortedFunc(maps.Keys(m), func(a, b string) int {
	return cmp.Compare(m[a], m[b])     // 按值升序
})

// 有默认值的配置取值
timeout := cmp.Or(cfg.Timeout, 30*time.Second)

1
2
3
4
5
6

type Box[T any] struct{ v T }

// ✅ 1.27 起合法：方法可以声明自己的类型参数 U
func (b Box[T]) Map[U any](f func(T) U) Box[U] { return Box[U]{f(b.v)} }

b.Map(func(n int) string { return fmt.Sprint(n * 2) })   // 6

1
2
3
4

// 🛑 编译错误：interface method must have no type parameters
type Mapper interface {
	Map[U any](f func(int) U) U
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

泛型 vs 接口的代码生成
┌─────────────────────────────────────────────┐
│ 泛型 func Sum[T Number](xs []T) T            │
│   Sum[int]    → 生成一份 int 专用代码 ✅ 无装箱 │
│   Sum[float64]→ 生成一份 float64 专用代码      │
│   代价：二进制体积随实例化组合增长 ⚠️           │
├─────────────────────────────────────────────┤
│ 接口 func Sum(xs []Number) Number（不存在，示意）│
│   一份代码，但每次调用都要装箱/查表 ⚠️          │
└─────────────────────────────────────────────┘