> For the complete documentation index, see [llms.txt](https://gocompiler.shizhz.me/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://gocompiler.shizhz.me/golang-bian-yi-qi-lei-xing-jian-cha/4.4.411-fan-xing-lei-xing-fl.md).

# 4.4.4-11 泛型类型

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

```go
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
}
```

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

```go
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 所包含的实际类型，例如如下申明：

```go
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），我们先来回顾一下普通的函数参数：

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

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

```go
type Node[T comparable] struct {
    val T
}
```

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

```go
type Node struct {
    val int32
}
```

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

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

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

事实上，编译器在[生成 IR Tree](/golang-bian-yi-qi-ir-tree/untitled-2.md#org3e1ddf1) 时便会为所有泛型函数做实例化。