Go中实现含联合类型参数的接口方法时无法访问结构体字段

我定义了一个带Calculate方法的接口，这个方法有两种实现，各自接收不同的参数。学习Go泛型后，我尝试用联合类型实现，代码如下：

type MinimumInfo struct {
    name string
}
type ExtendedInfo struct {
    name        string
    description string
}

// 定义联合类型的接口
type Info interface {
    MinimumInfo | ExtendedInfo
}

// 带泛型参数的Calculator接口
type Calculator[T Info] interface {
    Calculate(info *T)
}

接着我写了两个实现：适配MinimumInfo的BasicCalculator和适配ExtendedInfo的ExtendedCalculator：

// 为MinimumInfo实现Calculator接口
type BasicCalculator[T MinimumInfo] struct {
}

func (b *BasicCalculator[T]) Calculate(info *T) {
    fmt.Println("From basic calculator")
    fmt.Printf("Object %+v \n", info)

    // 这行代码无法运行
    //fmt.Printf("Name is %s \n", info.name)
}

// 为ExtendedInfo实现Calculator接口
type ExtendedCalculator[T ExtendedInfo] struct {
}

func (b *ExtendedCalculator[T]) Calculate(info *T) {
    fmt.Println("From extended calculator")
    fmt.Printf("Object %+v \n", info)

    // 这行代码无法运行
    //fmt.Printf("Name is %s \n", info.name)
}

main函数代码：

func main() {
    info1 := &MinimumInfo{
        name: "minimum",
    }
    calc := &BasicCalculator[MinimumInfo]{}
    calc.Calculate(info1)

    info2 := &ExtendedInfo{
        name:        "extended",
        description: "description",
    }
    calc2 := &ExtendedCalculator[ExtendedInfo]{}
    calc2.Calculate(info2)
}

现在的问题是：虽然能正常打印对象，但我无法在Calculate方法中访问对象的字段（比如info.name）。我不确定自己对Go泛型的理解是否正确，不知道问题出在哪，也不清楚为什么无法识别对象类型。

核心问题在于你对泛型约束的使用逻辑偏差，以及没必要的泛型滥用：

1. 最直接的解决：去掉不必要的泛型 #

你的两个计算器各自只适配一种结构体类型，完全不需要泛型。直接修改代码为非泛型实现，就能正常访问字段：

// 为MinimumInfo实现Calculator接口
type BasicCalculator struct {
}

func (b *BasicCalculator) Calculate(info *MinimumInfo) {
    fmt.Println("From basic calculator")
    fmt.Printf("Object %+v \n", info)
    fmt.Printf("Name is %s \n", info.name) // 现在可以正常访问
}

// 为ExtendedInfo实现Calculator接口
type ExtendedCalculator struct {
}

func (b *ExtendedCalculator) Calculate(info *ExtendedInfo) {
    fmt.Println("From extended calculator")
    fmt.Printf("Object %+v \n", info)
    fmt.Printf("Name is %s \n", info.name) // 正常访问
}

2. 若需泛型复用逻辑：用方法约束暴露字段 #

如果确实需要通过泛型复用部分逻辑，不能直接依赖联合类型的字段访问，要给结构体定义公共接口来暴露字段：

// 定义公共接口，暴露需要访问的字段方法
type HasName interface {
    GetName() string
}

// 给两个结构体实现该接口
func (m *MinimumInfo) GetName() string {
    return m.name
}

func (e *ExtendedInfo) GetName() string {
    return e.name
}

// 修改泛型约束为该接口
type Calculator[T HasName] interface {
    Calculate(info *T)
}

// 通用计算器实现
type GenericCalculator[T HasName] struct {
}

func (g *GenericCalculator[T]) Calculate(info *T) {
    fmt.Printf("Name is %s \n", info.GetName()) // 通过方法访问字段
}

这样既保留了泛型的灵活性，又能安全访问结构体的公共字段。

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