Golang泛型 - 方法不能包含类型参数

Golang泛型 - 方法不能包含类型参数 我对Go的新泛型无法处理泛型方法参数感到惊讶，具体如下。 我希望接受一个函数，该函数接收泛型类型T，但返回函数的返回类型R。

我想知道： a) 是否有人知道原因？也许Go并没有真正支持泛型的单态化，这是我怀疑的？ b) 是否有人知道，如果不将类型参数放在结构体本身，这到底是否可能实现？

package main

import (
	"fmt"
)

type MyThing[T any] struct {
	value T
}

func (m MyThing[T]) Perform[R any](f func(T) R) R {
	return f(m.value)
}

func main() {
	fmt.Println("Hello, playground")
}

// output: syntax error: method must have no type parameters

https://play.golang.com/p/HqidW-HW_Md


更多关于Golang泛型 - 方法不能包含类型参数的实战教程也可以访问 https://www.itying.com/category-94-b0.html

3 回复

在接近底部“没有泛型方法”的部分：

Go 泛型 - 博客标题 请注意，这不太可能改变，因为在方法上接受类型参数会使接口匹配变得奇怪和令人惊讶。

更多关于Golang泛型 - 方法不能包含类型参数的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


你是否查阅过文档：

https://go.googlesource.com/proposal/+/refs/heads/master/design/43651-type-parameters.md#No-parameterized-methods

以及当前的讨论？

proposal: spec: allow type parameters in methods

根据类型参数提案，不允许在方法中定义类型参数。

这一限制阻碍了定义函数式流处理原语，例如：

func (si *stream[IN]) Map[OUT any](f func(IN) OUT) stream[OUT]

虽然我同意这些函数式流可能效率不高，并且 Go 的设计初衷并非覆盖此类用例，但我想强调的是，Go 在流处理管道（例如 Kafka）中的应用已成为事实。允许在方法中使用类型参数将有助于构建领域特定语言（DSL），从而极大地简化某些现有用例。

其他可能受益于方法中类型参数的潜在用例包括：

  • 测试 DSL：Assert(actual).ToBe(expected)
  • 模拟 DSL：On(obj.Sum).WithArgs(7, 8).ThenReturn(15)

它们应该能提供你正在寻找的答案。

在Go语言中，方法确实不能有额外的类型参数，这是Go泛型设计的明确限制。原因在于Go的类型系统实现和编译时单态化的复杂性控制。

以下是两种可行的解决方案：

方案1：将类型参数移到结构体上

package main

import (
	"fmt"
)

// 结构体定义两个类型参数
type MyThing[T any, R any] struct {
	value T
}

// 方法使用结构体已定义的类型参数
func (m MyThing[T, R]) Perform(f func(T) R) R {
	return f(m.value)
}

func main() {
	thing := MyThing[int, string]{value: 42}
	result := thing.Perform(func(x int) string {
		return fmt.Sprintf("Value: %d", x)
	})
	fmt.Println(result) // 输出: Value: 42
}

方案2：使用包级函数替代方法

package main

import (
	"fmt"
)

type MyThing[T any] struct {
	value T
}

// 使用包级函数，可以有自己的类型参数
func Perform[T any, R any](m MyThing[T], f func(T) R) R {
	return f(m.value)
}

func main() {
	thing := MyThing[int]{value: 42}
	
	// 调用包级泛型函数
	result := Perform(thing, func(x int) string {
		return fmt.Sprintf("Value: %d", x)
	})
	fmt.Println(result) // 输出: Value: 42
}

方案3：闭包封装模式

package main

import (
	"fmt"
)

type MyThing[T any] struct {
	value T
}

// 返回一个闭包，该闭包可以处理特定返回类型
func (m MyThing[T]) AsFunc() func(func(T) any) any {
	return func(f func(T) any) any {
		return f(m.value)
	}
}

func main() {
	thing := MyThing[int]{value: 42}
	
	processor := thing.AsFunc()
	
	// 类型断言获取具体类型
	result := processor(func(x int) any {
		return x * 2
	}).(int)
	
	fmt.Println(result) // 输出: 84
}

Go团队在设计泛型时，为了避免方法类型参数带来的复杂性和歧义，明确禁止了方法上的额外类型参数。这种设计决策主要是为了保持语言的简洁性和编译器的可预测性。

回到顶部