Go泛型详解

引子

如果我们要写一个函数分别比较2个整数和浮点数的大小，我们就要写2个函数。如下：

func Min(x, y float64) float64 {if x < y {return x}return y
}func MinInt(x, y int) int {if x < y {return x}return y
}

2个函数，除了数据类型不一样，其他处理逻辑完全一言。那有没有方法能一个函数完成上面的功能呢？有，那就是泛型。

func min[T int | float64](x, y T) T {if x < y {return x}return y
}

泛型

官网文档：https://go.dev/blog/intro-generics
泛型为该语言添加了三个新的重要功能：

函数和类型的类型参数。
将接口类型定义为类型集，包括没有方法的类型。
类型推断，在许多情况下允许在调用函数时省略类型参数。

类型参数（Type Parameters）

现在允许函数和类型具有类型参数。类型参数列表看起来与普通参数列表类似，只是它使用方括号而不是圆括号。
在这里插入图片描述

package mainimport ("fmt""golang.org/x/exp/constraints"
)func GMin[T constraints.Ordered](x, y T) T {if x < y {return x}return y
}func main() {x := GMin[int](2, 3)fmt.Println(x) // 输出结果为2
}

其中constraints.Ordered是自定义类型（这里不展示源码）。
理解不了的，可以暂时把constraints.Ordered替换为 ·int | float64。

向 GMin 提供类型参数（在本例中为 int）称为实例化）（instantiation）。实例化分两步进行。

首先，编译器在整个泛型函数或类型中将所有类型实参替换为其各自的类型参数。
其次，编译器验证每个类型参数是否满足各自的约束。
我们很快就会明白这意味着什么，但如果第二步失败，实例化就会失败，程序就会无效。

成功实例化后，我们有一个非泛型函数，可以像任何其他函数一样调用它。例如，在类似的代码中

fmin := GMin[float64]
m := fmin(2.71, 3.14)

全部代码为

package mainimport ("fmt""golang.org/x/exp/constraints"
)func GMin[T constraints.Ordered](x, y T) T {if x < y {return x}return y
}func main() {fmin := GMin[float64] // 相当于func GMin(x, y float64) float64{...}m := fmin(2.71, 3.14)fmt.Println(m) // 输出结果为2.71
}

实例化 GMin[float64] 生成的实际上是我们原始的浮点 Min 函数，我们可以在函数调用中使用它。

类型参数也可以与类型一起使用。

type Tree[T interface{}] struct {left, right *Tree[T]value       T
}func (t *Tree[T]) Lookup(x T) *Tree[T] { ... }var stringTree Tree[string]

这里泛型类型 Tree 存储类型参数 T 的值。泛型类型可以有方法，就像本例中的 Lookup 一样。为了使用泛型类型，必须对其进行实例化； Tree[string] 是使用类型参数 string 实例化 Tree 的示例。

类型集（Type sets）

类型参数列表中的每个类型参数都有一个类型。由于类型参数本身就是一种类型，因此类型参数的类型定义了类型集。这种元类型称为类型约束。

类型约束

普通函数中的每个参数都有一个类型; 该类型定义一系列值的集合。例如，我们上面定义的非泛型函数minFloat64那样，声明了参数的类型为float64，那么在函数调用时允许传入的实际参数就必须是可以用float64类型表示的浮点数值。

类似于参数列表中每个参数都有对应的参数类型，类型参数列表中每个类型参数都有一个类型约束。类型约束定义了一个类型集——只有在这个类型集中的类型才能用作类型实参。

Go语言中的类型约束是接口类型。

就以上面提到的min函数为例，我们来看一下类型约束常见的两种方式。

类型约束接口可以直接在类型参数列表中使用。

// 类型约束字面量，通常外层interface{}可省略
func min[T interface{ int | float64 }](a, b T) T {if a <= b {return a}return b
}

作为类型约束使用的接口类型可以事先定义并支持复用。

// 事先定义好的类型约束类型
type Value interface {int | float64
}
func min[T Value](a, b T) T {if a <= b {return a}return b
}

在使用类型约束时，如果省略了外层的interface{}会引起歧义，那么就不能省略。例如：

type IntPtrSlice [T *int] []T  // T*int ?type IntPtrSlice[T *int,] []T  // 只有一个类型约束时可以添加`,`
type IntPtrSlice[T interface{ *int }] []T // 使用interface{}包裹

类型集

Go1.18开始接口类型的定义也发生了改变，由过去的接口类型定义方法集（method set）变成了接口类型定义类型集（type set）。
也就是说，接口类型现在可以用作值的类型，也可以用作类型约束。
在这里插入图片描述
把接口类型当做类型集相较于方法集有一个优势: 我们可以显式地向集合添加类型，从而以新的方式控制类型集。

Go语言扩展了接口类型的语法，让我们能够向接口中添加类型。例如

type V interface {int | string | bool
}

在这里插入图片描述
从 Go 1.18 开始，一个接口不仅可以嵌入其他接口，还可以嵌入任何类型、类型的联合或共享相同底层类型的无限类型集合。

