Go泛型深度解析与类型系统设计

一、Go泛型演进历史

1.1 为什么Go 1.18才支持泛型

Go语言自2009年开源以来，泛型一直是社区呼声最高的特性之一。然而，官方直到Go 1.18（2022年3月）才正式引入泛型。这背后有着深刻的设计哲学和技术考量。

Go团队的核心设计理念是"简单性优先"。在 Go 诞生之初，Rob Pike 和 Ken Thompson 等设计者认为，泛型会增加语言的复杂性，而复杂性是Go试图避免的。他们观察到C++模板带来的编译时间爆炸和代码膨胀问题，决定采取更谨慎的态度。

历经十余年的讨论，Go团队提出了三版泛型设计方案：

最终的泛型设计由 Ian Lance Taylor 和 Robert Griesemer 主导，核心目标是：保持向后兼容、不破坏现有代码、编译速度不受影响、类型系统保持简洁。

1.2 泛型设计的核心挑战

Go团队在实现泛型时面临几个核心技术挑战：

首先是类型参数化与接口系统的融合。Go的接口（interface）本身就是一种形式的"泛型"——通过接口可以编写处理多种类型的代码。但接口使用动态分发（dynamic dispatch），有运行时开销。泛型的目标是零成本抽象（zero-cost abstraction），即在编译期确定具体类型，消除运行时开销。

其次是类型推断（Type Inference）的实现。Go希望泛型调用像普通函数一样简洁，不需要显式指定类型参数。这要求编译器能够进行复杂的类型推导，同时保证推导结果的可预测性。

最后是编译速度与代码膨胀的平衡。C++模板会为每种类型生成独立的代码，导致编译产物膨胀。Go采用了一种混合策略：对于值类型（如int、struct），生成专用代码；对于指针类型，复用通用代码。

// Go泛型的核心设计目标：
// 1. 类型安全 —— 编译期检查，无运行时类型错误
// 2. 零成本抽象 —— 泛型代码与手写特定类型代码性能相当
// 3. 简洁性 —— 语法不增加语言理解负担
// 4. 向后兼容 —— 不影响现有代码

// 泛型语法示例（Go 1.18+）
func Min[T constraints.Ordered](a, b T) T {
    if a < b {
        return a
    }
    return b
}

// 类型推断：编译器自动推导T为int
m := Min(3, 5) // T = int

二、Type Parameter语法与Constraint设计

2.1 类型参数（Type Parameter）语法

Go泛型的语法设计极其简洁。类型参数用方括号 [] 声明，紧跟在函数名或类型名之后。每个类型参数都有一个约束（Constraint），约束定义了该类型参数可以接受的具体类型。

// 泛型函数语法
func FunctionName[T Constraint](params) returnType {
    // 函数体
}

// 泛型类型语法
type TypeName[T Constraint] struct {
    // 结构体字段
}

// 泛型接口语法
type InterfaceName[T any] interface {
    Method() T
}

方括号语法的选择是经过深思熟虑的。尖括号 <> 被排除，因为会与比较运算符产生歧义（如 foo<bar> 可能是比较表达式）。方括号在大多数上下文中没有歧义，且视觉上与泛型概念关联较弱，保持Go的简洁风格。

2.2 Constraint（约束）机制详解

Constraint是Go泛型的核心创新。本质上，Constraint就是一个接口类型，它描述了类型参数必须满足的方法集和类型集合。

Go 1.18引入了一个重要概念：接口可以作为类型约束。但作为约束的接口，其含义比作为类型使用的接口更宽泛——它可以包含类型元素（type elements），用 | 表示类型联合（union）。

package constraints

// Ordered 是标准库中的约束示例
// 它定义了所有有序类型（可比较大小）的类型集合
type Ordered interface {
    ~int | ~int8 | ~int16 | ~int32 | ~int64 |
    ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
    ~float32 | ~float64 |
    ~string
}

// 自定义约束：支持数值运算
type Number interface {
    ~int | ~int8 | ~int16 | ~int32 | ~int64 |
    ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 |
    ~float32 | ~float64
}

// 使用约束
func Sum[T Number](values []T) T {
    var total T
    for _, v := range values {
        total += v
    }
    return total
}

注意 ~ 符号的含义：~int 表示"底层类型为int的所有类型"，而不仅仅是int本身。这意味着即使你定义了 type MyInt int，MyInt也满足 ~int 约束。

