Go 的泛型替代方案:型別斷言與代碼生成

用函數式編程(Functional Programming)的風格寫程式時,會常常重複使用一些通用函式,舉個例子,假設有個 array,開發者需要從該 array 中篩選符合條件的元素,重新組成新的 array。合理的情況是,如果有個 filter 函式,只需要設定條件,剩下的事情都能交給語言處理。

Golang 的 append 有點這味道,類似 JavaScript 的 push,能新增 slice 中的元素,但 Golang 畢竟不是徹底的函數式語言,內建函式庫中沒有 filter、map、reduce 等等 array 常用的函式。如果想要自行實現,語言的強型別系統會要求開發者在使用前告知對象型別,這等於是對不同的型別都要實現幾乎相同的函式,可想而知不切實際。

同樣是強型別語言,C++ 或 C# 在面對這問題時,是靠著泛型(Generic)來解決;在 The Next Step for Generics 這篇文章中,Golang 有公開泛型的草稿,但至少到 1.15 為止,實務上仍需要仰賴別的方式來達到接近的效果。本篇會分別用型別斷言(type assertion)跟 genny 這套 Golang 開源函式庫,來試著實現一些基本函式,看看 Golang 如何處理泛型問題。

需要 Clone 程式碼的,可以到這裡

Establish a Filter Function

專案結構如下

project
├── cmd
│   └── genny
│       └── main.go
├── pkg
│   └── genny
│       └── genny.go
├── scripts
├── go.mod
├── Makefile
└── README.md

先來看 pkg 內的 genny.go

package genny

// Filter filter slice
func Filter(source []int, callback func(int) bool) []int {
    var out []int
    for _, element := range source {
    if callback(element) {
    out = append(out, element)
    }
    }
    return out
}

我們的目標是設計 Filter 函式,該函式可用來篩選 slice。使用者傳入 slice 跟 callback function,遍歷 slice,使用 callback 看結果。如果 callback 結果是 true,代表 element 符合篩選的條件,將 element 加入新的 slice,最後將新的 slice 傳送回去。

因為 Golang 是強型別語言,在設計函式時需要宣告參數型別,在上面的設計中,型別是 int,這也代表該函式只能用於 int[]。

來看 cmd 中的使用方式

package main

import (
    "example/pkg/genny"
    "fmt"
)

func main() {
    num := []int{1, 3, 5, 7, 9, 11}
    // filter by static filter
    num = genny.Filter(num, func(element int) bool {
    if element < 6 {
        return true
    }
    return false
    })
    fmt.Println(num)
}

有個 slice,其中包含 {1,3,5,7,9,11},判斷條件是 element 小於 6,就將它放到新的 slice 中。執行結果是

ken@DESKTOP:~/git/medium-example-golang$ ./bin/genny 
[1 3 5]

這樣就能完成 slice 的篩選。

Using Type Assertion

如前面提到的,Filter 函式因為需要宣告型別,只能用於 int[]。實際情境裡,開發者可能會需要用到 string[]、float32[],或者是自己定義的 struct[]。為每個型別個別開發 Filter,會造成大量重複代碼,修改時也要一個一個改,很花功夫。

Golang 可以用型別斷言來解決這問題。在 Golang 中,所有型別的基本型別都是 interface{},類似 C 語言的 void。interface{} 可以容納任意型別,同時它有 var.(type),讓開發者可以動態判斷變數型別。

修改 pkg,新增 FilterWithInterface

// FilterWithInterface filter slice
func FilterWithInterface(source interface{}, callback func(interface{}) bool) interface{} {
    var outInt []int
    var outFloat32 []float32
    switch source.(type) {
    case []int:
        for _, element := range source.([]int) {
            if callback(element) {
                outInt = append(outInt, element)
            }
        }
        return outInt
    case []float32:
        for _, element := range source.([]float32) {
            if callback(element) {
                outFloat32 = append(outFloat32, element)
            }
        }
        return outFloat32
    }
    return nil
}

將引數型別改成 interface{}

switch source.(type) {
case []int:
//...
case []float32:
//...
}

用 source.(type) 取得 source 的型別,並用 switch case 來進行對應處理

for _, element := range source.([]int) {
    if callback(element) {
        outInt = append(outInt, element)
    }
}
return outInt

對於 []int 的例子,在使用時用型別斷言,指定該型別是 []int。可以把型別斷言想像成是強制轉型,斷言後語言會用 []int 來處理該變數。要特別注意的是,由於是動態判斷,它會跳過編譯器靜態檢查,如果出現型別錯誤,不會在編譯期報警,而是要到執行期才會告知。儘管 interface{} 有更高的自由度,但也會增加除錯的代價。

通常用型別斷言會搭配 switch 或斷言檢查,避免程式直接 panic,switch 前面看過了,而斷言檢查的語法是

if v, ok := v.(int); !ok{
    fmt.Println("hey guys! you enter a wrong type!")
}

ok 如果是 true,表示型別轉換正確;反之有錯誤。

因為 pkg 修改了,cmd 也要有對應修改,改成

