4.4.4-11 泛型类型

函数与类型中申明的泛型使用如下数据结构来表示：

type TypeParam struct {
    check *Checker  // for lazy type bound completion
    id    uint64    // unique id
    obj   *TypeName // 
    index int       // parameter index
    bound Type      // *Named or *Interface; underlying type is always *Interface
}

除此之外还有三个类型用于泛型，其定义如下：

type instance struct {
    check   *Checker     // for lazy instantiation
    pos     syntax.Pos   // position of type instantiation; for error reporting only
    base    *Named       // parameterized type to be instantiated
    targs   []Type       // type arguments
    poslist []syntax.Pos // position of each targ; for error reporting only
    value   Type         // base(targs...) after instantiation or Typ[Invalid]; nil if not yet set
}
type bottom struct{}
type top struct{}

bottom 与 top 是两个标记类型。当接口中包含泛型的 constraints 时，我们需要推算出当前接口中 constraints 所包含的实际类型，例如如下申明：

type SmallInt interface {
    type int8, int16, int32
}

type BigInt interface {
    type int, int32, int64
}

type MediumInt interface {
    SmallInt
    BigInt
    type int16, int32
}

MediumInt 中除了申明了自己的 constraints 列表, 还内嵌了 SmallInt 与 BigInt, 此时 MediumInt 的实际 constraints 自然应该是三者的并集：int32. bottom 与 top 两个类型用于表示两个特殊的集合：前者表示空集，后者表示全集。

instance 代表一个实例化了的泛型，泛型也叫类型参数（type parameter），我们先来回顾一下普通的函数参数：

func sum(i, j int) int {
    return i + j
}

但凡说道“参数”，就需要使用者将具体的实参传递进去。i, j 是函数 sum 的形参，我们可以将函数看着是一个计算模版，当调用者提供该模版的实参时，我们就可以通过该“模版”计算出最终值。那么“类型参数”该如何传递呢？我们先来看一个典型的泛型定义：

type Node[T comparable] struct {
    val T
}

Node 是我们定义的一个类型，但是该类型并不完备：属性 val 的类型 T 还是未知的，由使用者提供。我们可以将 T 看着是 Node 的类型参数，从而将将 Node[T comparable] 看着是一个类型模版，当使用者提供具体的参数类型时，我们就可以得到一个具体的Node类型。例如当 T 为 int32 时，我们得到具体类型是：

type Node struct {
    val int32
}

该过程叫着类型的实例化。所以在代码中，任何使用泛型 Node 的地方都需要传入类型参数，例如如下代码：

// 该方法中一共有三个实例化的 Node 类型：Node[string], Node[float32] 与 Node[int32]
func convert(nod Node[string]) Node[float32] {   
var _ Node[int32]
}

go 编译器内部使用 instance 来表示一个实例化的泛型类型，其中 base 是“类型模版”，而 targs 就是具体传入的参数类型值。例如上述代码中将会生成三个具体类型，对应三个 instance 实例。

事实上，编译器在生成 IR Tree 时便会为所有泛型函数做实例化。