2.3 any 与 comparable 预定义约束

Go 1.18在标准库中预定义了两个特殊的约束，它们实际上是内置标识符的别名：

comparable 是一个特殊的预定义约束，它不是一个普通的接口类型，而是由编译器特殊处理的。它包含了所有可以使用 == 和 != 进行比较的类型，包括基本类型、指针类型、通道类型、以及元素类型是可比较的数组和结构体。

// any 约束：任意类型都可以
func PrintAny[T any](v T) {
    fmt.Printf("%v\n", v)
}

// comparable 约束：只能用于可比较类型
func IndexOf[T comparable](slice []T, target T) int {
    for i, v := range slice {
        if v == target { // comparable 保证 == 可用
            return i
        }
    }
    return -1
}

// 使用示例
func main() {
    PrintAny(42)           // T = int
    PrintAny("hello")      // T = string
    PrintAny(struct{}{})   // T = struct{}
    
    fmt.Println(IndexOf([]int{1, 2, 3}, 2))       // 输出: 1
    fmt.Println(IndexOf([]string{"a", "b"}, "c")) // 输出: -1
}

三、泛型与interface{}性能对比

3.1 运行时开销分析

在泛型出现之前，Go程序员通常使用 interface{}（或Go 1.18后的 any）来实现"通用"代码。然而，这种方式有显著的运行时开销：

使用 interface{} 时，值会被装箱（boxing）——具体类型的值被包装到一个 interface 结构中，包含类型信息和数据指针。这导致：1）堆分配增加；2）间接访问带来的缓存不友好；3）动态分发的方法调用开销。

泛型通过在编译期为每个具体类型生成专门代码，完全消除了这些开销。类型参数在编译期被替换为具体类型，生成的代码与手写针对该类型的代码性能完全一致。

3.2 性能基准测试对比

通过实际的基准测试，可以直观看到泛型和 interface{} 的性能差异。以下测试比较了三种方式实现的通用加法函数：

package main

import (
    "testing"
)

// 使用 interface{} 的实现
func AddInterface(a, b interface{}) interface{} {
    // 需要类型断言，且有运行时开销
    switch v := a.(type) {
    case int:
        return v + b.(int)
    case float64:
        return v + b.(float64)
    default:
        return nil
    }
}

// 使用泛型的实现
func AddGeneric[T int | float64](a, b T) T {
    return a + b
}

// 手写特定类型的实现（基准）
func AddInt(a, b int) int {
    return a + b
}

func BenchmarkInterface(b *testing.B) {
    for i := 0; i < b.N; i++ {
        AddInterface(1, 2)
    }
}

func BenchmarkGeneric(b *testing.B) {
    for i := 0; i < b.N; i++ {
        AddGeneric(1, 2)
    }
}

func BenchmarkInt(b *testing.B) {
    for i := 0; i < b.N; i++ {
        AddInt(1, 2)
    }
}

典型基准测试结果（Go 1.18+，amd64）：

BenchmarkInterface-8      100000000    12.3 ns/op    8 B/op    1 allocs/op
BenchmarkGeneric-8        1000000000   0.30 ns/op    0 B/op    0 allocs/op
BenchmarkInt-8            1000000000   0.30 ns/op    0 B/op    0 allocs/op

// 结论：
// 1. interface{} 版本慢约40倍，因为有堆分配（8B）和类型断言开销
// 2. 泛型版本与手写int版本性能完全一致（0.30 ns/op）
// 3. 泛型版本零分配，无堆内存压力

这个对比清晰地展示了泛型的零成本抽象特性：泛型代码在编译后被特化为具体类型的代码，运行时性能与手写代码无异。

四、泛型在容器数据结构中的应用

4.1 泛型容器设计模式

容器数据结构是泛型最自然的应用场景。在Go 1.18之前，要实现通用的容器（如栈、队列、链表），要么使用 interface{}（有类型安全和性能问题），要么为每种类型手写实现（代码重复）。

使用泛型，可以编写类型安全、零开销、代码复用的容器。以下是一个类型安全的泛型栈实现：

package main

import "errors"

// Stack 泛型栈
type Stack[T any] struct {
    items []T
}

// Push 入栈
func (s *Stack[T]) Push(item T) {
    s.items = append(s.items, item)
}

