是否可以从分配给什么返回值来推断类型参数？

假设我写了两个这样的函数：

func ToInterfaceSlice[T any](s []T) []interface{} {
    res := make([]interface{}, len(s))
    for i, v := range s {
        res[i] = v
    }
    return res
}

func FromInterfaceSlice[T any](s []interface{}) (res []T, err error) {
    res = make([]T, len(s))
    for i, v := range s {
        vt, ok := v.(T)
        if !ok {
            return nil, fmt.Errorf("%v (type=%T) doesn't fit the target type %T", v, v, res)
        }
        res[i] = vt
    }
    return
}

当我从输入参数解析类型时，我可以简单地使用

    var m = []int{1, 2, 3}
    fmt.Println(ToInterfaceSlice(m))

编译器知道T is int.

但是，当我尝试从返回变量传递类型时

    var m []int
    m, _ = FromInterfaceSlice([]interface{}{1, 2, 3})
    fmt.Println(m)

编译器给出错误：

.\scratch.go:29:27: 无法推断 T

我必须在函数调用中显式传递类型：

    var m []int
    m, _ = FromInterfaceSlice[int]([]interface{}{1, 2, 3})
    fmt.Println(m)

当接收者变量不是接口时，是否有什么难以从返回类型推断类型参数的事情？还是只是不执行，甚至故意不执行？

评论后更新 #1

我知道a, b := GenericFunc()无法引用返回值的类型。目前，Go 确实有“视情况而定”的情况，是否需要用户输入的显式实例化。

type Set[T comparable] map[T]struct{}

func NewSet[T comparable](eles ...T) Set[T] {
    s := make(Set[T])
    for _, ele := range eles {
        s[ele] = struct{}{}
    }
    return s
}

两者都用就可以了t := NewSet(1, 2, 3) and t := NewSet[string]()， 但不是var t NewSet[float64] = NewSet()现在因为这个

当前类型推断的规则是explicit https://go.dev/ref/spec#Type_inference。不考虑如何使用返回值：

类型推断基于

• 类型参数列表
• 使用已知类型参数初始化的替换映射 M（如果有）
• 普通函数参数的（可能为空）列表（仅在函数调用的情况下）

从 Go 1.18 开始，您可能会简单地重写您的函数以接受所需类型的参数；这还有一个好处，就是不隐藏函数体内的分配：

func FromInterfaceSlice[T any](s []interface{}, dst []T) error {
    if len(s) != len(dst) {
        return errors.New("lengths don't match")
    }
    for i, v := range s {
        vt, ok := v.(T)
        if !ok {
            return nil, fmt.Errorf("%v (type=%T) doesn't fit the target type %T", v, v, res)
        }
        dst[i] = vt
    }
    return nil
}

并传入具有所需长度的目标切片：

func main() {
    src := []interface{}{1, 2, 3}
    m := make([]int, len(src))
    _ = FromInterfaceSlice(src, m)
    fmt.Println(m)
}

如果您不能或不想预先确定切片的长度，则只能进行显式实例化：

var m []int
m, _ = FromInterfaceSlice[int]([]interface{}{1, 2, 3})
//                        ^^^ explicit type argument

而且类型参数仍然无法推断:=简写声明：

// what is m???
m, err := FromInterfaceSlice([]interface{}{1, 2, 3})