Go语言泛型演进：从interface{}到原生类型参数的实践指南

package main

import (
    "container/list"
    "fmt"
)

func main() {
    l := list.New() // 创建一个可以存储任何类型的链表

    l.PushBack(10)          // 存储一个int
    l.PushBack("hello")     // 存储一个string
    l.PushBack(struct{}{}) // 存储一个匿名结构体

    // 遍历链表并尝试获取值
    for e := l.Front(); e != nil; e = e.Next() {
        // 每次取出元素都需要进行类型断言
        if val, ok := e.Value.(int); ok {
            fmt.Printf("Int value: %d\n", val)
        } else if val, ok := e.Value.(string); ok {
            fmt.Printf("String value: %s\n", val)
        } else {
            fmt.Printf("Other value: %v\n", e.Value)
        }
    }

    // 尝试错误类型断言会导致运行时panic
    // val := l.Front().Value.(float64) // 如果第一个元素不是float64，将panic
    // fmt.Println(val)
}

// 假设这是由gen工具根据用户定义生成的代码
// 文件名可能为 `intlist_gen.go` 或类似
package mypackage

// IntSliceGen 是一个由gen生成的，用于int类型切片的辅助类型
type IntSliceGen []int

// Filter 方法：生成一个针对int切片的过滤函数
func (s IntSliceGen) Filter(predicate func(int) bool) IntSliceGen {
    result := make(IntSliceGen, 0, len(s))
    for _, v := range s {
        if predicate(v) {
            result = append(result, v)
        }
    }
    return result
}

// Sum 方法：生成一个针对int切片的求和函数
func (s IntSliceGen) Sum() int {
    total := 0
    for _, v := range s {
        total += v
    }
    return total
}

// main.go (用户在自己的代码中使用生成的包)
package main

import (
    "fmt"
    "mypackage" // 导入gen生成的包
)

func main() {
    numbers := mypackage.IntSliceGen{1, 2, 3, 4, 5}

    // 使用gen生成的类型安全方法
    evens := numbers.Filter(func(n int) bool { return n%2 == 0 })
    fmt.Println("Even numbers:", evens) // Output: Even numbers: [2 4]

    sumOfEvens := evens.Sum()
    fmt.Println("Sum of even numbers:", sumOfEvens) // Output: Sum of even numbers: 6

    // 如果需要处理string类型，gen会生成一个StringSliceGen类型及其对应方法
    // strings := mypackage.StringSliceGen{"apple", "banana", "cherry"}
    // longStrings := strings.Filter(func(s string) bool { return len(s) > 5 })
    // fmt.Println("Long strings:", longStrings) // Output: Long strings: [banana cherry]
}

package main

import "fmt"

// 泛型函数：Filter，可以过滤任何类型的切片
// T 是类型参数，any 是类型约束，表示T可以是任何类型
func Filter[T any](slice []T, predicate func(T) bool) []T {
    var result []T // result 的类型会根据T自动确定
    for _, v := range slice {
        if predicate(v) {
            result = append(result, v)
        }
    }
    return result
}

// 泛型结构体：List，可以存储任何类型的元素
type List[T any] struct {
    head *Element[T]
    tail *Element[T]
    len  int
}

type Element[T any] struct {
    Value T
    next  *Element[T]
    prev  *Element[T]
}

// PushBack 方法：泛型List的方法，接受类型T的值
func (l *List[T]) PushBack(v T) *Element[T] {
    e := &Element[T]{Value: v}
    if l.tail == nil {
        l.head = e
        l.tail = e
    } else {
        l.tail.next = e
        e.prev = l.tail
        l.tail = e
    }
    l.len++
    return e
}

func (l *List[T]) Len() int {
    return l.len
}

func main() {
    // 使用泛型Filter函数处理int切片
    intSlice := []int{1, 2, 3, 4, 5, 6}
    evenInts := Filter(intSlice, func(i int) bool { return i%2 == 0 })
    fmt.Println("Even integers:", evenInts) // Output: Even integers: [2 4 6]

    // 使用泛型Filter函数处理string切片
    stringSlice := []string{"apple", "banana", "cherry", "date"}
    longStrings := Filter(stringSlice, func(s string) bool { return len(s) > 5 })
    fmt.Println("Long strings:", longStrings) // Output: Long strings: [banana cherry]

    // 使用泛型List结构体存储int类型
    var intList List[int]
    intList.PushBack(10)
    intList.PushBack(20)
    intList.PushBack(30)
    fmt.Printf("Int list length: %d, first element: %d\n", intList.Len(), intList.head.Value) // Output: Int list length: 3, first element: 10

    // 使用泛型List结构体存储string类型
    var stringList List[string]
    stringList.PushBack("Go")
    stringList.PushBack("Generics")
    fmt.Printf("String list length: %d, first element: %s\n", stringList.Len(), stringList.head.Value) // Output: String list length: 2, first element: Go

    // 尝试向intList添加string会导致编译错误
    // intList.PushBack("wrong type") // 编译错误: cannot use "wrong type" (type string) as type int in argument to intList.PushBack
}