// Pop 出栈
func (s *Stack[T]) Pop() (T, error) {
    if len(s.items) == 0 {
        var zero T
        return zero, errors.New("stack is empty")
    }
    item := s.items[len(s.items)-1]
    s.items = s.items[:len(s.items)-1]
    return item, nil
}

// Peek 查看栈顶元素（不出栈）
func (s *Stack[T]) Peek() (T, error) {
    if len(s.items) == 0 {
        var zero T
        return zero, errors.New("stack is empty")
    }
    return s.items[len(s.items)-1], nil
}

// Size 栈大小
func (s *Stack[T]) Size() int {
    return len(s.items)
}

// IsEmpty 是否为空
func (s *Stack[T]) IsEmpty() bool {
    return len(s.items) == 0
}

// 使用示例
func main() {
    // 整数栈
    intStack := &Stack[int]{}
    intStack.Push(1)
    intStack.Push(2)
    val, _ := intStack.Pop() // val 类型为 int
    fmt.Println(val) // 输出: 2
    
    // 字符串栈
    strStack := &Stack[string]{}
    strStack.Push("hello")
    strStack.Push("world")
    s, _ := strStack.Pop() // s 类型为 string
    fmt.Println(s) // 输出: world
    
    // 自定义类型栈
    type Point struct { X, Y int }
    pointStack := &Stack[Point]{}
    pointStack.Push(Point{1, 2})
    p, _ := pointStack.Pop()
    fmt.Println(p) // 输出: {1 2}
}

4.2 泛型链表与树结构

泛型同样适用于更复杂的数据结构，如链表和二叉搜索树。这些结构的节点类型通常与存储的数据类型参数化。

// 泛型单向链表
type ListNode[T any] struct {
    Value T
    Next  *ListNode[T]
}

type LinkedList[T any] struct {
    head *ListNode[T]
    size int
}

// 添加元素到链表尾部
func (l *LinkedList[T]) Append(value T) {
    newNode := &ListNode[T]{Value: value}
    if l.head == nil {
        l.head = newNode
    } else {
        curr := l.head
        for curr.Next != nil {
            curr = curr.Next
        }
        curr.Next = newNode
    }
    l.size++
}

// 遍历链表
func (l *LinkedList[T]) ForEach(f func(T)) {
    curr := l.head
    for curr != nil {
        f(curr.Value)
        curr = curr.Next
    }
}

// 泛型二叉搜索树
type TreeNode[T constraints.Ordered] struct {
    Value T
    Left  *TreeNode[T]
    Right *TreeNode[T]
}

type BST[T constraints.Ordered] struct {
    root *TreeNode[T]
    size int
}

func (bst *BST[T]) Insert(value T) {
    bst.root = bst.insertNode(bst.root, value)
    bst.size++
}

func (bst *BST[T]) insertNode(node *TreeNode[T], value T) *TreeNode[T] {
    if node == nil {
        return &TreeNode[T]{Value: value}
    }
    if value < node.Value {
        node.Left = bst.insertNode(node.Left, value)
    } else {
        node.Right = bst.insertNode(node.Right, value)
    }
    return node
}

// 中序遍历（有序输出）
func (bst *BST[T]) InOrder(f func(T)) {
    bst.inOrderTraversal(bst.root, f)
}

func (bst *BST[T]) inOrderTraversal(node *TreeNode[T], f func(T)) {
    if node == nil {
        return
    }
    bst.inOrderTraversal(node.Left, f)
    f(node.Value)
    bst.inOrderTraversal(node.Right, f)
}

注意二叉搜索树对类型参数使用了 constraints.Ordered 约束，因为比较操作（< 和 >）需要类型支持有序比较。这体现了Go泛型约束的精确性——只让满足特定行为的类型参与实例化。

五、泛型函数与类型推断机制

5.1 类型推断（Type Inference）原理

Go泛型的类型推断是一项精巧的设计，它允许在大多数情况下省略类型参数，让编译器自动推导。Go支持两种类型的类型推断：函数参数类型推断和约束类型推断。

函数参数类型推断：当类型参数出现在函数参数中时，编译器可以根据传入的实参类型推断类型参数。这是最常见、最直观的推断方式。

约束类型推断：当类型参数之间通过约束关联时（如 type S[T1, T2 any] struct { A T1; B T2 }），编译器可以从已知的一个类型参数推导出另一个。

