你真的了解泛型 Generic 嘛?

Posted qcrao

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了你真的了解泛型 Generic 嘛?相关的知识,希望对你有一定的参考价值。

泛型 Generic Programming[1] 通常指允许程序员在强类型程序设计语言中,编写代码时使用一些以后才指定的类型,在实例化时作为参数指明这些类型,即类型参数化

首先我们不是科班讨论学术,有些概念比较模糊也正常,本文讨论的内容意在给大家提供全局的视野看待泛型 Generic, 大致了解主流语言的实现

泛型会提供哪些便利呢?上面的动图非常经典,比如 min 函数,如果没有泛型,需要针对 int, float, string 分别写出不同的特定实现,代码非常冗余。本文会讨论下为什么 go 需要泛型以及 go2 泛型的 proposal[2]

CPP 模板

#include <iostream>
template <class T>
T max(T a,T b){
  T ret = a > b? a : b;
  std::cout<< a << " and " << b <<" max is " << ret << std::endl;
  return ret;
}
int main(){
  max(1,2);  // 整数
  max(1.2,2.3); // 浮点数
  return 0;
}

上面是 cpp 模板实现的 max 泛型函数,传入 int, float 都可以工作

$ c++ max.cpp  -o max && ./max
1 and 2 max is 2
1.2 and 2.3 max is 2.3

运行结果如上所示,同样代码换成 go 肯定就是错的,本质是模板在编译期单态化,针对每个特定类型生成了特定函数

$ nm max | grep -i max
0000000100000f90 T __Z3maxIdET_S0_S0_
0000000100000ef0 T __Z3maxIiET_S0_S0_
$ c++filt __Z3maxIdET_S0_S0_
double max<double>(double, double)
$ c++filt __Z3maxIiET_S0_S0_
int max<int>(int, int)

通过 nm 查看二进制的符号表,生成了两个函数,签名分别是 double max<double>(double, double), int max<int>(int, int)

CPP 模板非常强大,但是也有缺点,比如二进制膨胀的厉害,有可能影响到 cpu icache, 业务代码无所谓了。另外 T 没有其它语言的 constraint 或 bounded, 比如要求 T 必须实现某些方法,然后函数内只能调用这些显示的约束(C++20 会引入 concepts 实现约束)

C 怎么实现

C 严格意义上没有实现,但在 C11 标准中引入了 _Generic 泛型选择器,阉割版的实现

#include <stdio.h>
// int类型加法
int addI(int a, int b)
{
    printf("%d + %d = %d\\n",a,b, a + b );
    return (a + b);
}
// double类型加法
double addF(double a, double b)
{
    printf("%f + %f = %f\\n",a,b, a + b );
    return (a + b);
}
void unsupport(int a,int b)
{
    printf("unsupport type\\n");
}
#define ADD(a,b) _Generic((a), \\
    int:addI(a,b),\\
    double:addF(a,b), \\
    default:unsupport(a,b))
int main(void)
{
    ADD(1 , 2);
    ADD(1.1,2.2);
    return 0;
}

上面是实现的 ADD 方法,只是调用的时候看起来是泛型了。这种实现是有缺点的,c 会做很多隐式转换,即使你传入字符串,也会编译成功,并且取得一个值。并没有在编译期确保类型 a, b 一致

同时由于 c 不支持函数名重载,还要人工编写特定实例的函数 addF, addI, 并且二进制的符号表并没有 ADD. 类比 cpp 是由编译器替我们完成

在 C11 以前的标准中,很多代码都是用 void * 实现,问题在于 void 是没有类型信息的,需要增加特定的函数指针回调,让我们来看 redis 例子

typedef struct dictType {
    uint64_t (*hashFunction)(const void *key);
    void *(*keyDup)(void *privdata, const void *key);
    void *(*valDup)(void *privdata, const void *obj);
    int (*keyCompare)(void *privdata, const void *key1, const void *key2);
    void (*keyDestructor)(void *privdata, void *key);
    void (*valDestructor)(void *privdata, void *obj);
} dictType;


typedef struct dict {
    dictType *type;
    void *privdata;
    dictht ht[2];
    long rehashidx; /* rehashing not in progress if rehashidx == -1 */
    unsigned long iterators; /* number of iterators currently running */
} dict;

上面的代码来自 redis dict[3], 字典是泛型的,value 可以是任意类型,只要实现了 dictType 定义的函数指针。内核里面也有大量类似实现,非常通用

Rust 实现

Rust 泛型也同样编译期单态化,运行时没有开销

