大家好，我是煎魚。
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 泛型了嗎，設計的如何，歡迎一起討論：）
若有任何疑問歡迎評論區反饋和交流，最好的關係是互相成就，各位的點贊就是煎魚創作的最大動力，感謝支援。
文章持續更新，可以微信搜【腦子進煎魚了】閱讀，本文 GitHub github.com/eddycjy/blog 已收錄，學習 Go 語言可以看 Go 學習地圖和路線，歡迎 Star 催更。