package main

import "fmt"

// 简单的泛型函数，T 由参数推断
func Identity[T any](v T) T {
    return v
}

// 多个类型参数
func Pair[T1, T2 any](a T1, b T2) (T1, T2) {
    return a, b
}

// 类型参数在返回值中，但可由参数推断
func First[T any](slice []T) (T, bool) {
    if len(slice) == 0 {
        var zero T
        return zero, false
    }
    return slice[0], true
}

func main() {
    // 类型推断：编译器自动推导 T = int
    v1 := Identity(42)
    fmt.Printf("Type: %T, Value: %v\n", v1, v1) // Type: int, Value: 42
    
    // 类型推断：T1 = string, T2 = int
    a, b := Pair("hello", 100)
    fmt.Printf("a: %T=%v, b: %T=%v\n", a, a, b, b) // a: string=hello, b: int=100
    
    // 切片元素类型推断
    slice := []float64{1.1, 2.2, 3.3}
    first, ok := First(slice) // T = float64
    fmt.Printf("First: %v, ok: %v\n", first, ok)
    
    // 有时需要显式指定类型参数
    // 例如：返回类型参数，但参数中没有该类型
    func New[T any]() T {
        var zero T
        return zero
    }
    
    // 这种情况下需要显式指定：
    s := New[string]() // 必须显式指定，编译器无法推断
    fmt.Printf("New string: %q\n", s)
}

5.2 类型推断的限制与边缘情况

尽管Go的类型推断相当强大，但有一些场景下推断会失败或产生歧义，需要显式指定类型参数：

Go的类型推断设计遵循"可预测性优于智能"的原则。如果推断结果可能让程序员感到意外，编译器会选择报 错而不是猜测。这与C++的模板参数推断形成对比，后者在某些情况下会进行复杂的模板参数推导，导致难以理解的错误信息。

// 需要显式类型参数的例子

// 例1：类型参数不在参数中
func MakeSlice[T any](n int) []T {
    return make([]T, n)
}

// 必须显式指定 T
// s := MakeSlice(5)       // 编译错误！无法推断 T
s := MakeSlice[int](5)   // 正确：T = int

// 例2：多个类型参数，编译器无法确定关系
func Convert[T1, T2 any](v T1) T2 {
    // 假设有某种转换逻辑
    // 这里编译器无法推断 T2
    var result T2
    return result
}

// result := Convert(42)     // 错误：无法推断 T2
result := Convert[int, string](42) // 必须显式指定

// 例3：类型推断与接口
type Stringer interface {
    String() string
}

func PrintStringer[T Stringer](v T) {
    fmt.Println(v.String())
}

type MyString string
func (m MyString) String() string { return string(m) }

// PrintStringer(MyString("hi")) // 可以推断 T = MyString
// 但如果涉及接口参数：
var s fmt.Stringer = MyString("hi")
// PrintStringer(s) // 可能出错，因为 fmt.Stringer 不等于 MyString

六、实战：泛型DAO层设计

6.1 传统DAO模式的痛点

在Go Web开发中，数据访问对象（DAO）层通常负责与数据库交互。传统实现中，每个实体（如User、Order）都需要编写几乎相同的CRUD代码，或者依赖 interface{} 导致类型不安全。

使用泛型，可以创建一个通用的、类型安全的DAO基类，同时保留针对特定实体的扩展能力。以下是一个基于database/sql的泛型DAO实现：

package dao

import (
    "context"
    "database/sql"
    "errors"
    "reflect"
)

// Entity 接口定义了所有实体必须实现的方法
// 这是泛型DAO的约束
type Entity interface {
    // TableName 返回数据库表名
    TableName() string
    // Scan 从数据库行扫描数据到实体
    Scan(rows *sql.Rows) error
    // InsertQuery 返回插入SQL和参数
    InsertQuery() (query string, args []any)
    // UpdateQuery 返回更新SQL和参数
    UpdateQuery() (query string, args []any)
    // ID 返回实体ID（用于删除和查询）
    ID() any
}

// GenericDAO 泛型DAO，处理通用CRUD操作
type GenericDAO[T Entity] struct {
    db *sql.DB
}

// NewGenericDAO 创建新的泛型DAO
func NewGenericDAO[T Entity](db *sql.DB) *GenericDAO[T] {
    return &GenericDAO[T]{db: db}
}

