一文看懂 Go 泛型核心設計

大家好，我是煎魚。

Go1.18 的泛型是鬧得沸沸揚揚，雖然之前寫過很多篇針對泛型的一些設計和思考。但因爲泛型的提案之前一直還沒定型，所以就沒有寫完整介紹。

如今已經基本成型，就由煎魚帶大家一起摸透 Go 泛型。本文內容主要涉及泛型的 3 大核心概念，非常值得大家深入瞭解。

如下：

• 類型參數。

• 類型約束。

• 類型推導。

類型參數

類型參數，這個名詞。不熟悉的小夥伴咋一看就懵逼了。

泛型代碼是使用抽象的數據類型編寫的，我們將其稱之爲類型參數。當程序運行通用代碼時，類型參數就會被類型參數所取代。也就是類型參數是泛型的抽象數據類型。

簡單的泛型例子：

func Print(s []T) {
 for _, v := range s {
  fmt.Println(v)
 }
}

代碼有一個 Print 函數，它打印出一個片斷的每個元素，其中片斷的元素類型，這裏稱爲 T，是未知的。

這裏引出了一個要做泛型語法設計的點，那就是：T 的泛型類型參數，應該如何定義？

在現有的設計中，分爲兩個部分：

• 類型參數列表：類型參數列表將會出現在常規參數的前面。爲了區分類型參數列表和常規參數列表，類型參數列表使用方括號而不是小括號。

• 類型參數約束：如同常規參數有類型一樣，類型參數也有元類型，被稱爲約束（後面會進一步介紹）。

結合完整的例子如下：

// Print 可以打印任何片斷的元素。
// Print 有一個類型參數 T，並有一個單一的（非類型）的 s，它是該類型參數的一個片斷。
func Print[T any](s []T) {
 // do something...
}

在上述代碼中，我們聲明瞭一個函數 Print，其有一個類型參數 T，類型約束爲 any，表示爲任意的類型，作用與 interface{} 一樣。他的入參變量 s 是類型 T 的切片。

函數聲明完了，在函數調用時，我們需要指定類型參數的類型。如下：

 Print[int]([]int{1, 2, 3})

在上述代碼中，我們指定了傳入的類型參數爲 int，並傳入了 []int{1, 2, 3} 作爲參數。

其他類型，例如 float64:

 Print[float64]([]float64{0.1, 0.2, 0.3})

也是類似的聲明方式，照着套就好了。

類型約束

說完類型參數，我們再說說 “約束”。在所有的類型參數中都要指定類型約束，才能叫做完整的泛型。

以下分爲兩個部分來具體展開講解：

• 定義函數約束。

• 定義運算符越蘇

爲什麼要有類型約束

爲了確保調用方能夠滿足接受方的程序訴求，保證程序中所應用的函數、運算符等特性能夠正常運行。

泛型的類型參數，類型約束，相輔相成。

定義函數約束

問題點

我們看看 Go 官方所提供的例子：

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

該方法的實現目的是：任何類型的切片都能轉換成對應的字符串切片。但程序邏輯裏有一個問題，那就是他的入參 T 是 any 類型，是任意類型都可以傳入。

其內部又調用了 String 方法，自然也就會報錯，因爲只像是 int、float64 等類型，就可能沒有實現該方法。

你說要定義有效的類型約束，那像是上面的例子，在泛型中如何實現呢？

要求傳入方要有內置方法，就得定義一個 interface 來約束他。

單個類型

例子如下：

type Stringer interface {
 String() string
}

在泛型方法中應用：

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

再將 Stringer 類型放到原有的 any 類型處，就可以實現程序所需的訴求了。

多個類型

如果是多個類型約束。例子如下：

type Stringer interface {
 String() string
}

type Plusser interface {
 Plus(string) string
}

func ConcatTo[S Stringer, P Plusser](s []S, p []P) []string {
 r := make([]string, len(s))
 for i, v := range s {
  r[i] = p[i].Plus(v.String())
 }
 return r
}

與常規的入參、出參類型聲明一樣的規則。

定義運算符約束

完成了函數約束的定義後，剩下一個要啃的大骨頭就是 “運算符” 的約束了。

問題點

我們看看 Go 官方的例子：

func Smallest[T any](s []T) T {
 r := s[0] // panic if slice is empty
 for _, v := range s[1:] {
  if v < r { // INVALID
   r = v
  }
 }
 return r
}

經過上面的函數例子，我們很快能意識到這個程序根本無法運行成功。

其入參是 any 類型，程序內部是按 slice 類型來獲取值，且在內部又進行運算符比較，那如果真是 slice，內部就可能每個值類型都不一樣。

