Golang 函數式編程基礎
當聽到 "函數式編程" 時，Go 并不是你會首先想到的語言。你可能會想到 Haskell，它有純函數和單子（先別慌），或者 JavaScript，它喜歡用高階函數和回調來炫耀。但你也可以用 Go 進行函數式編程，而且一點也不枯燥無聊。
高階函數（Higher-Order Functions）
首先，我們來談談高階函數。這些函數可以與其他函數很好的配合，要么將它們作為參數，要么將它們作為返回值。在 Go 的世界里，這不僅是可能的，而且是非常巧妙的。
package main
import (
"fmt"
)
func filter(numbers []int, f func(int) bool) []int {
var result []int
for _, value := range numbers {
if f(value) {
result = append(result, value)
}
}
return result
}
func isEven(n int) bool {
return n%2 == 0
}
func main() {
numbers := []int{1, 2, 3, 4}
even := filter(numbers, isEven)
fmt.Println(even) // [2, 4]
}你看到了嗎？我們好像在用一個更快的 JavaScript。
柯里化（Currying）
接下來是柯里化，這是將一個接收多個參數的函數分解成一系列各接收一個參數的函數。它實際上沒有想象的那么復雜。
package main
import"fmt"
func add(a int) func(int) int {
returnfunc(b int) int {
return a + b
}
}
func main() {
addFive := add(5)
fmt.Println(addFive(3)) // 8
}簡單、直接，無需任何修飾即可完成工作。
不變性（Immutability）
函數式編程的特點之一是不變性。一旦構造了某樣東西，就不會再改變。相反，如果你需要不同的東西，可以構建一個新的。這乍聽起來可能有點浪費，但實際上卻能保持整潔并減少副作用。
package main
import "fmt"
func main() {
obj := map[string]int{"a": 1, "b": 2}
newObj := make(map[string]int)
for k, v := range obj {
newObj[k] = v
}
newObj["b"] = 3
fmt.Println(newObj) // map[a:1 b:3]
}純函數（Pure Functions）
純函數就像是個愛干凈的朋友，不會接觸或修改其范圍之外的任何東西。你所傳入的就是你所使用的，你所返回的就是它們唯一的效果。
package main
import "fmt"
func square(x int) int {
return x * x
}
func main() {
fmt.Println(square(5)) // 25
}看，沒有副作用。在創建這個函數的過程中，沒有破壞任何全局變量。
算子（Functors）
用最淺顯易懂的話來說，算子就是任何可以映射函數的東西。想想不起眼的數組，對每一項應用一個函數，然后得到一個新數組。在 Go 中，沒有內置的通用 map 函數，但我們可以自己構建。
讓定義一個操作 int 切片的算子：
package main
import"fmt"
// Functor on a slice of int
func mapInts(values []int, f func(int) int) []int {
result := make([]int, len(values))
for i, v := range values {
result[i] = f(v)
}
return result
}
func main() {
numbers := []int{1, 2, 3, 4}
squared := mapInts(numbers, func(x int) int { return x * x })
fmt.Println(squared) // [1, 4, 9, 16]
}看看這個！有了這樣的編碼技巧，誰還需要內置方法呢？
自映射算子（Endofunctors）
現在，我們來談談自映射算子，這只是一種花哨的說法，意思是一種將類型映射到相同類型的算子。簡單來說，從一個 Go 切片開始，最終也會得到一個同樣類型的 Go 切片。這不是什么高科技，只是類型一致性的問題。
以之前的 mapInts 為例，這是一個變相的自映射算子。它接收 []int 并返回 []int，沒有類型轉換。
單態（Monoids）
想象一下，在一個聚會上，每個人都需要帶一個朋友。單子就像這樣，不過代表的是類型。它們需要兩樣東西：一個結合兩種類型的操作和一個特殊值，后者就像最討人喜歡的朋友 -- 它與每個人都相處融洽，卻不會改變他們的任何東西。
在 Go 中，可以通過切片或數字看到這一點。我們以數字為例，因為數字更容易上手：
package main
import"fmt"
// Integer addition is a monoid with zero as the identity element
func add(a, b int) int {
return a + b
}
func main() {
fmt.Println(add(5, 5)) // 10
fmt.Println(add(5, 0)) // 5
fmt.Println(add(0, 0)) // 0
}在這里，0 是我們的英雄，是身份元素，它讓數字保持不變。
單子（Monads）
單子是自映射算子類別中的一個單態。
當有人拋出 "單子是子映射算子類別中的一個單態" 這樣的話語時，他們基本上是在炫耀自己的計算機科學詞匯量。詳細解釋一下：單子（monad）是一種編程結構，以超級特殊的方式處理類型和函數 -- 就像有些人對咖啡的沖泡方式很挑剔一樣。用最簡單的話來說，單態（monoid）就是用一種特殊的規則將各種東西組合在一起，其中包括一個無用元素或身份元素。現在，再加上子映射算子（endofunctors），就像普通的老式函數一樣，但它們堅持在自己的小宇宙（范疇）內變換事物。把這一切放在一起，你就會明白，單子可以被看作是將函數按序列粘連在一起的一種方式，只不過是以一種超級自足的方式，同時也尊重數據的原始結構。這就像在說："我們要去公路旅行，但只能走風景優美的小路，最后我們還是會回到起點"。
單子是萬事通，不僅可以處理帶有上下文的值（如錯誤或列表），還可以通過傳遞上下文的方式將操作鏈在一起。在 Go 中，要模仿這一點可能有點困難，但讓我們來看看錯誤處理，這也是單子的實際用途。
package main
import (
"errors"
"fmt"
)
// Maybe represents a monad for error handling
func Maybe(value int, err error, f func(int) (int, error)) (int, error) {
if err != nil {
return0, err
}
return f(value)
}
func main() {
// Simulate a computation that might fail
process := func(v int) (int, error) {
if v < 0 {
return0, errors.New("negative value")
}
return v * v, nil
}
// Use our Maybe "monad" to handle potential errors
result, err := Maybe(5, nil, process)
if err != nil {
fmt.Println("Error:", err)
} else {
fmt.Println("Success:", result) // Success: 25
}
}這個臨時單子可以幫助我們處理可能出錯的計算，而不會在代碼中造成恐慌和混亂。
結論
Go 中的函數式編程可能不是函數式范例的典型代表，但卻是完全可行的，甚至可以很有趣。誰知道呢，對吧？現在，你應該明白，Go 可以像其他語言一樣實現函數式編程，只要稍加努力，就能寫出簡潔、高效、健壯的代碼。
參考資料
[1] Basics of Functional Programming in Go: https://araujo88.medium.com/basics-of-functional-programming-in-go-290b5d79fc3e