// Create 插入新实体
func (d *GenericDAO[T]) Create(ctx context.Context, entity T) error {
    query, args := entity.InsertQuery()
    _, err := d.db.ExecContext(ctx, query, args...)
    return err
}

// GetByID 根据ID查询实体
func (d *GenericDAO[T]) GetByID(ctx context.Context, id any) (T, error) {
    var entity T
    
    // 通过反射创建实例以获取表名
    // 注意：这里需要实体有零值可用的TableName方法
    zero := reflect.Zero(reflect.TypeOf(entity)).Interface().(T)
    
    query := "SELECT * FROM " + zero.TableName() + " WHERE id = ?"
    rows, err := d.db.QueryContext(ctx, query, id)
    if err != nil {
        var zero T
        return zero, err
    }
    defer rows.Close()
    
    if !rows.Next() {
        var zero T
        return zero, sql.ErrNoRows
    }
    
    err = entity.Scan(rows)
    return entity, err
}

// Update 更新实体
func (d *GenericDAO[T]) Update(ctx context.Context, entity T) error {
    query, args := entity.UpdateQuery()
    _, err := d.db.ExecContext(ctx, query, args...)
    return err
}

// Delete 删除实体
func (d *GenericDAO[T]) Delete(ctx context.Context, id any) error {
    var entity T
    zero := reflect.Zero(reflect.TypeOf(entity)).Interface().(T)
    
    query := "DELETE FROM " + zero.TableName() + " WHERE id = ?"
    _, err := d.db.ExecContext(ctx, query, id)
    return err
}

// List 列出所有实体
func (d *GenericDAO[T]) List(ctx context.Context) ([]T, error) {
    var entity T
    zero := reflect.Zero(reflect.TypeOf(entity)).Interface().(T)
    
    query := "SELECT * FROM " + zero.TableName()
    rows, err := d.db.QueryContext(ctx, query)
    if err != nil {
        return nil, err
    }
    defer rows.Close()
    
    var results []T
    for rows.Next() {
        var item T
        if err := item.Scan(rows); err != nil {
            return nil, err
        }
        results = append(results, item)
    }
    return results, nil
}

6.2 实体实现与使用示例

下面展示如何定义具体实体并实现 Entity 接口，然后使用泛型DAO：

// User 实体定义
type User struct {
    ID        int64  `db:"id"`
    Username  string `db:"username"`
    Email     string `db:"email"`
    CreatedAt string `db:"created_at"`
}

func (u *User) TableName() string {
    return "users"
}

func (u *User) Scan(rows *sql.Rows) error {
    return rows.Scan(&u.ID, &u.Username, &u.Email, &u.CreatedAt)
}

func (u *User) InsertQuery() (string, []any) {
    return "INSERT INTO users (username, email) VALUES (?, ?)",
        []any{u.Username, u.Email}
}

func (u *User) UpdateQuery() (string, []any) {
    return "UPDATE users SET username = ?, email = ? WHERE id = ?",
        []any{u.Username, u.Email, u.ID}
}

func (u *User) ID() any {
    return u.ID
}

// Order 实体定义
type Order struct {
    ID     int64   `db:"id"`
    UserID int64   `db:"user_id"`
    Amount float64 `db:"amount"`
    Status string  `db:"status"`
}

func (o *Order) TableName() string {
    return "orders"
}

func (o *Order) Scan(rows *sql.Rows) error {
    return rows.Scan(&o.ID, &o.UserID, &o.Amount, &o.Status)
}

func (o *Order) InsertQuery() (string, []any) {
    return "INSERT INTO orders (user_id, amount, status) VALUES (?, ?, ?)",
        []any{o.UserID, o.Amount, o.Status}
}

func (o *Order) UpdateQuery() (string, []any) {
    return "UPDATE orders SET amount = ?, status = ? WHERE id = ?",
        []any{o.Amount, o.Status, o.ID}
}

func (o *Order) ID() any {
    return o.ID
}

