面试题：Rust中Result枚举在链式操作中的应用及错误处理优化

Question

假设有一系列操作，每个操作都可能返回`Result`类型。例如，第一个操作是从文件读取数据（返回`Result<String, std::io::Error>`），第二个操作是解析读取到的字符串为特定结构体（返回`Result<MyStruct, ParseError>`），第三个操作是对结构体进行一些计算并返回结果（返回`Result<i32, CalculationError>`）。请使用`Result`的链式调用方法，将这三个操作串联起来，并以一种优雅的方式处理可能出现的各种错误，同时说明为什么这种链式调用方式在错误处理上比传统的层层嵌套`match`语句更有优势。

Answer 1

use std::fs::File;
use std::io::{self, Read};
use std::fmt;

// 假设的结构体
#[derive(Debug)]
struct MyStruct {
    // 结构体字段
    data: i32,
}

// 假设的解析错误类型
#[derive(Debug)]
struct ParseError;

impl fmt::Display for ParseError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "解析错误")
    }
}

// 假设的计算错误类型
#[derive(Debug)]
struct CalculationError;

impl fmt::Display for CalculationError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "计算错误")
    }
}

fn read_file() -> Result<String, io::Error> {
    let mut file = File::open("test.txt")?;
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;
    Ok(contents)
}

fn parse_string(s: String) -> Result<MyStruct, ParseError> {
    // 简单示例，假设字符串格式为数字
    match s.trim().parse::<i32>() {
        Ok(num) => Ok(MyStruct { data: num }),
        Err(_) => Err(ParseError),
    }
}

fn calculate(s: MyStruct) -> Result<i32, CalculationError> {
    // 简单计算示例
    if s.data > 0 {
        Ok(s.data * 2)
    } else {
        Err(CalculationError)
    }
}

fn main() {
    let result = read_file()
      .and_then(parse_string)
      .and_then(calculate);

    match result {
        Ok(num) => println!("结果: {}", num),
        Err(e) => eprintln!("错误: {:?}", e),
    }
}

链式调用比传统层层嵌套match语句的优势：

1. 代码简洁：链式调用使用and_then等方法，将多个操作串联起来，代码更加紧凑，减少了不必要的嵌套层次，提高了代码的可读性。例如在上述代码中，通过链式调用可以清晰地看到数据从文件读取，到解析，再到计算的流程，而传统match嵌套会使代码变得冗长。
2. 错误处理集中：链式调用一旦某个操作返回错误，后续操作将不再执行，直接返回错误，错误处理逻辑集中在最后的match语句中。相比之下，传统match嵌套需要在每个操作后都进行错误处理，使得错误处理代码分散，难以维护。
3. 易于扩展：如果需要在操作链中添加新的操作，链式调用只需要在链中添加新的and_then调用即可，不会影响其他部分的代码结构。而传统match嵌套则需要在适当的层次添加新的嵌套，可能需要调整整个错误处理结构。