num := []int{1, 3, 5, 7, 9, 11}
num2 := []float32{1.0, 3.0, 5.0, 7.0, 9.0, 11.0}
var out interface{}

// filter by int filter
out = genny.FilterWithInterface(num, func(element interface{}) bool {
    if element.(int) < 6 {
        return true
    }
    return false
})
fmt.Println(out.([]int))

// filter by float filter
out = genny.FilterWithInterface(num2, func(element interface{}) bool {
if element.(float32) < 6 {
        return true
    }
    return false
})
fmt.Println(out.([]float32))

建立 2 個 slice,1 個是 int,1 個是 float32。可以看到 FilterWithInterface 能處理這兩個不同型別的 Case。

Using genny to Implement

型別斷言的問題是會引入執行期錯誤,同時產生多餘的開銷。在 C++ 中,會用 template 來處理類似情況,例如

template <typename T>
T Filter(T arr, [=](auto element)){
}

像這類可以處理泛用型別的語法,稱為泛型。

因為要處理泛用型別,編譯時會需要做許多檢查,連帶會降低編譯速度,考量到這點,Golang 沒將泛型放進設計中。

Generics may well be added at some point. We don’t feel an urgency for them.

Generics are convenient but they come at a cost in complexity in the type system and run-time… Meanwhile, Go’s built-in maps and slices, plus the ability to use the empty interface to construct containers mean in many cases it is possible to write code that does what generics would enable, if less smoothly.

至少在設計層面,Golang 建議用 interface{} 頂著。

好的,官方沒有工具,但如果開發者還是想要泛型怎麼辦?genny 的設計思維是,開發者可以提供函式原型(proto-type),再使用 Code Generator 依照原型產生函式。相對原本方案要開發者一個一個處理類型,genny 用工具自動生成,省掉手動時間。

genny 的 GitHub 在這裡

使用前,安裝 genny 的命令行工具

go get github.com/cheekybits/genny

在 pkg 下新增 genny 的原型檔 source.go

project
├── cmd
│   └── genny
│       └── main.go
├── pkg
│   └── genny
│       ├── source.go
│       └── genny.go
├── scripts
├── go.mod
├── Makefile
└── README.md

內容是

package genny

import "github.com/cheekybits/genny/generic"

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

//FilterWithSomething filter Something type
func FilterWithSomething(source []Something, callback func(Something) bool) []Something {
    var out []Something
    for _, element := range source {
        if callback(element) {
            out = append(out, element)
        }
    }
    return out
}

引入 genny 專案

import "github.com/cheekybits/genny/generic"

宣告泛用類型

type Something generic.Type

跟類型有關的地方,都改為 Something

//FilterWithSomething filter Something type
func FilterWithSomething(source []Something, callback func(Something) bool) []Something {
    var out []Something
    for _, element := range source {
        if callback(element) {
            out = append(out, element)
        }
    }
    return out
}

genny 產生程式碼時,會自動將關鍵字換掉,改為需要的類型。

使用命令行來執行

genny -in ./pkg/genny/source.go -out ./pkg/genny/gencode.go gen "Something=int,string,float32"

-in 是輸入;-out 是輸出;gen 後面接要替換的關鍵字與類型,這邊將 Something 換成 int、string、float32。

執行後產出 gencode.go,內容是

// This file was automatically generated by genny.
// Any changes will be lost if this file is regenerated.
// see [https://github.com/cheekybits/genny](https://github.com/cheekybits/genny)

package genny

//FilterWithInt filter int type
func FilterWithInt(source []int, callback func(int) bool) []int {
    var out []int
    for _, element := range source {
        if callback(element) {
            out = append(out, element)
        }
    }
    return out
}

//FilterWithString filter string type
func FilterWithString(source []string, callback func(string) bool) []string {
    var out []string
    for _, element := range source {
        if callback(element) {
            out = append(out, element)
        }
    }
    return out
}

//FilterWithFloat32 filter float32 type
func FilterWithFloat32(source []float32, callback func(float32) bool) []float32 {
    var out []float32
    for _, element := range source {
        if callback(element) {
            out = append(out, element)
        }
    }
    return out
}

函式自動生成!得到 3 個新函式,FilterWithInt、FilterWithString、FilterWithFloat32。

回去修改 cmd,改為

out = genny.FilterWithInt(num, func(element int) bool {
    if element < 6 {
        return true
    }
    return false
})

跟 Step 1 用法相同,只是名稱變成 FilterWithInt。

Add go generate

用 Code Gen 的問題是需要執行命令行,在協作專案中,開發者可能不知道同伴用哪些指令來產生程式碼,這些資訊應該要能納入版本管理,讓 Code Gen 有跡可循。這時可以用 go generate。

go generate 是 Golang 內建的工具,它可以用來調用命令行指令,可以看成是 Golang 底下的 shell,用於協調 Golang 跟其他程式的互動。當執行 go generate 時,Golang 會去看專案底下的 .go 檔有沒有 go generate 的註解,如果有就依照註解來執行。

具體來說,修改 pkg 的 source.go,加入

package genny

// ...

//go:generate genny -in ./source.go -out ./gencode.go gen "Something=int,string,float32"

