Rust中批量处理Result：全成功生成结构体，否则返回所有错误

问题背景 #

需要将包含大量Option/Result的输入结构体转换为所有字段值确定的结构体，同时收集所有输入错误到Vec中一次性返回，而非遇到第一个错误就终止流程。现有实现因编译器无法保证Ok分支中字段已完成初始化而编译失败，且字段数量较多时写法会极其繁琐。

给定结构体与错误枚举定义：

struct Test {
    x: i32,
    y: String,
}

#[derive(Debug)]
enum Errors {
    OneIsNone,
    TwoIsNone,
}

原实现编译失败，核心原因是编译器无法确认进入Ok分支时x和y已被初始化：

fn main() -> Result<Test, Vec<Errors>> {
    let option1 = Some(5);
    let option2 = None;

    let mut errors = Vec::new();

    let x: i32;
    match option1 {
        Some(value) => x = value,
        None => errors.push(Errors::OneIsNone),
    };

    let y: String;
    match option2 {
        Some(value) => y = value,
        None => errors.push(Errors::TwoIsNone),
    }

    if errors.len() != 0 {
        return Err(errors)
    }

    Ok(Test { x, y })
}

希望实现类似Test::unwrap_or_errors的方法：传入多个Result，若全部为Ok则生成目标结构体，否则返回包含所有错误的Vec。

解决方案 #

1. 手动收集错误的正确写法 #

通过将字段临时包装为Option或先转为Result，在确认无错误后再安全取值，让编译器明确字段初始化状态：

fn main() -> Result<Test, Vec<Errors>> {
    let option1 = Some(5);
    let option2 = None;

    let mut errors = Vec::new();

    // 先转换为Result，同时收集错误
    let x = option1.ok_or_else(|| {
        errors.push(Errors::OneIsNone);
        Errors::OneIsNone
    });
    let y = option2.ok_or_else(|| {
        errors.push(Errors::TwoIsNone);
        Errors::TwoIsNone
    });

    // 存在错误则直接返回
    if !errors.is_empty() {
        return Err(errors);
    }

    // 此时可安全unwrap，编译器能识别x/y必然是Ok状态
    Ok(Test {
        x: x.unwrap(),
        y: y.unwrap(),
    })
}

2. 实现unwrap_or_errors关联函数 #

将错误收集逻辑封装到Test结构体的关联函数中，简化主流程代码：

impl Test {
    fn unwrap_or_errors(x: Result<i32, Errors>, y: Result<String, Errors>) -> Result<Self, Vec<Errors>> {
        let mut errors = Vec::new();

        // 先处理所有Result，收集错误，用默认值占位（后续不会用到）
        let x_val = match x {
            Ok(val) => val,
            Err(e) => {
                errors.push(e);
                0
            }
        };

        let y_val = match y {
            Ok(val) => val,
            Err(e) => {
                errors.push(e);
                String::new()
            }
        };

        if !errors.is_empty() {
            Err(errors)
        } else {
            Ok(Self { x: x_val, y: y_val })
        }
    }
}

fn main() -> Result<Test, Vec<Errors>> {
    let option1 = Some(5);
    let option2 = None;

    let x = option1.ok_or(Errors::OneIsNone);
    let y = option2.ok_or(Errors::TwoIsNone);

    Test::unwrap_or_errors(x, y)
}

3. 自定义宏简化多字段场景 #

如果结构体字段数量较多，手动处理每个字段会非常繁琐，可自定义宏批量处理：

#[macro_export]
macro_rules! collect_errors {
    ($($res:expr => $err:expr),* $(,)?) => {{
        let mut errors = Vec::new();
        let mut values = Vec::new();

        $(
            match $res {
                Ok(val) => values.push(val),
                Err(_) => errors.push($err),
            }
        )*

        if !errors.is_empty() {
            Err(errors)
        } else {
            Ok(values)
        }
    }};
}

impl Test {
    fn from_results(x: Result<i32, Errors>, y: Result<String, Errors>) -> Result<Self, Vec<Errors>> {
        let values = collect_errors!(
            x => Errors::OneIsNone,
            y => Errors::TwoIsNone
        )?;

        Ok(Self {
            x: values[0].clone(),
            y: values[1].clone(),
        })
    }
}

fn main() -> Result<Test, Vec<Errors>> {
    let option1 = Some(5);
    let option2 = None;

    let x = option1.ok_or(Errors::OneIsNone);
    let y = option2.ok_or(Errors::TwoIsNone);

    Test::from_results(x, y)
}

宏会自动遍历所有传入的Result，批量收集错误与有效值，最后返回处理结果。

4. 基于迭代器折叠收集错误 #

利用Rust迭代器的fold方法，批量处理所有Result并收集错误：

fn main() -> Result<Test, Vec<Errors>> {
    let option1 = Some(5);
    let option2 = None;

    // 将所有Option转为Result，放入数组
    let results = [
        option1.ok_or(Errors::OneIsNone),
        option2.ok_or(Errors::TwoIsNone),
    ];

    // 折叠迭代器，分离错误与有效值
    let (errors, mut values) = results.into_iter().fold(
        (Vec::new(), Vec::new()),
        |(mut errs, mut vals), res| {
            match res {
                Ok(val) => vals.push(val),
                Err(e) => errs.push(e),
            }
            (errs, vals)
        },
    );

    if !errors.is_empty() {
        Err(errors)
    } else {
        Ok(Test {
            x: values.remove(0),
            y: values.remove(0),
        })
    }
}

这种方式无需额外依赖，适合字段数量较多的场景，代码简洁易维护。

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