使用 mo 库进行 Golang 函数式编程

mo 是一个基于泛型的 Golang 函数式编程抽象插件库，它提供了许多实用的函数式编程工具，可以帮助你编写更简洁、更表达性的代码。

安装 mo

go get github.com/samber/mo

核心概念和功能

1. Option 类型

Option 类型用于处理可能存在或不存在的值，替代 nil 检查。

package main

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

func getUserName(id int) mo.Option[string] {
	if id == 1 {
		return mo.Some("Alice")
	}
	return mo.None[string]()
}

func main() {
	name := getUserName(1)
	fmt.Println(name.OrElse("Unknown")) // 输出: Alice

	name = getUserName(2)
	fmt.Println(name.OrElse("Unknown")) // 输出: Unknown
}

2. Either 类型

Either 类型表示两种可能的值之一，通常用于错误处理。

func divide(a, b int) mo.Either[string, int] {
	if b == 0 {
		return mo.Left[string, int]("division by zero")
	}
	return mo.Right[string, int](a / b)
}

func main() {
	result := divide(10, 2)
	result.Match(
		func(err string) { fmt.Println("Error:", err) },
		func(val int) { fmt.Println("Result:", val) },
	) // 输出: Result: 5

	result = divide(10, 0)
	result.Match(
		func(err string) { fmt.Println("Error:", err) },
		func(val int) { fmt.Println("Result:", val) },
	) // 输出: Error: division by zero
}

3. Future 异步处理

mo 提供了 Future 类型来处理异步操作。

func asyncTask() mo.Future[int] {
	return mo.NewFuture(func(resolve func(int), reject func(error)) {
		// 模拟异步任务
		go func() {
			resolve(42)
		}()
	})
}

func main() {
	future := asyncTask()
	
	result := future.Collect()
	fmt.Println(result.MustGet()) // 输出: 42
}

4. 函数式组合

mo 提供了函数式组合工具。

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

func main() {
	// 函数组合
	composed := mo.Compose(addOne, double)
	fmt.Println(composed(5)) // (5+1)*2 = 12

	// 管道操作
	pipe := mo.Pipe(
		mo.NewOption(5),
		mo.Map(addOne),
		mo.Map(double),
	)
	fmt.Println(pipe.OrElse(0)) // 12
}

5. 集合操作

mo 提供了对切片和映射的函数式操作。

func main() {
	numbers := []int{1, 2, 3, 4, 5}

	// Map
	doubled := mo.MapSlice(numbers, func(x int) int { return x * 2 })
	fmt.Println(doubled) // [2 4 6 8 10]

	// Filter
	evens := mo.FilterSlice(numbers, func(x int) bool { return x%2 == 0 })
	fmt.Println(evens) // [2 4]

	// Reduce
	sum := mo.ReduceSlice(numbers, 0, func(acc, x int) int { return acc + x })
	fmt.Println(sum) // 15
}

实际应用示例

处理数据库查询

type User struct {
	ID   int
	Name string
}

func findUser(id int) mo.Option[User] {
	// 模拟数据库查询
	if id == 1 {
		return mo.Some(User{ID: 1, Name: "Alice"})
	}
	return mo.None[User]()
}

func getUserEmail(user User) mo.Option[string] {
	// 模拟获取邮箱
	if user.ID == 1 {
		return mo.Some("alice@example.com")
	}
	return mo.None[string]()
}

func main() {
	// 使用 Option 链式操作
	email := mo.FlatMap(findUser(1), getUserEmail)
	fmt.Println(email.OrElse("no email")) // alice@example.com

	email = mo.FlatMap(findUser(2), getUserEmail)
	fmt.Println(email.OrElse("no email")) // no email
}

错误处理管道

func parseInput(input string) mo.Either[error, int] {
	// 模拟解析
	if len(input) == 0 {
		return mo.Left[error, int](fmt.Errorf("empty input"))
	}
	return mo.Right[error, int](len(input))
}

func processValue(val int) mo.Either[error, string] {
	// 模拟处理
	if val > 10 {
		return mo.Left[error, string](fmt.Errorf("value too large"))
	}
	return mo.Right[error, string](fmt.Sprintf("processed-%d", val))
}

func main() {
	result := mo.FlatMapEither(parseInput("hello"), processValue)
	
	result.Match(
		func(err error) { fmt.Println("Error:", err) },
		func(val string) { fmt.Println("Result:", val) },
	) // 输出: Result: processed-5
}

mo 库通过这些抽象类型和函数式操作，使得 Golang 代码更加简洁、安全且易于维护。它特别适合需要处理大量可选值、错误或异步操作的场景。