Go语言中泛型容器的类型强制与惯用实践

package bag

// T 是一个空接口，表示任何类型
type T interface{}

// Bag 是一个存储任意类型的切片
type Bag []T

// Add 方法允许添加任何类型的值
func (a *Bag) Add(t T) {
    *a = append(*a, t)
}

// IsEmpty 检查背包是否为空
func (a *Bag) IsEmpty() bool {
    return len(*a) == 0
}

// Size 返回背包中元素的数量
func (a *Bag) Size() int {
    return len(*a)
}

package main

import (
    "fmt"
    "time"
    "your_module_path/bag" // 假设 bag 包在你的模块路径下
)

func main() {
    a := make(bag.Bag, 0, 0)
    a.Add(1)                 // 添加整数
    a.Add("Hello world!")    // 添加字符串
    a.Add(5.6)               // 添加浮点数
    a.Add(time.Now())        // 添加时间对象

    fmt.Printf("Bag size: %d, Is empty: %t\n", a.Size(), a.IsEmpty())
    fmt.Println("Contents:", a)

    // 如果尝试在运行时进行类型断言，可能会引发panic
    // val := a[0].(string) // 运行时panic: interface conversion: interface {} is int, not string
    // fmt.Println(val)
}

// 这种方式在Go 1.18之前无法实现编译时泛型接口
// type Bag interface {
//     Add(t T) // 这里的 T 依然是 interface{}，无法强制具体类型
//     IsEmpty() bool
//     Size() int
// }

type IntSlice []int

func (i *IntSlice) Add(t T) { // T 仍然是 interface{}
    // 运行时类型断言，如果 t 不是 int，则会panic
    *i = append(*i, t.(int))
}

func (i *IntSlice) IsEmpty() bool {
    return len(*i) == 0
}

func (i *IntSlice) Size() int {
    return len(*i)
}

package bag

// IntBag 是一个专门存储整数的切片
type IntBag []int

// Add 方法只接受 int 类型的参数
func (b *IntBag) Add(i int) {
    *b = append(*b, i)
}

// IsEmpty 检查背包是否为空
func (b IntBag) IsEmpty() bool { // 注意这里接收器类型可以是非指针，因为没有修改 IntBag 本身
    return len(b) == 0
}

// Size 返回背包中元素的数量
func (b IntBag) Size() int { // 同上
    return len(b)
}

package main

import (
    "fmt"
    "your_module_path/bag" // 假设 bag 包在你的模块路径下
)

func main() {
    intBag := make(bag.IntBag, 0, 0)
    intBag.Add(10) // 编译通过
    intBag.Add(20) // 编译通过
    // intBag.Add("hello") // 编译错误: cannot use "hello" (type string) as type int in argument to intBag.Add

    fmt.Printf("IntBag size: %d, Is empty: %t\n", intBag.Size(), intBag.IsEmpty())
    fmt.Println("IntBag contents:", intBag)
}

package bag

// Bag 接口定义了所有背包类型都应具备的基本行为
type Bag interface {
    IsEmpty() bool
    Size() int
}

// IntBag 的实现保持不变，它现在隐式地实现了 Bag 接口
// type IntBag []int
// func (b *IntBag) Add(i int) { ... }
// func (b IntBag) IsEmpty() bool { ... }
// func (b IntBag) Size() int { ... }

// 假设我们有另一个 StringBag
type StringBag []string

func (s *StringBag) Add(str string) {
    *s = append(*s, str)
}

func (s StringBag) IsEmpty() bool {
    return len(s) == 0
}

func (s StringBag) Size() int {
    return len(s)
}

func main() {
    var b1 Bag = bag.IntBag{}
    var b2 Bag = bag.StringBag{}

    // b1.Add(10) // 编译错误: b1 的静态类型是 Bag，不包含 Add 方法
    // b2.Add("hello") // 同上

    fmt.Println(b1.IsEmpty(), b2.Size())
}