如果一個是 slice，一個是 int 類型，又如何進行運算符的值對比？

近似元素

可能有的同學想到了重載運算符，但... 想太多了，Go 語言沒有支持的計劃。爲此做了一個新的設計，那就是允許限制類型參數的類型範圍。

語法如下：

InterfaceType  = "interface" "{" {(MethodSpec | InterfaceTypeName | ConstraintElem) ";" } "}" .
ConstraintElem = ConstraintTerm { "|" ConstraintTerm } .
ConstraintTerm = ["~"] Type .

例子如下：

type AnyInt interface{ ~int }

上述聲明的類型集是 ~int，也就是所有類型爲 int 的類型（如：int、int8、int16、int32、int64）都能夠滿足這個類型約束的條件。

包括底層類型是 int8 類型的，例如：

type AnyInt8 int8

也就是在該匹配範圍內的。

聯合元素

如果希望進一步縮小限定類型，可以結合分隔符來使用，用法爲：

type AnyInt interface{
 ~int8 | ~int64
}

就可以將類型集限定在 int8 和 int64 之中。

實現運算符約束

基於新的語法，結合新的概念聯合和近似元素，可以把程序改造一下，實現在泛型中的運算符的匹配。

類型約束的聲明，如下：

type Ordered interface {
 ~int | ~int8 | ~int16 | ~int32 | ~int64 |
  ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
  ~float32 | ~float64 |
  ~string
}

應用的程序如下：

func Smallest[T Ordered](s []T) T {
 r := s[0] // panics if slice is empty
 for _, v := range s[1:] {
  if v < r {
   r = v
  }
 }
 return r
}

確保了值均爲基礎數據類型後，程序就可以正常運行了。

類型推導

程序員寫代碼，一定程度的偷懶是必然的。

在一定的場景下，可以通過類型推導來避免明確地寫出一些或所有的類型參數，編譯器會進行自動識別。

建議複雜函數和參數能明確是最好的，否則讀代碼的同學會比較麻煩，可讀性和可維護性的保證也是工作中重要的一點。

參數推導

函數例子。如下：

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

公共代碼片段。如下：

var s []int
f := func(i int) int64 { return int64(i) }
var r []int64

明確指定兩個類型參數。如下：

r = Map[int, int64](s, f)

只指定第一個類型參數，變量 f 被推斷出來。如下：

r = Map[int](s, f)

不指定任何類型參數，讓兩者都被推斷出來。如下：

r = Map(s, f)

約束推導

神奇的在於，類型推導不僅限與此，連約束都可以推導。

函數例子，如下：

func Double[E constraints.Number](s []E) []E {
 r := make([]E, len(s))
 for i, v := range s {
  r[i] = v + v
 }
 return r
}

基於此的推導案例，如下：

type MySlice []int

var V1 = Double(MySlice{1})

MySlice 是一個 int 的切片類型別名。變量 V1 的類型編譯器推導後 []int 類型，並不是 MySlice。

原因在於編譯器在比較兩者的類型時，會將 MySlice 類型識別爲 []int，也就是 int 類型。

要實現 “正確” 的推導，需要如下定義：

type SC[E any] interface {
 []E 
}

func DoubleDefined[S SC[E], E constraints.Number](s S) S {
 r := make(S, len(s))
 for i, v := range s {
  r[i] = v + v
 }
 return r
}

基於此的推導案例。如下：

var V2 = DoubleDefined[MySlice, int](MySlice{1})

只要定義顯式類型參數，就可以獲得正確的類型，變量 V2 的類型會是 MySlice。

那如果不聲明約束呢？如下：

var V3 = DoubleDefined(MySlice{1})

編譯器通過函數參數進行推導，也可以明確變量 V3 類型是 MySlice。

總結

今天我們在文章中給大家介紹了泛型的三個重要概念，分別是：

• 類型參數：泛型的抽象數據類型。

• 類型約束：確保調用方能夠滿足接受方的程序訴求。

• 類型推導：避免明確地寫出一些或所有的類型參數。

在內容中也涉及到了聯合元素、近似元素、函數約束、運算符約束等新概念。本質上都是基於三個大概念延伸出來的新解決方法，一環扣一環。

你學會 Go 泛型了嗎，設計的如何，歡迎一起討論：）

參考

• Type Parameters Proposal

• Summary of Go Generics Discussions

• Go 語言泛型設計

關注煎魚，獲取業內第一手消息和知識 👇

本文由 Readfog 進行 AMP 轉碼，版權歸原作者所有。
來源：https://mp.weixin.qq.com/s/TgczuxfygeHfWvlIsJfAOA