// 使用示例
func main() {
    db, _ := sql.Open("mysql", "user:pass@/dbname")
    defer db.Close()
    
    // 创建针对 User 的 DAO
    userDAO := NewGenericDAO[User](db)
    
    // 创建用户
    user := &User{Username: "alice", Email: "alice@example.com"}
    err := userDAO.Create(context.Background(), user)
    if err != nil {
        panic(err)
    }
    
    // 查询用户（类型安全！返回的是 User 类型）
    fetchedUser, err := userDAO.GetByID(context.Background(), 1)
    if err != nil {
        panic(err)
    }
    fmt.Printf("User: %+v\n", fetchedUser)
    
    // 创建针对 Order 的 DAO
    orderDAO := NewGenericDAO[Order](db)
    order := &Order{UserID: 1, Amount: 99.99, Status: "pending"}
    orderDAO.Create(context.Background(), order)
    
    // 列出所有订单
    orders, _ := orderDAO.List(context.Background())
    for _, o := range orders {
        fmt.Printf("Order: %+v\n", o)
    }
}

这个设计展示了泛型在业务代码中的强大威力：GenericDAO 处理了所有实体的通用CRUD逻辑，而每个实体只需要实现 Entity 接口定义的方法。类型安全得到保证——userDAO 只能操作 User 类型，orderDAO 只能操作 Order 类型，编译器会在类型不匹配时报错。

七、泛型的局限性与最佳实践

7.1 当前泛型的限制

尽管Go 1.18的泛型实现已经相当完善，但它仍然有一些已知的限制，了解这些限制有助于避免踩坑：

特别是不支持泛型方法这一限制，在实践中经常遇到。如果你需要为某个类型添加泛型能力，必须将泛型参数放在类型定义上，而不是方法上：

// 错误：Go 不支持泛型方法
// type MyStruct struct {}
// func (m MyStruct) Method[T any]() T { ... } // 编译错误！

// 正确：泛型放在类型上
 type MyStruct[T any] struct {
    value T
}

func (m MyStruct[T]) Get() T {
    return m.value
}

// 使用
intStruct := MyStruct[int]{value: 42}
fmt.Println(intStruct.Get()) // 42

// 混合使用：类型有泛型参数，方法可以操作这些参数
 type Container[T any] struct {
    items []T
}

func (c *Container[T]) Add(item T) {
    c.items = append(c.items, item)
}

// 注意：即使方法没有使用类型参数，也不能为普通类型添加泛型方法
// 这是 Go 泛型当前的明确限制

7.2 泛型最佳实践

基于Go泛型的特性和限制，以下是经过实战验证的最佳实践：

1. 优先使用具体类型，泛型是最后的选择

泛型增加了代码的抽象层次。如果具体类型能解决问题，就不要使用泛型。只有当需要为多种类型编写完全相同的逻辑时，才考虑泛型。

// 反模式：过度使用泛型
// 如果只处理 int 和 string，没必要泛型
func PrintTwo[T any](a, b T) {  // 过度设计
    fmt.Println(a, b)
}

// 更好的做法：简单场景直接写
func PrintIntAndString(a int, b string) {
    fmt.Println(a, b)
}

2. 约束要尽可能宽松

约束定义了类型参数的"能力"。约束越宽松，泛型代码的复用性越高。优先使用标准库的约束（如 constraints.Ordered、comparable），避免自定义过于严格的约束。

3. 避免在约束中使用具体类型

// 不推荐：约束过于严格
 type MyConstraint interface {
    int | string  // 只允许 int 和 string
}

// 推荐：使用 ~ 让约束更通用
 type MyConstraint interface {
    ~int | ~string  // 允许底层类型为 int 或 string 的类型
}

type MyInt int
// 使用 ~int 约束时，MyInt 也满足约束
 func Process[T ~int](v T) T {
    return v * 2
}
// Process(MyInt(5)) // 可以编译

4. 泛型类型参数命名规范

Go社区对泛型类型参数的命名有约定：通常使用单个大写字母（T、U、V等）或描述性名称（如 Key、Value、Elem）。对于简单的泛型函数，单字母足够；对于复杂的泛型类型，描述性名称更清晰。

// 简单场景：单字母
 func Min[T constraints.Ordered](a, b T) T

// 复杂场景：描述性名称
 type Map[K comparable, V any] struct {
    data map[K]V
}

// 多个类型参数：使用有意义的名称
 func Transform[In any, Out any](input []In, f func(In) Out) []Out

5. 注意代码膨胀问题

虽然Go的泛型实现会尽量复用代码（特别是指针类型），但如果为大量不同类型实例化泛型，仍可能导致二进制文件增大。在嵌入式或空间受限环境中要特别注意。