Go语言中能否创建泛型结构体/接口的列表？

问题原因分析 #

你遇到的错误核心在于Go泛型的类型严格匹配规则：

• ListInterface[any]要求实现Add(any)方法，但*List[int]的Add方法签名是Add(int)，两者方法签名不兼容。
• Go中any（即interface{}）是一个具体的类型约束，泛型接口的类型参数不支持协变/逆变，因此ListInterface[int]和ListInterface[any]是完全独立的接口类型，无法互相转换。

可行解决方案 #

方案1：使用空接口存放（最简单，牺牲部分类型安全） #

直接用[]interface{}作为切片类型，存放任意类型的List实例，操作时通过类型断言恢复具体类型：

package main

import "fmt"

type List[T any] struct {
    Elements []T
}

func (f *List[T]) Add(el T) {
    f.Elements = append(f.Elements, el)
}

func main() {
    listOfLists := make([]interface{}, 0)
    listOfLists = append(listOfLists, &List[int]{}, &List[string]{})

    // 操作int类型的List
    if intList, ok := listOfLists[0].(*List[int]); ok {
        intList.Add(123)
        fmt.Println(intList.Elements) // 输出 [123]
    }

    // 操作string类型的List
    if strList, ok := listOfLists[1].(*List[string]); ok {
        strList.Add("hello")
        fmt.Println(strList.Elements) // 输出 [hello]
    }
}

方案2：定义非泛型顶层接口（兼顾存放和基础操作） #

如果需要在切片中统一调用某些方法，可以定义一个非泛型接口，让泛型List实现该接口：

package main

import "fmt"

type List[T any] struct {
    Elements []T
}

func (f *List[T]) Add(el T) {
    f.Elements = append(f.Elements, el)
}

// 定义非泛型接口，包含需要统一调用的方法（这里示例添加Len方法）
type BasicList interface {
    Len() int
}

// 让List[T]实现BasicList接口
func (f *List[T]) Len() int {
    return len(f.Elements)
}

func main() {
    listOfLists := make([]BasicList, 0)
    listOfLists = append(listOfLists, &List[int]{}, &List[string]{})

    // 统一调用Len方法
    for _, list := range listOfLists {
        fmt.Println("List length:", list.Len())
    }

    // 若要调用Add，仍需类型断言
    if intList, ok := listOfLists[0].(*List[int]); ok {
        intList.Add(456)
    }
}

方案3：修改泛型方法兼容任意类型（适合需要统一调用Add的场景） #

如果必须在切片中统一调用Add，可以修改Add方法接收interface{}，内部做类型断言：

package main

import (
    "fmt"
    "errors"
)

type List[T any] struct {
    Elements []T
}

// 修改Add方法，接收任意类型并断言为T
func (f *List[T]) Add(el interface{}) error {
    val, ok := el.(T)
    if !ok {
        return errors.New(fmt.Sprintf("expected type %T, got %T", *new(T), el))
    }
    f.Elements = append(f.Elements, val)
    return nil
}

// 定义非泛型接口
type ListInterface interface {
    Add(el interface{}) error
}

func main() {
    listOfLists := make([]ListInterface, 0)
    listOfLists = append(listOfLists, &List[int]{}, &List[string]{})

    // 统一调用Add，处理可能的错误
    if err := listOfLists[0].Add(789); err != nil {
        fmt.Println(err)
    }
    if err := listOfLists[1].Add("world"); err != nil {
        fmt.Println(err)
    }
    // 传入错误类型会返回错误
    if err := listOfLists[0].Add("wrong"); err != nil {
        fmt.Println(err) // 输出 expected type int, got string
    }
}

总结 #

Go泛型的设计更偏向类型安全，因此无法直接将*List[int]这类具体泛型类型赋值给ListInterface[any]。根据你的需求选择合适的方案：

• 仅需存放不同类型List：用[]interface{}最简便。
• 需要统一调用部分方法：定义非泛型顶层接口。
• 需要统一调用Add：修改方法兼容任意类型，同时处理类型断言错误。

内容的提问来源于stack exchange，提问作者lnlpxl