fn printer<T: Display>(t: T) {
    println!("{}", t);
}

这里定义函数 printer, 类型 T 必须实现了 Display trait, 这就是所谓的 constraint 或者 bounded

impl <A, D> MyTrait<A, D> for YourType where
    A: TraitB + TraitC,
    D: TraitE + TraitF {
    
}

但假如需要满足多个约束的时候,在 <> 里写就很不简洁,需要使用 where[4] 关键字

Rust 很多时候难懂,就是因为叠加了泛型,生命周期,所有权,还有很多的 wrapper, 别说写了,读都读不懂

Java 版本

Java 在 1.5 版本引入了泛型,它的泛型是用类型擦除实现的。Java 的泛型只是在编译期间用于检查类型的正确,为了保证与旧版本 JVM 的兼容,类型擦除会删除泛型的相关信息,导致其在运行时不可用。关于这块可以参考 大神R大的回答[5], 早就有类似 cpp 实现,只是涉及兼容上的取舍,不得不这么做

编译器会插入额外的类型转换指令,与 C 语言和 C++ 在运行前就已经实现或者生成代码相比,Java 类型的装箱和拆箱会降低程序的执行效率。非 Java 党就不写太多了

Go 为什么需要泛型

官方要在 go1.18 引入泛型,那现在我们是怎么用的呢?很多时候就是 copy 代码,或者用 interface{} 代替

func Max(a , b Comparable) Comparable

比如常见的 Max 函数,传入参数 a, b 都实现了 Comparable 接口,然后返回最大值。能工作不?能,但是有问题

  1. 丢失了类型信息,原来 cpp/rust 的实现,在函数中操作的都是原始类型,如果用 interface 还需要断言,这是运行时行为,性能损失很大

  2. 表达力不够,比如 a, b 不能确保是同一个类型,可能一个是 int, 另外一个是 struct. 如果想传入的是类型组合呢?

再看一个 interface{} 不能当成泛型的例子

func sort(arr []interface{})

这个排序函数如果传入 sort([]int{1,2,3}) 或是 sort([]float64{1.032, 3.012}) 都会报错,原因是什么呢???

在 go 中 []interface{} 类型是 slice 不是 interface{}, go 中对比接口相等时,是判断 itab 中 type 和 data 需要都一致。换句话说,不允许类型的协变(没其它语言背景的不必纠结概念,在 Go2 中也不打算支持协变和逆变)

同时社区还有其它库辅助,比如 genny[6] 和 betterGO[7], 本质还是上面的动图

// NOTE: this is how easy it is to define a generic type
type Something generic.Type

// SomethingQueue is a queue of Somethings.
type SomethingQueue struct {
  items []Something
}

func NewSomethingQueue() *SomethingQueue {
  return &SomethingQueue{items: make([]Something, 0)}
}
func (q *SomethingQueue) Push(item Something) {
  q.items = append(q.items, item)
}
func (q *SomethingQueue) Pop() Something {
  item := q.items[0]
  q.items = q.items[1:]
  return item
}

上面定义了一个泛型 type Something generic.Type, 然后用 go generate 生成对应的泛型代码

cat source.go | genny gen "Something=string"
// StringQueue is a queue of Strings.
type StringQueue struct {
  items []string
}

func NewStringQueue() *StringQueue {
  return &StringQueue{items: make([]string, 0)}
}
func (q *StringQueue) Push(item string) {
  q.items = append(q.items, item)
}
func (q *StringQueue) Pop() string {
  item := q.items[0]
  q.items = q.items[1:]
  return item
}

最后替换相应的类型,生成对应源码文件,人肉模板骚不骚^^

Go2 泛型

泛型讨论了很久,参见 generic programming facilities[8], Why Generics[9], Next Step[10], 以及官方 proposal[11], 这是最终版,语法上不会再改变。为了运行时性能,go 的实现类似 rust 编译期单态化,而且为了兼容 go1 语法也会做一些妥协。如果近期想阅读源码的,不如等到明年 go1.18, 因为引入泛型源码库变更会很大

1.Multiple type parameters

// Print prints the elements of any slice.
// Print has a type parameter T and has a single (non-type)
// parameter s which is a slice of that type parameter.
func Print[T any](s []T) {
 ......
}

类型参数列表,放到中括号里 [], 其中 T 是类型,any 关键字是表示可以传入任意类型。居然不是业界通用的尖括号 <> 感觉非常丑... 其中 any 其实就是 interface{} 空接口,写起来相对方便,而且语意上表达更准确一些

