fp-go: Golang函数式编程工具集使用指南

fp-go 是一个为Go语言设计的函数式编程工具库，它提供了一系列高阶函数和实用工具，帮助开发者以更函数式的方式编写Go代码。

安装

go get github.com/repeale/fp-go

核心功能

1. 集合操作

fp-go 提供了类似JavaScript中Array.map/filter/reduce的功能：

import (
    "github.com/repeale/fp-go"
    "fmt"
)

func main() {
    numbers := []int{1, 2, 3, 4, 5}
    
    // Map: 对每个元素应用函数
    doubled := fp.Map(func(x int) int { return x * 2 })(numbers)
    fmt.Println(doubled) // [2 4 6 8 10]
    
    // Filter: 过滤元素
    evens := fp.Filter(func(x int) bool { return x%2 == 0 })(numbers)
    fmt.Println(evens) // [2 4]
    
    // Reduce: 聚合操作
    sum := fp.Reduce(func(acc, x int) int { return acc + x }, 0)(numbers)
    fmt.Println(sum) // 15
}

2. 函数组合

fp-go 支持函数组合，可以创建更复杂的函数：

import (
    "github.com/repeale/fp-go"
    "strings"
)

func main() {
    toUpper := func(s string) string { return strings.ToUpper(s) }
    addExclamation := func(s string) string { return s + "!" }
    
    // 组合函数
    shout := fp.Compose(addExclamation, toUpper)
    
    result := shout("hello")
    fmt.Println(result) // "HELLO!"
}

3. 柯里化(Currying)

fp-go 支持柯里化，可以将多参数函数转换为一系列单参数函数：

import "github.com/repeale/fp-go"

func main() {
    add := func(a, b int) int { return a + b }
    
    // 柯里化
    curriedAdd := fp.Curry2(add)
    
    addFive := curriedAdd(5)
    result := addFive(3)
    fmt.Println(result) // 8
}

4. 实用工具函数

fp-go 提供了一些实用工具函数：

import (
    "github.com/repeale/fp-go"
    "fmt"
)

func main() {
    // 恒等函数
    id := fp.Identity(42)
    fmt.Println(id) // 42
    
    // 常量函数
    alwaysFive := fp.Const(5)
    fmt.Println(alwaysFive()) // 5
    
    // 管道操作
    result := fp.Pipe(
        10,
        func(x int) int { return x * 2 },
        func(x int) int { return x + 3 },
    )
    fmt.Println(result) // 23
}

实际应用示例

数据处理管道

import (
    "github.com/repeale/fp-go"
    "fmt"
    "strings"
)

func main() {
    data := []string{"apple", "banana", "cherry", "date"}
    
    process := fp.Pipe(
        fp.Map(strings.ToUpper),
        fp.Filter(func(s string) bool { return len(s) > 5 }),
        fp.Map(func(s string) string { return "FRUIT: " + s }),
    )
    
    result := process(data)
    fmt.Println(result) // [FRUIT: BANANA FRUIT: CHERRY]
}

异步操作组合

import (
    "github.com/repeale/fp-go"
    "context"
    "fmt"
    "time"
)

func fetchUser(id int) func() string {
    return func() string {
        time.Sleep(100 * time.Millisecond)
        return fmt.Sprintf("User-%d", id)
    }
}

func fetchProfile(user string) func() string {
    return func() string {
        time.Sleep(100 * time.Millisecond)
        return fmt.Sprintf("Profile of %s", user)
    }
}

func main() {
    // 组合异步操作
    getUserProfile := fp.Compose(
        fetchProfile,
        fetchUser,
    )
    
    profile := getUserProfile(1)()
    fmt.Println(profile) // "Profile of User-1"
}

注意事项

1. fp-go 的函数式风格与Go语言的惯用风格有所不同，使用时需权衡可读性
2. 由于Go缺乏泛型(在1.18之前)，fp-go 的类型安全性有限
3. 性能方面，函数式操作可能比直接循环稍慢

fp-go 为Go开发者提供了函数式编程的便利，但建议根据项目需求适度使用，避免过度抽象影响代码可读性。