go - 在 Go 泛型(版本 1.18)或更高版本中使用 "void"类型作为参数化类型

Question

Go 在 version 1.18 中引入了泛型.我刚刚下载了 latest beta version测试这个主要的新功能。

考虑下面的代码:

package main

import "fmt"

func Demo1(n int) int {
    return n
}

func Demo2(n int) {
    fmt.Println(n)
}

func Call[T1, T2 any](fn func(T1) T2, param T1) {
    fn(param)
}

func main() {
    // Okay
    Call(Demo1, 1)
    // type func(n int) of Demo2 does not match
    // inferred type func(int) T2 for func(T1) T2
    Call(Demo2, 2)
}

Call 函数接受函数fn 作为参数，并使用参数param 调用它。第一次调用 Call 没问题，T1 和 T2 的推断类型都是 int。然而，第二次调用编译失败。

我知道我总是可以编写一个适配器来包装 Demo2:

wrapped := func(n int) int {
    Demo2(n)
    return -1
}
Call(wrapped, 2)

但这会影响性能并破坏我当前项目的目的。

您有解决问题的想法吗？还是我应该发出错误报告？

谢谢!

---

编辑 1(背景):

我正在更新 6 年前为使用泛型而编写的基准测试库。它旨在提供精心编写的基准测试函数，以便基准测试结果比单独编写自定义基准测试更一致。

例如，如果用户想要对签名func(int) int 的函数Sum 进行基准测试，参数值介于0 之间和 10，他可以这样写:

func BenchmarkSum(b *testing.B) {
    butils.BenchmarkFnIntRetInt(b, Sum, butils.UniformDistribution(0, 10))
}

BenchmarkFnIntRetInt 可用于对其他 func(int) int 函数进行基准测试。基准测试结果比编写单独的例程更一致，例如 BenchmarkProduct 来对 Product 函数进行基准测试。由于基础相同，因此在比较不同作者的实现时，基准测试结果会更加一致。

在我的库中，函数签名如下所示:

func UniformDistribution(min, max int) func() int {
    // ...
}

func BenchmarkFnIntRetInt(
    b *testing.B,
    target func(int) int,
    paramGen func() int,
) {
    // ...
}

由于 Go 现在有了泛型，我可以摆脱大部分冗余组合(又名重载，例如 func(int) int 的重载，以及 func(int) string 的重载，还有一个用于 func(int) bool)，并用泛型代替它们。我希望用户可以摆脱重载，只写:

func BenchmarkSum(b *testing.B) {
    butils.BenchmarkGeneric(b, Sum, butils.UniformDistribution(0, 10))
}

icza's solution的问题为“非无效”编写一个版本，为“无效”编写另一个版本的原因是我的库中有很多高阶函数。随着函数参数数量的增加，我需要编写的版本数量呈指数级增长。

比如我有fn1和fn2，那么就需要4个版本；如果我有fn1、fn2和fn3，那么需要8个版本；等等。

Answer 1

这不是错误。 Go 中没有 void 类型。

您的Call() 函数需要一个函数类型的参数，该参数必须有一个结果参数。 Demo2() 没有。无论使用什么类型来实例化参数化的 Call() 函数，它都不符合 Call() 的第一个参数。

您不能用单一类型描述有或没有结果类型的函数，即使是类型参数也是如此。

您必须使用 2 个 Call() 函数，例如:

func Call[T1, T2 any](fn func(T1) T2, param T1) {
    fn(param)
}

func CallNoResult[T any](fn func(T), param T) {
    fn(param)
}

并使用它们(在 Go Playground 上尝试):

Call(Demo1, 1)
CallNoResult(Demo2, 2)

如果你需要处理所有的函数类型，你应该使用反射。这是它的本质(省略了类型和参数检查):

func Call(f interface{}, params ...interface{}) {
    v := reflect.ValueOf(f)

    vparams := make([]reflect.Value, len(params))
    for i, p := range params {
        vparams[i] = reflect.ValueOf(p)
    }
    v.Call(vparams)
}

测试它:

func Demo1(n int) int {
    fmt.Println("Demo1", n)
    return n
}

func Demo2(n int) {
    fmt.Println("Demo2", n)
}

func main() {
    Call(Demo1, 1)
    Call(Demo2, 2)
}

这将输出(在 Go Playground 上尝试):

Demo1 1
Demo2 2