在 Go 泛型（版本 1.18）或更高版本中使用“void”类型作为参数化类型

Question

Go 在1.18 版本中引入了泛型。我刚刚下载了最新的测试版来测试这个主要的新功能。

考虑下面的代码：

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很好，推断的类型适用int于T1和T2。然而，第二次调用未能编译。

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

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

但这会损害性能并违背我当前项目的目的。

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

谢谢！

---

编辑1（背景）：

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

例如，如果用户想要对Sum签名函数进行基准测试func(int) int，参数值在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 现在有了泛型，我可以摆脱大部分冗余组合（又名重载，比如一个 for func(int) int，另一个 for func(int) string，还有另一个 for func(int) bool），并用泛型替换它们。我希望用户能够摆脱重载，只写：

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

icza 的解决方案为“non-void”编写一个版本，为“void”编写另一个版本，问题是我的库中有很多高阶函数。随着函数参数数量的增加，我需要编写的版本数量呈指数级增长。

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

Answer 1

这不是一个错误。voidGo 中没有类型。

您的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