类型参数使用[T any]来声明，通过在类型名称或函数名称后面声明类型参数来使其泛型化。

泛型函数

在函数名后面定义类型参数[T any]，然后在参数列表中使用该类型。

go
// 定义泛型函数
func PrintAnythingTo[T any](w io.Writer, d T) {
	fmt.Fprintln(w, d)
}

// 使用泛型函数
func TestPrintAnythingTo_PrintsInputToSuppliedWriter(t *testing.T) {
	t.Parallel()
	buf := &bytes.Buffer{}
	print.PrintAnythingTo[string](buf, "Hello, world")
	want := "Hello, world\n"
	got := buf.String()
	if !cmp.Equal(want, got) {
		t.Error(cmp.Diff(want, got))
	}
}

复合类型

go
// 获取任意 slice 的长度
func Len[E any](s []E) int ()
// 参数为 receive-only chan
func Drain[E any](ch <-chan E) {}
func Merge[E any](chs ...<-chan E) <-chan E {}

泛型类型

泛型 slice

go
// 声明
type Bunch[E any] []E
// 使用
b := Bunch[int]{1, 2, 3}

// 错误的使用
b := Bunch[int]{1, 2, 3}
b = append(b, "hello")
   // cannot use "hello" (untyped string
   // constant) as int value in argument
   // to append

泛型函数类型

go
// 正确的声明
type idFunc[T any] func(T) T
// 错误的声明
type idFunc func[T any](T) T
   // syntax error: function type must have no type parameters

泛型类型作为函数参数

和上面的复合类型类似，只不过参数是泛型类型。

go
// 泛型类型
type Group[E any] []E
// 泛型函数
func Len[E any](s Group[E]) int {
	return len(s)
}

// 使用
func TestLenOfGroupIs2WhenItContains2Elements(t *testing.T) {
	t.Parallel()
	g := group.Group[int]{1, 2}
	want := 2
	got := group.Len(g)
	if !cmp.Equal(want, got) {
		t.Error(cmp.Diff(want, got))
	}
}