Go 泛型：从历史考量到 Go 1.18 的实践与应用

package main

import "fmt"

// PrintList 打印一个interface{}切片中的所有元素
func PrintList(list []interface{}) {
    for i, item := range list {
        fmt.Printf("Index %d: %v\n", i, item)
    }
}

func main() {
    intList := []interface{}{1, 2, 3}
    PrintList(intList)

    stringList := []interface{}{"hello", "world"}
    PrintList(stringList)

    // 如果需要取出特定类型的值，则需要类型断言
    var firstInt int
    if len(intList) > 0 {
        if val, ok := intList[0].(int); ok {
            firstInt = val
            fmt.Printf("First int: %d\n", firstInt)
        }
    }
}

// 示例：一个简单的类型约束，表示任何可比较的类型
type Comparable interface {
    // 定义一个方法，用于比较两个相同类型的值
    // Go标准库中已经提供了 comparable 预定义约束
    // 例如：type Ordered interface { ~int | ~float64 | ~string }
}

package main

import "fmt"

// Number 约束定义了所有可以进行大小比较的数值类型
type Number interface {
    ~int | ~int8 | ~int16 | ~int32 | ~int64 |
        ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
        ~float32 | ~float64
}

// Min 是一个泛型函数，返回两个 Number 类型值中较小的一个
func Min[T Number](a, b T) T {
    if a < b {
        return a
    }
    return b
}

func main() {
    fmt.Println("Min(10, 20):", Min(10, 20))         // T 推断为 int
    fmt.Println("Min(3.14, 2.71):", Min(3.14, 2.71)) // T 推断为 float64
    fmt.Println("Min(-5, 0):", Min[int](-5, 0))      // 显式指定 T 为 int
}

package main

import "fmt"

// Stack 是一个泛型栈结构体
type Stack[T any] struct {
    elements []T
}

// Push 将元素压入栈顶
func (s *Stack[T]) Push(item T) {
    s.elements = append(s.elements, item)
}

// Pop 从栈顶弹出元素
func (s *Stack[T]) Pop() (T, bool) {
    if s.IsEmpty() {
        var zero T // 返回该类型的零值
        return zero, false
    }
    index := len(s.elements) - 1
    item := s.elements[index]
    s.elements = s.elements[:index]
    return item, true
}

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

func main() {
    // 创建一个整数栈
    intStack := Stack[int]{}
    intStack.Push(10)
    intStack.Push(20)
    fmt.Println("Popped from intStack:", intStack.Pop()) // Output: Popped from intStack: 20 true

    // 创建一个字符串栈
    stringStack := Stack[string]{}
    stringStack.Push("hello")
    stringStack.Push("world")
    fmt.Println("Popped from stringStack:", stringStack.Pop()) // Output: Popped from stringStack: world true
}