泛型语法
函数名后可以附带一个方括号，包含了该函数涉及的类型参数（Type Paramters）的列表：
func F[T any](p T) { ... }
这些类型参数可以在函数参数和函数体中（作为类型）被使用
自定义类型也可以有类型参数列表：
type M[T any] []T
每个类型参数对应一个类型约束，上述的 any 就是预定义的匹配任意类型的约束
类型约束在语法上以 interface 的形式存在，在 interface 中嵌入类型 T 可以表示这个类型必须是 T:
type Integer1 interface {
int
}嵌入单个类型意义不大，我们可以用 | 来描述类型的 union:
type Integer2 interface {
int | int8 | int16 | int32 | int64
}~T 语法可以表示该类型的「基础类型」是 T，比如说我们的自定义类型 type MyInt int 不满足上述的 Integer1 约束，但满足以下的约束:
type Integer3 interface {
~int
}上手使用
例如，有 string->int64 和 string->float64 两类 map，我们需要对 map 的 value 求和。
使用泛型前的代码：
package main
import "fmt"
func main() {
ints := map[string]int64{
"a": 1,
"b": 2,
}
floats := map[string]float64{
"a": 3.0,
"b": 4.0,
}
fmt.Printf("Generic Sums: %v and %v\n",
SumInts(ints),
SumFloats(floats))
}
// SumInts adds together the values of m.
func SumInts(m map[string]int64) int64 {
var s int64
for _, v := range m {
s += v
}
return s
}
// SumFloats adds together the values of m.
func SumFloats(m map[string]float64) float64 {
var s float64
for _, v := range m {
s += v
}
return s
}使用泛型替换上述代码：
package main
import "fmt"
func main() {
ints := map[string]int64{
"a": 1,
"b": 2,
}
floats := map[string]float64{
"a": 3.0,
"b": 4.0,
}
fmt.Printf("Generic Sums: %v and %v\n",
SumIntsOrFloats(ints),
SumIntsOrFloats(floats))
}
// SumIntsOrFloats sums the values of map m. It supports both int64 and float64 as types for map values.
func SumIntsOrFloats[K comparable, V int64 | float64](m map[K]V) V {
var s V
for _, v := range m {
s += v
}
return s
}代码说明：
声明了一个 SumIntsOrFloats 函数，此函数参数类型为 map，返回值类型为 V，函数的作用是对 map 的 int64 或 float64 类型 value 求和。
map 的 K 和 V 是泛型类型，泛型的约束写在 方括号 [ ] 中，K 具有约束 comparable（即可做 == 或 != 运算，参考 深入理解 Go Comparable Type），V 是 int64 或 float64（也相当于是对入参类型的约束）。
当然，map 的 key 的类型也可以不一样，满足
package main
import "fmt"
func main() {
ints := map[string]int64{
"a": 1,
"b": 2,
}
floats := map[int32]float64{
5: 3.0,
6: 4.0,
}
fmt.Printf("Generic Sums: %v and %v\n",
SumIntsOrFloats[string, int64](ints),
SumIntsOrFloats[int32, float64](floats))
}
// SumIntsOrFloats sums the values of map m. It supports both int64 and float64 as types for map values.
func SumIntsOrFloats[K comparable, V int64 | float64](m map[K]V) V {
var s V
for _, v := range m {
s += v
}
return s
} 即：需要和函数定义一样写明参数类型。
当然，此处参数类型不写也可以（可以省略，但前提是编译器可以从函数参数的类型推断类型参数）
“编译器可以从函数参数的类型推断类型参数”，不太明白，哪位大佬举个例子或给个反例？
令人沮丧
泛型类型系统的不足
众多函数式特性的实现依赖于一个强大类型系统，Go 的类型系统显然不足以胜任, 在 Go 语言中引入泛型之后，类型系统有哪些水土不服的地方。
编译期类型判断
当我们在写一段泛型代码里的时候，有时候会需要根据 T 实际上的类型决定接下来的流程，可 Go 的完全没有提供在编译期操作类型的能力。运行期的 workaround 当然有，怎么做呢：将 T 转化为 interface{}，然后做一次 type assertion, 比如我想实现一个通用的字符串类型到数字类型的转换函数:
type Number interface {
int | int32 | int64 | uint32 | uint64 | float64
}
func Str2Number[N Number](strNumber string) (N, error) {
var num N
switch (interface{})(num).(type) {
case int:
cn, err := strconv.Atoi(strNumber)
return N(cn), err
case int32:
cn, err := strconv.ParseInt(strNumber, 10, 32)
return N(cn), err
case int64:
cn, err := strconv.ParseInt(strNumber, 10, 64)
return N(cn), err
case uint32:
cn, err := strconv.ParseUint(strNumber, 10, 32)
return N(cn), err
case uint64:
cn, err := strconv.ParseUint(strNumber, 10, 64)
return N(cn), err
case float64:
cn, err := strconv.ParseFloat(strNumber, 64)
return N(cn), err
}
return 0, nil
}无法辨认「基础类型」
在类型约束中可以用 ~T 的语法约束所有 基础类型为 T 的类型，这是 Go 在语法层面上首次暴露出「基础类型」的概念，在之前我们只能通过 reflect.(Value).Kind 获取。而在 type assertion 和 type switch 里并没有对应的语法处理「基础类型」:
type Int interface {
~int | ~uint
}
func IsSigned[T Int](n T) {
switch (interface{})(n).(type) {
case int:
fmt.Println("signed")
default:
fmt.Println("unsigned")
}
}
func main() {
type MyInt int
IsSigned(1) // Output: signed
IsSigned(MyInt(1)) //Output: unsigned
}乍一看很合理，MyInt 确实不是 int。那我们要如何在函数不了解 MyInt 的情况下把它当 int 处理呢, 比较抱歉的是目前在1.18中没办法对这个进行处理。
类型约束不可用于 type assertion
一个直观的想法是单独定义一个 Signed 约束，然后判断 T 是否满足 Signed:
package main
import (
"fmt"
)
type Signed interface {
~int
}
type Int interface {
~int | ~uint
}
func IsSigned[T Int](n T) {
if _, ok := (interface{})(n).(Signed); ok {
fmt.Println("signed")
} else {
fmt.Println("unsigned")
}
}
func main() {
type MyInt int
IsSigned(1)
IsSigned(MyInt(1))
}但很可惜，类型约束不能用于 type assertion/switch，编译器报错如下：
interface contains type constraints
尽管让类型约束用于 type assertion 可能会引入额外的问题，但牺牲这个支持让 Go 的类型表达能力大大地打了折扣。
总结
确实可以实现部分函数式特性能以更通用的方式。
灵活度比代码生成更高 ，用法更自然，但细节上的小问题很多。
1.18 的泛型在引入 type paramters 语法之外并没有其他大刀阔斧的改变，导致泛型和这个语言的其他部分显得有些格格不入，也使得泛型的能力受限。 至少在 1.18 里，我们要忍受泛型中存在的种种不一致。
受制于 Go 类型系统的表达能力，我们无法表示复杂的类型约束，自然也无法实现完备的函数式特性。
《本文》有 0 条评论