Rust非异步块表达式错误传播：Try式写法的便捷替代方案

我有一个执行具体操作的函数，当出现任何错误时需要执行额外操作。理想的实现是像Try块那样把所有逻辑包裹在块表达式里，最后统一检查结果。但问题是这个块表达式不需要异步，可移除async关键字后，用?传播的错误会直接跳出整个块（导致无法后续检查result并执行额外操作）。请问有什么便捷的替代方案？

原代码示例：

async fn main() -> Result<i32, Error> {
    let result: Result<i32, Error> = async {
        do_smth()?;
        do_smth()?;
        do_smth()?;

        Ok(1)
    }
    .await;

    if result.is_err() {
        additional_action();
    };

    result
}

方法1：立即执行闭包包裹同步逻辑 #

用立即执行的闭包替代异步块，让?仅跳出闭包内部，外部可以正常捕获结果并处理错误：

async fn main() -> Result<i32, Error> {
    let result: Result<i32, Error> = (|| {
        do_smth()?;
        do_smth()?;
        do_smth()?;
        Ok(1)
    })();

    if result.is_err() {
        additional_action();
    }

    result
}

这种写法和原异步块的结构高度一致，不需要调整太多逻辑，就能实现同步代码的错误统一捕获。

方法2：在错误分支直接执行额外操作 #

如果想把错误处理和结果返回合并，可以用match直接在错误分支触发额外操作，省去单独的if判断：

async fn main() -> Result<i32, Error> {
    let result = match (|| {
        do_smth()?;
        do_smth()?;
        do_smth()?;
        Ok(1)
    })() {
        Ok(val) => Ok(val),
        Err(e) => {
            additional_action();
            Err(e)
        }
    };

    result
}

方法3：封装通用错误处理函数 #

如果这种“执行逻辑+错误时触发额外操作”的模式在代码中多次出现，可以封装一个辅助函数复用逻辑：

fn with_error_handler<T, E>(f: impl FnOnce() -> Result<T, E>, handler: impl FnOnce()) -> Result<T, E> {
    match f() {
        Ok(t) => Ok(t),
        Err(e) => {
            handler();
            Err(e)
        }
    }
}

async fn main() -> Result<i32, Error> {
    let result = with_error_handler(
        || {
            do_smth()?;
            do_smth()?;
            do_smth()?;
            Ok(1)
        },
        additional_action,
    );

    result
}

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