编辑“︁Go 函数式错误处理”︁

= Go函数式错误处理 =

'''Go函数式错误处理'''是Go语言中结合函数式编程范式处理错误的一种方法。尽管Go语言本身以显式错误检查为主（如`if err != nil`模式），但通过高阶函数、闭包和自定义类型等技术，可以实现更函数式的错误处理流程。这种方法强调组合、不可变性和声明式风格，适合需要复杂错误处理逻辑或希望减少重复代码的场景。

== 核心概念 ==

=== 错误作为值 ===
在函数式编程中，错误被视为普通值而非异常，这与Go的`error`接口设计天然契合。关键思想是将错误处理逻辑封装为可组合的函数。

=== 高阶函数 ===
高阶函数（接受或返回函数的函数）允许将错误处理策略抽象为可复用的组件。

=== 函子（Functor）与单子（Monad） ===
虽然Go没有内置这些范畴论概念，但可以通过自定义类型模拟类似行为（如`Maybe`或`Either`模式）。

== 基本模式 ==

=== 错误包装器 ===
通过闭包创建错误处理上下文：

<syntaxhighlight lang="go">
func WithLogging(fn func() error) func() error {
    return func() error {
        err := fn()
        if err != nil {
            log.Printf("Error occurred: %v", err)
        }
        return err
    }
}

// 使用示例
operation := WithLogging(func() error {
    return fmt.Errorf("simulated error")
})
operation() // 输出: Error occurred: simulated error
</syntaxhighlight>

=== 结果类型封装 ===
定义包含值和错误的复合类型：

<syntaxhighlight lang="go">
type Result[T any] struct {
    Value T
    Err   error
}

func MapResult[T, U any](r Result[T], fn func(T) U) Result[U] {
    if r.Err != nil {
        return Result[U]{Err: r.Err}
    }
    return Result[U]{Value: fn(r.Value)}
}

// 使用示例
r := Result[int]{Value: 42}
result := MapResult(r, func(x int) string {
    return fmt.Sprintf("value is %d", x)
})
fmt.Println(result.Value) // 输出: value is 42
</syntaxhighlight>

== 高级组合模式 ==

=== 错误处理管道 ===
通过函数组合实现链式错误处理：

<mermaid>
graph LR
    A[输入] --> B(步骤1)
    B --> C{错误?}
    C -->|否| D(步骤2)
    C -->|是| E[提前返回]
    D --> F{错误?}
    F -->|否| G(步骤3)
    F -->|是| E
</mermaid>

对应实现：
<syntaxhighlight lang="go">
func Pipeline(input interface{}, ops ...func(interface{}) (interface{}, error)) (interface{}, error) {
    var err error
    res := input
    for _, op := range ops {
        res, err = op(res)
        if err != nil {
            return nil, err
        }
    }
    return res, nil
}

// 使用示例
result, err := Pipeline(
    10,
    func(x interface{}) (interface{}, error) { return x.(int) * 2, nil },
    func(x interface{}) (interface{}, error) { return x.(int) + 1, nil },
)
fmt.Println(result) // 输出: 21
</syntaxhighlight>

=== 错误恢复策略 ===
实现类似"重试"的函数式模式：

<syntaxhighlight lang="go">
func WithRetry(maxAttempts int, fn func() error) error {
    var err error
    for i := 0; i < maxAttempts; i++ {
        if err = fn(); err == nil {
            return nil
        }
        time.Sleep(time.Second * time.Duration(i+1))
    }
    return fmt.Errorf("after %d attempts: %v", maxAttempts, err)
}
</syntaxhighlight>

== 数学基础 ==
函数式错误处理的理论基础可以表示为：

<math>
\text{Result} = \text{Value} \oplus \text{Error}
</math>

其中<math>\oplus</math>表示不相交联合类型（即Go中的`Result`结构体）。

== 实际案例 ==

=== 配置文件加载 ===
组合多个可能失败的操作：

<syntaxhighlight lang="go">
func LoadConfig(path string) (Config, error) {
    readFile := func() ([]byte, error) {
        return os.ReadFile(path)
    }
    
    parseConfig := func(data []byte) (Config, error) {
        var cfg Config
        err := json.Unmarshal(data, &cfg)
        return cfg, err
    }
    
    data, err := readFile()
    if err != nil {
        return Config{}, fmt.Errorf("read error: %w", err)
    }
    
    cfg, err := parseConfig(data)
    if err != nil {
        return Config{}, fmt.Errorf("parse error: %w", err)
    }
    
    return cfg, nil
}
</syntaxhighlight>

使用函数式重构后：
<syntaxhighlight lang="go">
func LoadConfigFunctional(path string) (Config, error) {
    andThen := func(prev Result[[]byte]) Result[Config] {
        if prev.Err != nil {
            return Result[Config]{Err: prev.Err}
        }
        return parseConfig(prev.Value)
    }
    
    return andThen(readFile(path)).Unwrap()
}
</syntaxhighlight>

== 权衡与限制 ==
* '''优点''':
  * 减少重复错误检查代码
  * 提高错误处理逻辑的可复用性
  * 声明式风格使控制流更清晰
* '''缺点''':
  * 可能增加类型系统的复杂性
  * 与Go习惯用法存在差异
  * 调试堆栈信息可能不够直观

== 最佳实践 ==
1. 在复杂业务逻辑中应用函数式错误处理
2. 保持底层IO操作使用传统错误检查
3. 为自定义结果类型实现清晰的`Unwrap`方法
4. 使用`%w`包装错误保留上下文

[[Category:Go编程]]
[[Category:函数式编程]]
[[Category:错误处理]]

[[Category:编程语言]]
[[Category:Go]]
[[Category:Go 函数式编程]]