《Go 语言高级编程》1.1 泛型类型别名与语言精化

type Set[T comparable] = map[T]struct{}  // 别名：Set 就是 map[T]struct{}
type MySet[T comparable] map[T]struct{}  // 定义：MySet 是一个新的、不同的类型

package main

import "fmt"

type Set[T comparable] = map[T]struct{}
type StringSet = Set[string]  // 别名可以指向已实例化的泛型别名
type MySet[T comparable] map[T]struct{}

func main() {
	s := Set[string]{"a": {}, "b": {}}
	var ss StringSet = s // 同一类型，直接赋值，无需转换
	fmt.Println("len =", len(ss))

	show(s)
	show(ss) // 别名与目标类型等价，函数参数可互换

	m := map[int]struct{}{1: {}}
	var defined MySet[int] = m // 底层类型相同，m 的类型未命名，可直接赋值
	_ = defined
	fmt.Println("ok")
}

func show(s Set[string]) { fmt.Println("show:", len(s)) }

len = 2
show: 2
show: 2
ok

package main

import (
	"fmt"
	"reflect"
)

type Pair[K comparable, V any] = map[K]V
type IntToStr = Pair[int, string]

type Box[T any] struct{ v T }
type BoxAlias[T any] = Box[T] // 别名到一个泛型命名类型

func main() {
	p := Pair[string, int]{"a": 1}
	var q IntToStr = IntToStr{2: "b"}
	fmt.Println(reflect.TypeOf(p), reflect.TypeOf(q))

	var m map[string]int = p // 直接赋给底层类型
	fmt.Println("assignable to underlying:", m["a"])

	b := BoxAlias[int]{v: 3}
	fmt.Println("BoxAlias field:", b.v, "type:", reflect.TypeOf(b))
}

map[string]int map[int]string
assignable to underlying: 1
BoxAlias field: 3 type: main.Box[int]

package main

type Pair[K comparable, V any] = map[K]V

var _ Pair // 未实例化，缺少类型实参

./bad.go:5:7: cannot use generic type Pair[K comparable, V any] without instantiation

$ GOTOOLCHAIN=go1.25.0 GOEXPERIMENT=noaliastypeparams go build .
./main.go:6:6: generic type alias requires GOEXPERIMENT=aliastypeparams
$ GOTOOLCHAIN=go1.26.3 GOEXPERIMENT=aliastypeparams go env GOEXPERIMENT
go: unknown GOEXPERIMENT aliastypeparams

# 工具链固定 go1.27.0，只改 go.mod 的 go 指令
range over int:  go.mod=1.21 → 编译失败   go.mod=1.22 → 通过
range over func: go.mod=1.22 → 编译失败   go.mod=1.23 → 通过
min/max/clear:   go.mod=1.21 → 通过（1.21.0 / 1.24.0 / 1.27.0 均可）

package main

import "fmt"

func main() {
	sum := 0
	for i := range 5 { // range over int（1.22）
		sum += i
	}
	fmt.Println("range over int sum =", sum)

	var fns []func() int
	for _, v := range []int{10, 20, 30} { // 每迭代独立变量（1.22）
		fns = append(fns, func() int { return v })
	}
	fmt.Println("loopvar:", fns[0](), fns[1](), fns[2]())

	seq := func(yield func(int) bool) { // range over func（1.23）
		for i := 1; i <= 3; i++ {
			if !yield(i * i) {
				return
			}
		}
	}
	for v := range seq {
		fmt.Print(v, " ")
	}
	fmt.Println()

	fmt.Println("min/max:", min(3, 7, 2), max(3, 7, 2)) // 1.21
	m := map[string]int{"a": 1}
	clear(m)
	fmt.Println("after clear:", len(m))
}

range over int sum = 10
loopvar: 10 20 30
1 4 9
min/max: 2 7
after clear: 0

$ GOTOOLCHAIN=go1.21.0 go run .   # go.mod 写 go 1.21
30 30 30
$ GOTOOLCHAIN=go1.27.0 go run .   # go.mod 仍是 go 1.21
30 30 30