当用作类型约束时，由接口定义的类型集精确地指定允许作为相应类型参数的类型。

|符号

T1 | T2表示类型约束为T1和T2这两个类型的并集，例如下面的Integer类型表示由Signed和Unsigned组成。

type Integer interface {Signed | Unsigned
}

~符号
~T表示所以底层类型是T的类型，例如~string表示所有底层类型是string的类型集合。

type MyString string  // MyString的底层类型是string

注意：~符号后面只能是基本类型。

接口作为类型集是一种强大的新机制，是使类型约束能够生效的关键。目前，使用新语法表的接口只能用作类型约束。

any接口
空接口在类型参数列表中很常见，在Go 1.18引入了一个新的预声明标识符，作为空接口类型的别名。

// src/builtin/builtin.gotype any = interface{}

由此，我们可以使用如下代码：

func foo[S ~[]E, E any]() {// ...
}

类型推断

对于类型参数，需要传递类型参数，这可能导致代码冗长。回到我们通用的 min函数：

func min[T int | float64](a, b T) T {if a <= b {return a}return b
}

类型形参T用于指定a和b的类型。我们可以使用显式类型实参调用它：

var a, b, m float64
m = min[float64](a, b) // 显式指定类型实参

在许多情况下，编译器可以从普通参数推断 T 的类型实参。这使得代码更短，同时保持清晰。

var a, b, m float64m = min(a, b) // 无需指定类型实参

这种从实参的类型推断出函数的类型实参的推断称为函数实参类型推断。函数实参类型推断只适用于函数参数中使用的类型参数，而不适用于仅在函数结果中或仅在函数体中使用的类型参数。例如，它不适用于像 MakeT T any T 这样的函数，因为它只使用 T 表示结果。

约束类型推断

Go 语言支持另一种类型推断，即约束类型推断。接下来我们从下面这个缩放整数的例子开始：

// Scale 返回切片中每个元素都乘c的副本切片
func Scale[E constraints.Integer](s []E, c E) []E {r := make([]E, len(s))for i, v := range s {r[i] = v * c}return r
}

这是一个泛型函数适用于任何整数类型的切片。

现在假设我们有一个多维坐标的 Point 类型，其中每个 Point 只是一个给出点坐标的整数列表。这种类型通常会实现一些业务方法，这里假设它有一个String方法。

type Point []int32func (p Point) String() string {b, _ := json.Marshal(p)return string(b)
}

由于一个Point其实就是一个整数切片，我们可以使用前面编写的Scale函数：

func ScaleAndPrint(p Point) {r := Scale(p, 2)fmt.Println(r.String()) // 编译失败
}

不幸的是，这代码会编译失败，输出r.String undefined (type []int32 has no field or method String的错误。

问题是Scale函数返回类型为[]E的值，其中E是参数切片的元素类型。当我们使用Point类型的值调用Scale（其基础类型为[]int32）时，我们返回的是[]int32类型的值，而不是Point类型。这源于泛型代码的编写方式，但这不是我们想要的。

为了解决这个问题，我们必须更改 Scale 函数，以便为切片类型使用类型参数。

func Scale[S ~[]E, E constraints.Integer](s S, c E) S {r := make(S, len(s))for i, v := range s {r[i] = v * c}return r
}

我们引入了一个新的类型参数S，它是切片参数的类型。我们对它进行了约束，使得基础类型是S而不是[]E，函数返回的结果类型现在是S。由于E被约束为整数，因此效果与之前相同：第一个参数必须是某个整数类型的切片。对函数体的唯一更改是，现在我们在调用make时传递S，而不是[]E。

现在这个Scale函数，不仅支持传入普通整数切片参数，也支持传入Point类型参数。

这里需要思考的是，为什么不传递显式类型参数就可以写入 Scale 调用？也就是说，为什么我们可以写 Scale(p, 2)，没有类型参数，而不是必须写 Scale[Point, int32](p, 2) ？

新 Scale 函数有两个类型参数——S 和 E。在不传递任何类型参数的 Scale(p, 2) 调用中，如上所述，函数参数类型推断让编译器推断 S 的类型参数是 Point。但是这个函数也有一个类型参数 E，它是乘法因子 c 的类型。相应的函数参数是2，因为2是一个非类型化的常量，函数参数类型推断不能推断出 E 的正确类型(最好的情况是它可以推断出2的默认类型是 int，而这是错误的，因为Point 的基础类型是[]int32)。相反，编译器推断 E 的类型参数是切片的元素类型的过程称为约束类型推断。

约束类型推断从类型参数约束推导类型参数。当一个类型参数具有根据另一个类型参数定义的约束时使用。当其中一个类型参数的类型参数已知时，约束用于推断另一个类型参数的类型参数。

通常的情况是，当一个约束对某种类型使用 ~type 形式时，该类型是使用其他类型参数编写的。我们在 Scale 的例子中看到了这一点。S 是 ~[]E，后面跟着一个用另一个类型参数写的类型[]E。如果我们知道了 S 的类型实参，我们就可以推断出E的类型实参。S 是一个切片类型，而 E是该切片的元素类型。