Go语言中链式调用与优雅的错误处理实践

package main

import "fmt"

// 模拟可能失败的函数
func f1(in int) (out int, err error) {
    // 假设 f1 有时会失败，这里为简化示例总是成功
    return in + 1, nil
}

func f2(in int) (out int, err error) {
    // 假设 f2 有时会失败
    // if in == 2 { return 0, fmt.Errorf("f2 failed for input 2") }
    return in + 2, nil
}

func f3(in int) (out int, err error) {
    // 假设 f3 有时会失败
    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 0, err // f1 失败，立即返回错误
    }

    temp2, err = f2(temp1)
    if err != nil {
        return 0, err // f2 失败，立即返回错误
    }

    // f3 成功，返回最终结果
    return f3(temp2)
}

func main() {
    inval := 0
    outval, err := calc(inval)
    if err != nil {
        fmt.Printf("计算失败: %v\n", err)
    } else {
        fmt.Printf("输入: %d, 输出: %d\n", inval, outval) // 输出: 输入: 0, 输出: 6
    }

    // 假设 f2 失败的情况
    // inval = 0
    // outval, err = calc(inval) // 如果 f2 失败，这里会捕获到错误
    // if err != nil {
    //     fmt.Printf("计算失败: %v\n", err)
    // } else {
    //     fmt.Printf("输入: %d, 输出: %d\n", inval, outval)
    // }
}

// saferun 接受一个 (int) (int, error) 签名的函数 f，
// 并返回一个包装后的函数，该函数在执行 f 之前检查传入的错误。
func saferun(f func(int) (int, error)) func(int, error) (int, error) {
    return func(in int, err error) (int, error) {
        if err != nil {
            // 如果上一步已经有错误，则直接返回上一步的错误，不再执行 f
            return 0, err 
        }
        // 否则，执行 f 并返回其结果
        return f(in)
    }
}

// 使用 saferun 改进后的 calc 函数
func calcWithSaferun(in int) (out int, err error) {
    // saferun(f3) 返回一个函数 sf3
    // saferun(f2) 返回一个函数 sf2
    // 调用顺序为 f1(in) -> sf2(f1的结果) -> sf3(sf2的结果)
    return saferun(f3)(saferun(f2)(f1(in)))
}

// 或者分解步骤，提高可读性
func calcWithSaferunVerbose(in int) (out int, err error) {
    sf2 := saferun(f2)
    sf3 := saferun(f3)

    val, err := f1(in) // f1 是链条的起点，不需要 saferun 包装
    val, err = sf2(val, err) // sf2 会检查 val, err
    val, err = sf3(val, err) // sf3 会检查 val, err

    return val, err
}

// composeInt 接受一系列 (int) (int, error) 签名的函数，
// 并返回一个将它们组合在一起的新函数。
// 新函数按顺序执行这些子函数，并在任何一个子函数返回错误时立即中断并传播错误。
func composeInt(fs ...func(int) (int, error)) func(int) (int, error) {
    return func(initialVal int) (int, error) {
        currentVal := initialVal // 初始化当前值
        var err error

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

// 使用 composeInt 改进后的 calc 函数
func calcWithCompose(in int) (out int, err error) {
    // 将 f1, f2, f3 组合成一个单一的函数
    composedFunc := composeInt(f1, f2, f3)
    // 调用组合后的函数
    return composedFunc(in)
}