// Print2 has two type parameters and two non-type parameters.
func Print2[T1, T2 any](s1 []T1, s2 []T2) { ... }
// Print2Same has one type parameter and two non-type parameters.
func Print2Same[T any](s1 []T, s2 []T) { ... }

Print2 中可以传入相同或不同的类型,比如 Print2[int, int]Print2[int, string] 都是允许的

但是 Print2Same 的参数 s1, s2 类别必然要相同,编译期保证。这也就是上面提到 go1 时 interface{} 模拟泛型的问题

2.Constraint

func Stringify[T any](s []T) (ret []string) {
 for _, v := range s {
  ret = append(ret, v.String()) // INVALID
 }
 return ret
}

这个例子是不会编译成功的,因为 T 是任意类型,并没有实现 String() 方法。也就是说,泛型函数只允许调用 constraint 约束里显示指定的方法 这样的好处是,对于大型项目的构建,不会因为隐式的改动,而改变兼容性

相比于 rust where 语句,go 中增加了类型参数列表和接口的组合,做为约束

package constraints

// Ordered is a type constraint that matches any ordered type.
// An ordered type is one that supports the <, <=, >, and >= operators.
type Ordered interface {
 type int, int8, int16, int32, int64,
  uint, uint8, uint16, uint32, uint64, uintptr,
  float32, float64,
  string
}

上面是约束的定义,关键字 type 后面跟上允许的类型列表,不知道为啥就是丑。其它语言用到哪个类型,编译期单态就好了,go 需要人工枚举所有可能...

// Smallest returns the smallest element in a slice.
// It panics if the slice is empty.
func Smallest[T constraints.Ordered](s []T) T {
 r := s[0] // panics if slice is empty
 for _, v := range s[1:] {
  if v < r {
   r = v
  }
 }
 return r
}

3.泛型类型

上面提到的都是 Generic Func, 另一个使用场景是泛型类型 Generic Type

// Vector is a name for a slice of any element type.
type Vector[T any] []T

上面标准的泛型容器定义,类似其它语言的 Vector

// Push adds a value to the end of a vector.
func (v *Vector[T]) Push(x T) { *v = append(*v, x) }

同样,泛型类型还可以定义方法

// List is a linked list of values of type T.
type ListNode[T] {xxx}
type List[T] struct {
    head *ListNode[T]
    tail *ListNode[T]
    size int
}


// This type is INVALID.
type P[T1, T2 any] struct {
 F *P[T2, T1] // INVALID; must be [T1, T2]
}

上面是定义的 struct 语法,比较相似。但如果泛型类型,有指向自己的指针,那么注意参数顺序也要一样,P[T1, T2 any] 这样写的,那么指针也要 *[T1, T2]. 官方说防止类型实例化的递归

4.Comparable types in constraints

Go 不允许重载操作符,这样好处多多。但同时代表着大于,小于这些只适用于基本类型。但也有例外 ==, != 可以比较 struct, array, interface. 官方在标准库预定义了约束 comparable 用于比较

// Index returns the index of x in s, or -1 if not found.
func Index[T comparable](s []T, x T) int {
 for i, v := range s {
  // v and x are type T, which has the comparable
  // constraint, so we can use == here.
  if v == x {
   return i
  }
 }
 return -1
}

上面的例子很清晰明了,T 实现了比较接口,就可以用 ==

// ComparableHasher is a type constraint that matches all
// comparable types with a Hash method.
type ComparableHasher interface {
 comparable
 Hash() uintptr
}
// ImpossibleConstraint is a type constraint that no type can satisfy,
// because slice types are not comparable.
type ImpossibleConstraint interface {
 comparable
 type []int
}

用 interface 实现约束,上面的例子是 hasher 接口,下面的接口是永远不能实现的,很好理解,类型 []int 是不能比较的

5.类型推导 type inference

类型推导很重要,可以省略很多无用代码,编译器自动识别类型

func Map[F, T any](s []F, f func(F) T) []T { ... }

这是一个 Map 算子函数的签名,f 匿名函数,将 []F 转换成 []T 类型 slice

 var s []int
 f := func(i int) int64 { return int64(i) }
 var r []int64
 // Specify both type arguments explicitly.
 r = Map[int, int64](s, f)
 // Specify just the first type argument, for F,
 // and let T be inferred.
 r = Map[int](s, f)
 // Don't specify any type arguments, and let both be inferred.
 r = Map(s, f)

最理想只需要调用 r=Map(s, f) 就可以,否则还要写 r = Map[int, int64](s, f), 能推导的就不要让人写

