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 第 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

Weekly Issue 第 9 期:Ghost 發布 6.0 版本

Ghost Release 新版了!距離上次大版號更新,已經過了 3 年多,這幾年來,創作者經濟變化得很快,Ghost 也嘗試讓創作者更容易經營自己的內容。 我會等 6.0 發布一陣子,穩定下來後才會更新。很期待他們下一步會是什麼。 🗞️ 熱門新聞 Ghost 6.0 Ghost Release 6.0。 兩個重量級更新:支援 ActivityPub,讓 Ghost 可以 Leverage 社群媒體分發渠道;以及內建 Analytics,支援流量分析。這剛好就是兩個我最想要的功能,Great Work。 常說經營內容的痛點在,不知道如何發佈內容,不知道訪客從哪來。當然這都可以用工具協助,例如設定 GA、或者使用 Postiz 等來經營社群,可是我覺得一個好的平台應該要替創作者處理掉這些事,Ghost

By Ken Chen

Weekly Issue 第 8 期:數位時代的遷徙自由

以前在開發內容平台產品時,常常想,如果有天我們的使用者要離開平台,他們擁有自由嗎?在現代,數位創作者有點像是佃農,替平台生產內容,可是因為數位落差,他們沒有移動的能力。 隨著時代進步,法規應該要與時俱進,這期選了數位部的公告草案,告訴我們科技與制度可以如何相輔相成。 另外,從本期開始,加入了目錄大綱,希望讓讀者閱讀時能更容易在不同議題間切換。 🗞️ 熱門新聞 社交資料可攜權與互通性 在唐鳳那看到這則消息,最近衛城出版編輯的帳號被無預警停權,引發討論,我自己也常常焦慮,當使用這些便利的平台服務時,我們是不是交出一些沒意識到的權利? 身為個人,可行的策略是,在發布內容到平台前,先保留一份在自己手中,但這其中的不平等顯而易見。《數位選擇法案》讓我理解到,創作者有機會在一個更好更平等的環境下創作。 我希望台灣也能有這樣的一天。 I gave the AI arms and legs – then it rejected me 在 HN 上看到的新聞,有名開發者發現自己的函式庫被用在 Claude

By Ken Chen