當聽到 "函數(shù)式編程" 時，Go 并不是你會首先想到的語言。你可能會想到 Haskell，它有純函數(shù)和單子（先別慌），或者 JavaScript，它喜歡用高階函數(shù)和回調(diào)來炫耀。但你也可以用 Go 進行函數(shù)式編程，而且一點也不枯燥無聊。

高階函數(shù)（Higher-Order Functions）

首先，我們來談談高階函數(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]
}

你看到了嗎？我們好像在用一個更快的 JavaScript。

柯里化（Currying）

接下來是柯里化，這是將一個接收多個參數(shù)的函數(shù)分解成一系列各接收一個參數(shù)的函數(shù)。它實際上沒有想象的那么復雜。

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）

函數(shù)式編程的特點之一是不變性。一旦構(gòu)造了某樣東西，就不會再改變。相反，如果你需要不同的東西，可以構(gòu)建一個新的。這乍聽起來可能有點浪費，但實際上卻能保持整潔并減少副作用。

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ù)就像是個愛干凈的朋友，不會接觸或修改其范圍之外的任何東西。你所傳入的就是你所使用的，你所返回的就是它們唯一的效果。

package main

import "fmt"

func square(x int) int {
 return x * x
}

func main() {
 fmt.Println(square(5)) // 25
}

看，沒有副作用。在創(chuàng)建這個函數(shù)的過程中，沒有破壞任何全局變量。

算子（Functors）

用最淺顯易懂的話來說，算子就是任何可以映射函數(shù)的東西。想想不起眼的數(shù)組，對每一項應用一個函數(shù)，然后得到一個新數(shù)組。在 Go 中，沒有內(nèi)置的通用 map 函數(shù)，但我們可以自己構(gòu)建。

讓定義一個操作 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]
}

看看這個！有了這樣的編碼技巧，誰還需要內(nèi)置方法呢？

自映射算子（Endofunctors）

現(xiàn)在，我們來談談自映射算子，這只是一種花哨的說法，意思是一種將類型映射到相同類型的算子。簡單來說，從一個 Go 切片開始，最終也會得到一個同樣類型的 Go 切片。這不是什么高科技，只是類型一致性的問題。

以之前的 mapInts 為例，這是一個變相的自映射算子。它接收 []int 并返回 []int，沒有類型轉(zhuǎn)換。

單態(tài)（Monoids）

想象一下，在一個聚會上，每個人都需要帶一個朋友。單子就像這樣，不過代表的是類型。它們需要兩樣東西：一個結(jié)合兩種類型的操作和一個特殊值，后者就像最討人喜歡的朋友 -- 它與每個人都相處融洽，卻不會改變他們的任何東西。

在 Go 中，可以通過切片或數(shù)字看到這一點。我們以數(shù)字為例，因為數(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）

單子是自映射算子類別中的一個單態(tài)。

當有人拋出 "單子是子映射算子類別中的一個單態(tài)" 這樣的話語時，他們基本上是在炫耀自己的計算機科學詞匯量。詳細解釋一下：單子（monad）是一種編程結(jié)構(gòu)，以超級特殊的方式處理類型和函數(shù) -- 就像有些人對咖啡的沖泡方式很挑剔一樣。用最簡單的話來說，單態(tài)（monoid）就是用一種特殊的規(guī)則將各種東西組合在一起，其中包括一個無用元素或身份元素?，F(xiàn)在，再加上子映射算子（endofunctors），就像普通的老式函數(shù)一樣，但它們堅持在自己的小宇宙（范疇）內(nèi)變換事物。把這一切放在一起，你就會明白，單子可以被看作是將函數(shù)按序列粘連在一起的一種方式，只不過是以一種超級自足的方式，同時也尊重數(shù)據(jù)的原始結(jié)構(gòu)。這就像在說："我們要去公路旅行，但只能走風景優(yōu)美的小路，最后我們還是會回到起點"。

單子是萬事通，不僅可以處理帶有上下文的值（如錯誤或列表），還可以通過傳遞上下文的方式將操作鏈在一起。在 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
 }
}

這個臨時單子可以幫助我們處理可能出錯的計算，而不會在代碼中造成恐慌和混亂。

結(jié)論

Go 中的函數(shù)式編程可能不是函數(shù)式范例的典型代表，但卻是完全可行的，甚至可以很有趣。誰知道呢，對吧？現(xiàn)在，你應該明白，Go 可以像其他語言一樣實現(xiàn)函數(shù)式編程，只要稍加努力，就能寫出簡潔、高效、健壯的代碼。

參考資料

[1] Basics of Functional Programming in Go: https://araujo88.medium.com/basics-of-functional-programming-in-go-290b5d79fc3e