如何通过无错误处理的函数正确传播Result类型错误？

我需要使用一个无法修改的函数F : (A -> B) -> C，但想传入一个返回Result<B, Err>类型的函数g : A -> Result<B, Err>作为参数。目标是实现一个函数G : (A -> Result<B, Err>) -> Result<C, Err>，用来传播调用g时产生的任何错误。

用异常思路能实现，但这种方式不支持代数错误，实用性很低：

fn transform_to_err(F : (A -> B) -> C, g : A -> Result<B, Err>) -> Result<C, Err> {
    
    fn g_panic (a : A) -> B {
        match g(a) {
            Ok(b) => b,
            Err(_) => panic("g_panic error")
        }
    }

    try {
        Ok(F(g_panic)) 
    } catch exception {
        Err(exception)
    }
}

有没有办法在正确处理Result的前提下实现类似功能？

举个具体例子：

• sum10是无法修改的外部函数（对应F）
• sqrt_err是返回Result的函数（对应g）

use std::f64::consts::E;

/// 假设该函数是外部函数，无法修改
fn sum10(fun: impl Fn(f64) -> f64) -> f64 {
    let mut sum = 0.;
    for i in 0..10 {
        sum += E.powf(fun(i as f64));
    }
    sum
}

/// 我们想将该函数与sum10配合使用，但它返回Result类型
fn sqrt_err(x: f64) -> Result<f64, String> {
    if x < 0.0 {
        Err("Negative value".to_string())
    } else {
        Ok(x.sqrt())
    }
}

我想要的效果是把sqrt_err传入sum10，如果sqrt_err某次调用返回Error变体，就直接返回该错误，等价于实现下面这个函数的逻辑：

fn sum10_error(fun: impl Fn(f64) -> Result<f64, String>) -> Result<f64, String> {
    let mut sum = 0.;
    for i in 0..10 {
        sum += E.powf(fun(i as f64)?);
    }
    Ok(sum)
}

核心问题在于F的设计本身不支持错误传播——它只接受返回B的函数，没有预留错误处理接口。因此无法完全在纯Result范畴内完成转换，必须借助一些“逃逸”手段，但可以用更优雅的方式替代原始的panic/catch思路：

方法1：线程局部存储（TLS）传递错误 #

利用线程局部变量存储错误状态，包装g时捕获错误并写入TLS，同时返回一个默认值让F继续执行（或提前终止），最后检查TLS状态判断是否有错误发生。

use std::cell::RefCell;
use std::f64::consts::E;

thread_local! {
    static LAST_ERROR: RefCell<Option<String>> = RefCell::new(None);
}

/// 包装返回Result的函数，转为返回B的函数，错误时写入TLS并返回默认值
fn wrap_g<F, A, B, E: ToString>(g: F) -> impl Fn(A) -> B
where
    F: Fn(A) -> Result<B, E>,
    B: Default,
{
    move |a| {
        match g(a) {
            Ok(b) => b,
            Err(e) => {
                LAST_ERROR.with(|cell| {
                    *cell.borrow_mut() = Some(e.to_string());
                });
                B::default()
            }
        }
    }
}

/// 实现G函数：包装F并处理错误
fn transform_to_err<A, B, C, E: ToString>(f: impl Fn(impl Fn(A) -> B) -> C, g: impl Fn(A) -> Result<B, E>) -> Result<C, String>
where
    B: Default,
{
    // 重置TLS错误状态
    LAST_ERROR.with(|cell| {
        *cell.borrow_mut() = None;
    });

    let wrapped_g = wrap_g(g);
    let result = f(wrapped_g);

    // 检查是否有错误发生
    LAST_ERROR.with(|cell| {
        match cell.borrow_mut().take() {
            None => Ok(result),
            Some(err) => Err(err),
        }
    })
}

// 测试示例
fn main() {
    let result = transform_to_err(sum10, sqrt_err);
    println!("{:?}", result); // i从0到9均非负，返回Ok(sum值)

    // 测试错误场景
    let err_fn = |x: f64| {
        if x > 5.0 {
            Err("Value too big".to_string())
        } else {
            Ok(x.sqrt())
        }
    };
    let result_err = transform_to_err(sum10, err_fn);
    println!("{:?}", result_err); // i=6时触发错误，返回Err("Value too big")
}

// 原有的sum10和sqrt_err函数
fn sum10(fun: impl Fn(f64) -> f64) -> f64 {
    let mut sum = 0.;
    for i in 0..10 {
        sum += E.powf(fun(i as f64));
    }
    sum
}

fn sqrt_err(x: f64) -> Result<f64, String> {
    if x < 0.0 {
        Err("Negative value".to_string())
    } else {
        Ok(x.sqrt())
    }
}

方法2：用std::panic::catch_unwind优雅捕获panic #

如果必须用panic方式，Rust提供了catch_unwind来捕获可 unwind 的panic，可以改进原始的异常思路：

use std::panic;
use std::f64::consts::E;

fn transform_to_err<A, B, C, E>(f: impl Fn(impl Fn(A) -> B) -> C + panic::UnwindSafe, g: impl Fn(A) -> Result<B, E> + panic::UnwindSafe) -> Result<C, E>
where
    E: Clone,
{
    let mut err = None;

    let wrapped_g = |a: A| {
        match g(a) {
            Ok(b) => b,
            Err(e) => {
                err = Some(e.clone());
                panic!("propagate error");
            }
        }
    };

    let result = panic::catch_unwind(|| f(wrapped_g));

    match result {
        Ok(c) => {
            if let Some(e) = err {
                Err(e)
            } else {
                Ok(c)
            }
        }
        Err(_) => err.map(Err).expect("panic occurred without capturing error"),
    }
}

// 测试示例
fn main() {
    let result = transform_to_err(sum10, sqrt_err);
    println!("{:?}", result);

    let err_fn = |x: f64| -> Result<f64, String> {
        if x > 5.0 {
            Err("Value too big".to_string())
        } else {
            Ok(x.sqrt())
        }
    };
    let result_err = transform_to_err(sum10, err_fn);
    println!("{:?}", result_err);
}

// 原函数
fn sum10(fun: impl Fn(f64) -> f64) -> f64 {
    let mut sum = 0.;
    for i in 0..10 {
        sum += E.powf(fun(i as f64));
    }
    sum
}

fn sqrt_err(x: f64) -> Result<f64, String> {
    if x < 0.0 {
        Err("Negative value".to_string())
    } else {
        Ok(x.sqrt())
    }
}

局限性说明 #

• 方法1依赖TLS，仅适用于单线程场景，如果F内部使用多线程则无法正常工作；另外需要B实现Default，如果B没有默认值，可能需要额外包装，但会和F的参数类型冲突。
• 方法2依赖catch_unwind，但并非所有panic都能被捕获（比如调用std::process::abort()的panic），且要求闭包实现UnwindSafe，如果F或g包含非UnwindSafe的类型（比如&mut T），需要用std::panic::AssertUnwindSafe手动标记。

最佳实践 #

如果可能，优先要求F的提供者提供支持错误传播的版本（比如返回Result<C, E>的重载）。如果无法修改F，则根据场景选择上述两种方法：单线程且B有默认值时选方法1，否则选方法2。

内容的提问来源于stack exchange，提问作者RRR