Golang 函數(shù)式編程基礎(chǔ)
當(dāng)聽(tīng)到 "函數(shù)式編程" 時(shí)，Go 并不是你會(huì)首先想到的語(yǔ)言。你可能會(huì)想到 Haskell，它有純函數(shù)和單子（先別慌），或者 JavaScript，它喜歡用高階函數(shù)和回調(diào)來(lái)炫耀。但你也可以用 Go 進(jìn)行函數(shù)式編程，而且一點(diǎn)也不枯燥無(wú)聊。
高階函數(shù)（Higher-Order Functions）
首先，我們來(lái)談?wù)劯唠A函數(shù)。這些函數(shù)可以與其他函數(shù)很好的配合，要么將它們作為參數(shù)，要么將它們作為返回值。在 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]
}你看到了嗎？我們好像在用一個(gè)更快的 JavaScript。
柯里化（Currying）
接下來(lái)是柯里化，這是將一個(gè)接收多個(gè)參數(shù)的函數(shù)分解成一系列各接收一個(gè)參數(shù)的函數(shù)。它實(shí)際上沒(méi)有想象的那么復(fù)雜。
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
}簡(jiǎn)單、直接，無(wú)需任何修飾即可完成工作。
不變性（Immutability）
函數(shù)式編程的特點(diǎn)之一是不變性。一旦構(gòu)造了某樣?xùn)|西，就不會(huì)再改變。相反，如果你需要不同的東西，可以構(gòu)建一個(gè)新的。這乍聽(tīng)起來(lái)可能有點(diǎn)浪費(fèi)，但實(shí)際上卻能保持整潔并減少副作用。
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]
}純函數(shù)（Pure Functions）
純函數(shù)就像是個(gè)愛(ài)干凈的朋友，不會(huì)接觸或修改其范圍之外的任何東西。你所傳入的就是你所使用的，你所返回的就是它們唯一的效果。
package main
import "fmt"
func square(x int) int {
return x * x
}
func main() {
fmt.Println(square(5)) // 25
}看，沒(méi)有副作用。在創(chuàng)建這個(gè)函數(shù)的過(guò)程中，沒(méi)有破壞任何全局變量。
算子（Functors）
用最淺顯易懂的話來(lái)說(shuō)，算子就是任何可以映射函數(shù)的東西。想想不起眼的數(shù)組，對(duì)每一項(xiàng)應(yīng)用一個(gè)函數(shù)，然后得到一個(gè)新數(shù)組。在 Go 中，沒(méi)有內(nèi)置的通用 map 函數(shù)，但我們可以自己構(gòu)建。
讓定義一個(gè)操作 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]
}看看這個(gè)！有了這樣的編碼技巧，誰(shuí)還需要內(nèi)置方法呢？
自映射算子（Endofunctors）
現(xiàn)在，我們來(lái)談?wù)勛杂成渌阕樱@只是一種花哨的說(shuō)法，意思是一種將類型映射到相同類型的算子。簡(jiǎn)單來(lái)說(shuō)，從一個(gè) Go 切片開(kāi)始，最終也會(huì)得到一個(gè)同樣類型的 Go 切片。這不是什么高科技，只是類型一致性的問(wèn)題。
以之前的 mapInts 為例，這是一個(gè)變相的自映射算子。它接收 []int 并返回 []int，沒(méi)有類型轉(zhuǎn)換。
單態(tài)（Monoids）
想象一下，在一個(gè)聚會(huì)上，每個(gè)人都需要帶一個(gè)朋友。單子就像這樣，不過(guò)代表的是類型。它們需要兩樣?xùn)|西：一個(gè)結(jié)合兩種類型的操作和一個(gè)特殊值，后者就像最討人喜歡的朋友 -- 它與每個(gè)人都相處融洽，卻不會(huì)改變他們的任何東西。
在 Go 中，可以通過(guò)切片或數(shù)字看到這一點(diǎn)。我們以數(shù)字為例，因?yàn)閿?shù)字更容易上手：
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 是我們的英雄，是身份元素，它讓數(shù)字保持不變。
單子（Monads）
單子是自映射算子類別中的一個(gè)單態(tài)。
當(dāng)有人拋出 "單子是子映射算子類別中的一個(gè)單態(tài)" 這樣的話語(yǔ)時(shí)，他們基本上是在炫耀自己的計(jì)算機(jī)科學(xué)詞匯量。詳細(xì)解釋一下：?jiǎn)巫樱╩onad）是一種編程結(jié)構(gòu)，以超級(jí)特殊的方式處理類型和函數(shù) -- 就像有些人對(duì)咖啡的沖泡方式很挑剔一樣。用最簡(jiǎn)單的話來(lái)說(shuō)，單態(tài)（monoid）就是用一種特殊的規(guī)則將各種東西組合在一起，其中包括一個(gè)無(wú)用元素或身份元素。現(xiàn)在，再加上子映射算子（endofunctors），就像普通的老式函數(shù)一樣，但它們堅(jiān)持在自己的小宇宙（范疇）內(nèi)變換事物。把這一切放在一起，你就會(huì)明白，單子可以被看作是將函數(shù)按序列粘連在一起的一種方式，只不過(guò)是以一種超級(jí)自足的方式，同時(shí)也尊重?cái)?shù)據(jù)的原始結(jié)構(gòu)。這就像在說(shuō)："我們要去公路旅行，但只能走風(fēng)景優(yōu)美的小路，最后我們還是會(huì)回到起點(diǎn)"。
單子是萬(wàn)事通，不僅可以處理帶有上下文的值（如錯(cuò)誤或列表），還可以通過(guò)傳遞上下文的方式將操作鏈在一起。在 Go 中，要模仿這一點(diǎn)可能有點(diǎn)困難，但讓我們來(lái)看看錯(cuò)誤處理，這也是單子的實(shí)際用途。
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
}
}這個(gè)臨時(shí)單子可以幫助我們處理可能出錯(cuò)的計(jì)算，而不會(huì)在代碼中造成恐慌和混亂。
結(jié)論
Go 中的函數(shù)式編程可能不是函數(shù)式范例的典型代表，但卻是完全可行的，甚至可以很有趣。誰(shuí)知道呢，對(duì)吧？現(xiàn)在，你應(yīng)該明白，Go 可以像其他語(yǔ)言一樣實(shí)現(xiàn)函數(shù)式編程，只要稍加努力，就能寫(xiě)出簡(jiǎn)潔、高效、健壯的代碼。
參考資料
[1] Basics of Functional Programming in Go: https://araujo88.medium.com/basics-of-functional-programming-in-go-290b5d79fc3e