除了上面的,再举个例子比如 T1, T2 是两个类型参数,那么 []map[int]bool 可以和以下类型统一 unified 起来

  • []map[int]bool 这个就是类型自身,很好理解

  • T1 当然可以匹配

  • []T1 T1 匹配到 map[int]bool

  • []map[T1]T2 这里 T1 是 int, T2 是 bool

上面只是几种可能,但同时不能匹配到 int, struct{}, []map[T1]string 这也是显而易见的。虽然 go2 不支持协变,但是基于类型推导还是比 go1 方便的多

6.type lists 组合

// StringableSignedInteger is a type constraint that matches any
// type that is both 1) defined as a signed integer type;
// 2) has a String method.
type StringableSignedInteger interface {
 type int, int8, int16, int32, int64
 String() string
}

约束还可以将 类型列表 与普通的接口函数组合起来。上面的 StringableSignedInteger 要求约束,必须是 type list 里的任一类型,同时实现了 String() string 函数

问题是 int 这些都没有 string 方法,所以上面约束其实是 impossible 的,只是举例子说明如何使用

7.未实现部份

官方还列举了很多 omissions[12] 未实现的点

比如不支持:特化,元编程(cpp 玩烂了),curry 柯立化等等,泛型分享内容大致这些,感兴趣直接看官网好了

泛型代价

引入泛型不是没有代价的,都是取舍,好在 go 语言诞生才十年,没有很重的历史包袱

  • Slow Compiler: 这是 c++/rust 泛型

  • Slow Performance: 这是 java/scala 泛型

  • Slow Programmer: 这是 go1

但 go 真的需要泛型嘛?虽然 go 定位是系统语言,用的最多还是偏业务层,中间件以下还是 c/c++ 的舞台,哪怕 go 己经有了杀手级应用 docker/k8s

吸引大公司选择 go 的原因,就是简单,快速上手,goroutine 用户态高并发。如果 GA 后,会不会导致代码库里泛型使用泛滥呢?可以预见,go1.18 出来后,大家要刷新对 go 的认识了,同时对于新手学习区线也不再简单

支持泛型也会让 go 很好的处理数据,要是再搞个分代 GC, 是不是可以造大数据的轮子了^^

小结

引用曹大[13]的一句话:敏捷大师们其实非常双标,他们给出的方法论也不一定靠谱,反正成功了就是大师方法得当,失败了就是我们执行不力没有学到精髓。正着说反着说都有道理。

再看看现在的 Go 社区,buzzwords 也很多,如果一个特性大师不想做,那就是 less is more. 如果一个特性大师想做,那就是 orthogonal, 非常客观

写文章不容易,如果对大家有所帮助和启发,请大家帮忙点击在看点赞分享 三连

关于 泛型 大家有什么看法,欢迎留言一起讨论,大牛多留言 ^_^

参考资料

[1]

泛型程序设计: https://zh.wikipedia.org/wiki/%E6%B3%9B%E5%9E%8B%E7%BC%96%E7%A8%8B,

[2]

go2 泛型最终提案: https://go.googlesource.com/proposal/+/refs/heads/master/design/43651-type-parameters.md,

[3]

redis disct: https://github.com/redis/redis/blob/unstable/src/dict.h#L61,

[4]

rust where: https://rustwiki.org/zh-CN/rust-by-example/generics/where.html,

[5]

Java 不能实现真正泛型的原因是什么?: https://www.zhihu.com/question/28665443/answer/118148143,

[6]

genny: https://github.com/cheekybits/genny,

[7]

betterGO: https://github.com/PioneerIncubator/betterGo,

[8]

generic programming facilities: https://github.com/golang/go/issues/15292,

[9]

Why Generics: https://blog.golang.org/why-generics#TOC_1.,

[10]

generics-next-step: https://blog.golang.org/generics-next-step,

[11]

泛型 官方 proposal: https://go.googlesource.com/proposal/+/refs/heads/master/design/43651-type-parameters.md,

[12]

omissions: https://go.googlesource.com/proposal/+/refs/heads/master/design/43651-type-parameters.md#omissions,

[13]

why-do-we-need-generics: https://xargin.com/why-do-we-need-generics/,

以上是关于你真的了解泛型 Generic 嘛?的主要内容,如果未能解决你的问题,请参考以下文章

Java 泛型了解嘛?

浏览器的工作原理你真的全知道嘛?史上最全图解其原理

浏览器的工作原理你真的全知道嘛?史上最全图解其原理

你真的了解JAVA中的泛型E、T、K、V吗?

详解 Java 泛型(Generic)机制

详解 Java 泛型(Generic)机制