Rust中使用and_then链式调用Result时如何区分具体错误类型

你要区分不同步骤的错误不需要强制做类型检查，Rust惯用的写法是在链式调用的每一步通过map_err为错误附加上下文或者转换为自定义错误类型，无需回到嵌套match的写法。

方案1：直接为每一步错误附加提示前缀（最适配你的场景） #

你可以在链式调用的每个可能产生错误的步骤后紧跟map_err，给对应步骤的错误加上你需要的提示前缀。由于Result的短路特性，只有对应步骤出错时才会执行该步骤的map_err逻辑，完美匹配你原来嵌套match的错误提示效果：

use std::num::ParseIntError;

fn get_num(n: u8) -> Result<u8, ParseIntError> {
   // Force a ParseIntError
   "foo ".parse()
}
fn add_one(n: u8) -> Result<u8, ParseIntError> {
    Ok(n + 1)
}
fn main() {
    match get_num(1)
        .map_err(|e| format!("Error getting number: {}", e))
        .and_then(add_one)
        .map_err(|e| format!("Error adding: {}", e))
    {
        Ok(n) => println!("Adding one gives us: {}", n),
        Err(why) => println!("{}", why)
    }
}

执行逻辑完全和嵌套match一致：

• 如果get_num返回Err，会直接触发第一个map_err，拼接提示前缀后直接返回，后续的and_then和第二个map_err都不会执行
• 如果get_num执行成功，才会进入and_then调用add_one，如果add_one返回Err，才会触发第二个map_err拼接对应前缀

方案2：自定义错误枚举（适合多错误类型、需要后续逻辑判断错误类型的场景） #

如果不同步骤的错误类型不同，或者后续需要根据错误类型做不同的业务处理，可以定义专属的错误枚举，每个变体对应不同步骤的错误，再通过map_err把各步骤的错误转换为自定义枚举类型，最后统一match枚举变体处理：

use std::num::ParseIntError;
use std::fmt;

#[derive(Debug)]
enum CalcError {
    GetNumFailed(ParseIntError),
    AddOneFailed(ParseIntError),
}

impl fmt::Display for CalcError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            CalcError::GetNumFailed(e) => write!(f, "Error getting number: {}", e),
            CalcError::AddOneFailed(e) => write!(f, "Error adding: {}", e),
        }
    }
}

fn get_num(n: u8) -> Result<u8, ParseIntError> {
   "foo ".parse()
}
fn add_one(n: u8) -> Result<u8, ParseIntError> {
    Ok(n + 1)
}

fn main() {
    match get_num(1)
        .map_err(CalcError::GetNumFailed)
        .and_then(add_one)
        .map_err(CalcError::AddOneFailed)
    {
        Ok(n) => println!("Adding one gives us: {}", n),
        Err(e) => println!("{}", e)
    }
}

关于你提到的「是否需要做类型检查」：如果你的多个步骤返回的是完全不同的错误类型，理论上也可以通过downcast做类型检查来区分错误来源，但这种写法远不如上面两种符合Rust的惯用范式，可读性和可维护性都更低，不推荐使用。

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