Fuego: Go函数式编程实验插件库

Fuego 是一个为 Go 语言设计的函数式编程实验性插件库，它提供了一系列函数式编程工具，让 Go 开发者能够以更函数式的方式编写代码。下面我将介绍 Fuego 的主要功能和用法示例。

安装 Fuego

go get github.com/samber/fuego

核心功能

1. 柯里化 (Currying)

Fuego 允许你将多参数函数转换为一系列单参数函数：

package main

import (
	"fmt"
	"github.com/samber/fuego"
)

func add(a, b, c int) int {
	return a + b + c
}

func main() {
	curriedAdd := fuego.Curry3(add)
	
	// 分步应用参数
	add5 := curriedAdd(5)
	add5And10 := add5(10)
	result := add5And10(15) // 5 + 10 + 15 = 30
	
	fmt.Println(result) // 输出: 30
	
	// 也可以一次性应用所有参数
	result2 := curriedAdd(5)(10)(15)
	fmt.Println(result2) // 输出: 30
}

2. 函数组合 (Function Composition)

Fuego 提供了函数组合的能力：

package main

import (
	"fmt"
	"github.com/samber/fuego"
)

func double(x int) int { return x * 2 }
func square(x int) int { return x * x }
func addOne(x int) int { return x + 1 }

func main() {
	// 组合函数: 先平方，然后加倍，最后加1
	composed := fuego.Compose(addOne, double, square)
	
	result := composed(3) // ((3^2)*2)+1 = 19
	fmt.Println(result) // 输出: 19
	
	// 管道式操作
	piped := fuego.Pipe(
		square,
		double,
		addOne,
	)
	
	result2 := piped(4) // ((4^2)*2)+1 = 33
	fmt.Println(result2) // 输出: 33
}

3. 高阶函数

Fuego 提供了常见的高阶函数操作：

package main

import (
	"fmt"
	"github.com/samber/fuego"
)

func main() {
	numbers := []int{1, 2, 3, 4, 5}
	
	// Map
	doubled := fuego.Map(numbers, func(x int) int { return x * 2 })
	fmt.Println(doubled) // [2 4 6 8 10]
	
	// Filter
	evens := fuego.Filter(numbers, func(x int) bool { return x%2 == 0 })
	fmt.Println(evens) // [2 4]
	
	// Reduce
	sum := fuego.Reduce(numbers, 0, func(acc, x int) int { return acc + x })
	fmt.Println(sum) // 15
	
	// FlatMap
	nested := [][]int{{1, 2}, {3, 4}, {5}}
	flattened := fuego.FlatMap(nested, func(x []int) []int { return x })
	fmt.Println(flattened) // [1 2 3 4 5]
}

4. Maybe 和 Either 类型

Fuego 提供了类似 Haskell 的 Maybe 和 Either 类型来处理可能失败的操作：

package main

import (
	"fmt"
	"github.com/samber/fuego"
)

func safeDivide(a, b int) fuego.Maybe[int] {
	if b == 0 {
		return fuego.None[int]()
	}
	return fuego.Some(a / b)
}

func main() {
	result := safeDivide(10, 2)
	fmt.Println(result.IsSome(), result.Unwrap()) // true 5
	
	result2 := safeDivide(10, 0)
	fmt.Println(result2.IsSome()) // false
	
	// 使用 Either 处理错误
	eitherResult := fuego.Try(func() int {
		return 10 / 2
	})
	
	fmt.Println(eitherResult.IsRight(), eitherResult.Unwrap()) // true 5
	
	eitherError := fuego.Try(func() int {
		return 10 / 0
	})
	
	fmt.Println(eitherError.IsLeft()) // true
}

5. 延迟求值 (Lazy Evaluation)

Fuego 支持延迟求值：

package main

import (
	"fmt"
	"github.com/samber/fuego"
)

func main() {
	lazyValue := fuego.Lazy(func() int {
		fmt.Println("Computing...")
		return 42
	})
	
	fmt.Println("Before evaluation")
	result := lazyValue()
	fmt.Println("After evaluation, result:", result)
	
	// 再次调用会使用缓存的值
	result2 := lazyValue()
	fmt.Println("Second evaluation, result:", result2)
	
	// 输出:
	// Before evaluation
	// Computing...
	// After evaluation, result: 42
	// Second evaluation, result: 42
}

实际应用示例

数据处理管道

package main

import (
	"fmt"
	"github.com/samber/fuego"
)

func main() {
	data := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	
	// 创建处理管道
	pipeline := fuego.Pipe(
		// 过滤偶数
		func(nums []int) []int {
			return fuego.Filter(nums, func(x int) bool { return x%2 == 0 })
		},
		// 平方
		func(nums []int) []int {
			return fuego.Map(nums, func(x int) int { return x * x })
		},
		// 求和
		func(nums []int) int {
			return fuego.Reduce(nums, 0, func(acc, x int) int { return acc + x })
		},
	)
	
	result := pipeline(data)
	fmt.Println(result) // 2^2 + 4^2 + 6^2 + 8^2 + 10^2 = 220
}

注意事项

1. Fuego 是一个实验性库，API 可能会发生变化
2. Go 不是纯函数式语言，过度使用函数式风格可能会影响代码可读性
3. 性能敏感的场景需要测试函数式写法的性能影响

Fuego 为 Go 开发者提供了一种探索函数式编程可能性的方式，虽然 Go 本身是命令式语言，但通过 Fuego 可以在适当场景下尝试函数式风格，获得更简洁、更声明式的代码表达。