// ...
type Something generic.Type

在 shell 輸入

go generate ./...

Golang 讀到 go:generate 開頭的註解,就會執行後面的命令,如果像我一樣,習慣用 Make 來編譯的話,可以將 Makefile 改成

all: ${OUT_DIR} ${FILES_OUT:=.exe}

${OUT_DIR}/%:
    go generate ./... 
    go build -o $(@) ./cmd/$(basename ${[@F](http://twitter.com/F)})

在 go build 前執行 go generate,就能串起編譯流程。

小結

比較幾個方案,我自己是傾向用型別斷言。開發者調用函式時,不用思考需要用 FilterWithString 還是 FilterWithFloat32,看起來更直覺,也更接近 C++ 的泛型。相對的,缺點是不知道傳入的型別,容易引發執行期錯誤;genny 則是嘗試用 Golang 的基本語法,解決掉泛型的問題。

嚴格說來,兩種解法都不能取代真正的泛型。在注重生產力的現代語言環境中,沒有泛型真的是件頗奇怪的事。我猜 Golang 看重編譯速度,應該還是跟 Monorepo 的管理方式有關?

Reference

Read more

Weekly Issue 第 13 期:Google 無須出售 Chrome

Chrome 的判決出來了,Google 不用分拆,只需要保障競爭者能跟它公平競爭。 這個判決有指標意義,所有人都知道 Google 長期利用 Chrome 數據改善它的搜尋引擎,讓其他廠商處於競爭劣勢。要解決這問題,最簡單方式是要求 Google 出售 Chrome,而法官在仔細評估後,給出相當審慎的判決。 我喜歡這種法律見解,具有實務與原則的平衡,法律條文不應該是照本宣科。 🗞️ 熱門新聞 Google Can Continue Paying for Firefox Search Deal, Judge Rules 以前很少注意 Chrome 的新聞,剛好最近判決出來了,看了一些。 最驚訝的是,Mozilla 有 85% 的年度收入是由 Google 給的,如果判決禁止 Google 出錢成為瀏覽器預設的搜尋引擎,將直接影響到 Mozilla

By Ken Chen

Weekly Issue 第 12 期:Bear 修改授權條款

通常開源專案需要面對長期維護的問題,而長期維護需要人力(開發者)物力(伺服器與基礎建設),個人開發者來說是個負擔。有些專案會有企業贊助,有些專案則是替用戶提供顧問與服務來收費維持。 這期選了 Bear 修改授權的新聞,也因為這則新聞,順道看了 Sentry 的授權模式。我們都希望擁有健康的開發生態,而授權條款很大程度左右了這點。 🗞️ 熱門新聞 Bear changes license to Elastic License Blog 平台工具 Bear 修改授權,原本是 MIT,現在改用 Elastic License。 看開發者的說法,原因是有人搭便車,fork 完直接部署成服務賣錢。開源不是免費勞工,這樣確實有點過分。Elastic License 的差別是不准以託管方式提供服務,算是補上這個洞。 相對 AGPL 來講,有時這種個人開發的小型專案,也不追求產業影響力,直接用 EL

By Ken Chen

Weekly Issue 第 11 期:AI 代理人插件可能存在資安風險

Preplexity 跟 Anthropic 等公司開始讓瀏覽器 AI 代理化,資安領域專家 Simon Willison 指出這可能會導致眾多資安漏洞出現。我建議兩邊的意見都可以看看,Anthropic 為了防堵問題,也下過不少功夫,看完後你會比較知道該如何使用 AI 代理。 另外這期特別喜歡 Mike Sun 談台灣的產品經理遇到的挑戰,我現在不太建議新人直接在台灣當產品經理,舞台太小,成長空間有限,會影響日後發展。如果真的對產品很有興趣,可以先到其他地方建立起正確的產品觀後,再回到台灣發展。 🗞️ 熱門新聞 Piloting Claude for Chrome Anthropic 最近推出 Chrome 用的 Claude 插件,但是依照說明文件:「當我們在自主模式中加入安全防護機制後,成功將 23.6%的攻擊成功率降低至 11.2%。」 儘管 Anthropic 特地專文說明它們的防護措施,

By Ken Chen

Weekly Issue 第 10 期:AI 機器人正造成網站負擔

隨著 LLM 變成日常的一部分,它們也在改變原有的網路生態。Fastly 的報告顯示,AI 機器人每分鐘可對網站發起高達 39K 次請求,日後造訪網站的,可能大多是機器人,而不是真人。 🗞️ 熱門新聞 Fastly warns AI bots can hit sites 39K times per minute 繼上次 Codeberg 的新聞後,Fastly 出報告指出 AI 機器人正造成網站營運負擔。 大多觀點延續幾個月來的趨勢:「網站負載增長主要並非來自人類訪客,而是代表聊天機器人公司運作的自動爬蟲與抓取程式。 」值得注意的是,AI Fetcher 的數量也在增加中,我猜這多少暗示了用戶搜尋資料的行為正在變化。 Meta 占了所有 AI 流量的 52% 🙄 ,相對下 Anthropic 只佔 3.76%

By Ken Chen