不能使用 *T 类型的变量作为参数的类型

Question

我正在学习 Go 1.18 泛型，我试图理解为什么我在这里遇到麻烦。长话短说，我正在尝试 Unmarshal 一个 protobuf，我希望 blah 中的参数类型“正常工作”。我已经尽可能地简化了问题，这个特定的代码正在重现我看到的相同错误消息：

./prog.go:31:5: cannot use t (variable of type *T) as type stringer in argument to do:
    *T does not implement stringer (type *T is pointer to type parameter, not type parameter)

package main

import "fmt"

type stringer interface {
    a() string
}

type foo struct{}

func (f *foo) a() string {
    return "foo"
}

type bar struct{}

func (b *bar) a() string {
    return "bar"
}

type FooBar interface {
    foo | bar
}

func do(s stringer) {
    fmt.Println(s.a())
}

func blah[T FooBar]() {
    t := &T{}
    do(t)
}

func main() {
    blah[foo]()
}

我意识到我可以通过不使用泛型来完全简化这个示例（即将实例传递给 blah(s stringer) {do(s)}。但是，我确实想了解为什么会发生错误。

我需要对这段代码进行哪些更改才能创建 T 的实例并将该指针传递给需要特定方法签名的函数？

Answer 1

在您的代码中，约束 FooBar 和 stringer 之间没有关系。此外，这些方法是在指针接收器上实现的。

对你设计的程序的一个快速而肮脏的修复是简单地断言 *T 确实是一个 stringer:

func blah[T FooBar]() {
    t := new(T)
    do(any(t).(stringer))
}

游乐场：https://go.dev/play/p/zmVX56T9LZx

但这会放弃类型安全，并且可能会在运行时发生恐慌。为了保持编译时类型安全，另一种在一定程度上保留程序语义的解决方案是：

type FooBar[T foo | bar] interface {
    *T
    stringer
}

func blah[T foo | bar, U FooBar[T]]() {
    var t T
    do(U(&t))
}

这是怎么回事？

首先，类型参数与其约束之间的关系不是同一性的：T 不是 FooBar。您不能像使用 FooBar 那样使用 T，因此 *T 绝对不等同于 *foo 或 *bar.

因此，当您调用 do(t) 时，您试图将 类型 *T 传递给需要 stringer 的对象，但是T，指针与否，只是在其类型集中本身没有 a() string 方法。

第 1 步：将方法 a() string 添加到 FooBar 接口（通过嵌入 stringer）：

type FooBar interface {
    foo | bar
    stringer
}

但这还不够，因为现在 none 您的类型实际上实现了它。两者都在指针接收器上声明了方法。

第 2 步：将联合中的类型更改为指针：

type FooBar interface {
    *foo | *bar
    stringer
}

此约束现在有效，但您还有另一个问题。当约束没有核心类型时，您不能声明复合文字。所以t := T{}也是无效的。我们改成：

func blah[T FooBar]() {
    var t T // already pointer type
    do(t)
}

现在可以编译了，但是 t 实际上是一个指针类型的零值，所以它是 nil。您的程序不会崩溃，因为这些方法只是 return 一些字符串文字。

如果你还需要初始化指针引用的内存，在blah你需要了解基本类型。

第 3 步：所以您添加 T foo | bar 作为一种类型参数，并将签名更改为：

func blah[T foo | bar, U FooBar]() {
    var t T
    do(U(&t))
}

完成了吗？还没有。转换 U(&t) 仍然无效，因为 U 和 T 的类型集不匹配。您现在需要在 T.

中参数化 FooBar

第 4 步：基本上，您将 FooBar 的联合提取到一个类型参数中，这样在编译时它的类型集将仅包含以下两种类型之一：

type FooBar[T foo | bar] interface {
    *T
    stringer
}

约束现在可以用 T foo | bar 实例化，保持类型安全、指针语义并将 T 初始化为 non-nil。

func (f *foo) a() string {
    fmt.Println("foo nil:", f == nil)
    return "foo"
}

func main() {
    blah[foo]()
}

打印：

foo nil: false
foo

游乐场：https://go.dev/play/p/src2sDSwe5H

如果你可以用指针类型实例化 blah，或者更好地向它传递参数，你就可以删除所有中间技巧：

type FooBar interface {
    *foo | *bar
    stringer
}

func blah[T FooBar](t T) {
    do(t)
}

func main() {
    blah(&foo{})
}

不能使用 *T 类型的变量作为参数的类型

Cannot use variable of type *T as type in argument

generics

go