Go语言中链式函数调用与错误处理的优化策略

package main

import "fmt"

// f1, f2, f3 示例函数，它们都可能返回错误
func f1(in int) (out int, err error) {
    // 假设在某些条件下会返回错误，这里简化为总是成功
    // if in < 0 {
    //     return 0, fmt.Errorf("f1 error: input cannot be negative")
    // }
    return in + 1, nil
}

func f2(in int) (out int, err error) {
    // if in > 10 {
    //     return 0, fmt.Errorf("f2 error: input too large")
    // }
    return in + 2, nil
}

func f3(in int) (out int, err error) {
    // if in % 2 != 0 {
    //     return 0, fmt.Errorf("f3 error: input must be even")
    // }
    return in + 3, nil
}

// calc 函数展示了传统的链式调用错误处理
func calc(in int) (out int, err error) {
    var temp1, temp2 int

    temp1, err = f1(in)
    if err != nil {
        // 错误发生时立即返回，并传播错误
        return temp1, err // 或者返回0，具体取决于业务逻辑
    }

    temp2, err = f2(temp1)
    if err != nil {
        return temp2, err
    }

    // 最后一个函数可以直接返回结果
    return f3(temp2)
}

func main() {
     inval := 0
     outval, err := calc(inval) // 注意：这里使用了calc，而非原文的calc3
     if err != nil {
         fmt.Printf("计算失败: %v\n", err)
     } else {
         fmt.Printf("输入: %d, 输出: %d, 错误: %v\n", inval, outval, err)
     }

     // 示例：模拟f1出错
     // _, err = f1(-1) // 假设f1在-1时出错
     // if err != nil {
     //     fmt.Printf("f1 模拟错误: %v\n", err)
     // }
}

// saferun 包装一个函数，使其在接收到错误时跳过执行
func saferun(f func(int) (int, error)) func(int, error) (int, error) {
    return func(in int, err error) (int, error) {
        if err != nil {
            return in, err // 如果上一步已出错，则直接传递错误
        }
        return f(in) // 否则执行当前函数
    }
}

// 使用 saferun 改进的 calc 函数
func calcImproved(in int) (out int, err error) {
    sf2 := saferun(f2)
    sf3 := saferun(f3)
    // 链式调用：sf3 接收 sf2 的结果，sf2 接收 f1 的结果
    return sf3(sf2(f1(in)))
}

// compose 函数：将一系列具有相同签名的函数组合成一个新函数
// 新函数会按顺序执行这些函数，并在遇到第一个错误时立即返回。
func compose(fs ...func(int) (int, error)) func(int) (int, error) {
    return func(initialVal int) (int, error) {
        currentVal := initialVal // 初始值作为第一个函数的输入
        var err error            // 错误变量，默认为nil

        for _, f := range fs {
            // 执行当前函数，将上一个函数的输出作为当前函数的输入
            currentVal, err = f(currentVal)
            if err != nil {
                // 如果当前函数返回错误，则立即停止组合并返回错误
                return currentVal, err // 返回错误发生时的值和错误
            }
        }
        // 所有函数都成功执行，返回最终结果
        return currentVal, nil
    }
}

// 使用 compose 进一步优化的 calc 函数
func calcComposed(in int) (out int, err error) {
    // 将 f1, f2, f3 按顺序组合
    composedFunc := compose(f1, f2, f3)
    // 调用组合后的函数
    return composedFunc(in)
}