主页 / coding / 问题 / 79263513
Accepted
Pioneer_11
Asked: 2024-12-09 07:11:50 +0800 CST

Rust，如果大量结果都正常则执行某些操作，或者返回所有错误的向量

  • 772

我正在尝试解析一些用户输入，输入存储在一个结构中，其中有很多选项/结果（以处理用户输入之前未初始化的数据），并且当用户提交时，它需要进入一个已知所有值的结构中。

我希望能够生成一个包含所有错误的向量，这样我就可以向用户反馈输入的所有错误（而不仅仅是第一个错误）。但是，我找不到一个好的方法来实现这一点。

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

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

我目前的方法是：

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
        }
    )
}

这是行不通的，因为如果代码到达Ok块，编译器就无法判断 x 和 y 是否必须初始化。

在这种情况下，我可以解开匹配两个结果，但对于具有大量字段的结构来说，这种方法会变得非常笨重。

基本上我想要一种方法来接收大量的结果并将它们解析成一个结构，如果它们都给出Ok()或返回一个包含所有错误的向量，否则，即我如何unwrap_or_errors实现

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

    let mut errors = Vec::new();
    

    let x = match option1 {
        Some(val) => Ok(val),
        None => Err(Errors::OneIsNone),
    };

    let y =  match option2 {
        Some(val) => Ok(val),
        None => Err(Errors::TwoIsNone),
    };

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

    Test::unwrap_or_errors(x, y)?
}
rust

1 个回答

  1. Best Answer

    您可以使用元组模式匹配来表示成功情况，并使用迭代器展平来表示失败情况：

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

impl Test {
    fn unwrap_or_errors<E>(
        x: Result<i32, E>,
        y: Result<String, E>,
    ) -> Result<Self, Vec<E>> {
        match (x, y) {
            (Ok(x), Ok(y)) => Ok(Self { x, y }),
            (x, y) => Err([x.err(), y.err()]
                .into_iter()
                .flatten()
                .collect()),
        }
    }
}

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

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

    let x = match option1 {
        Some(val) => Ok(val),
        None => Err(Errors::OneIsNone),
    };

    let y = match option2 {
        Some(val) => Ok(val),
        None => Err(Errors::TwoIsNone),
    };

    Test::unwrap_or_errors(x, y)
}

    这仍然有点多余，但你可以切换到宏来解决这个问题：

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

macro_rules! unwrap_or_errors {
    ($($id: ident),*) => {
        match ($($id),*) {
            ($(Ok($id)),*) => Ok(Test { $($id),* }),
            ($($id),*) => Err([$($id.err()),*]
                .into_iter()
                .flatten()
                .collect()),
        }
    }
}

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

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

    let x = match option1 {
        Some(val) => Ok(val),
        None => Err(Errors::OneIsNone),
    };

    let y = match option2 {
        Some(val) => Ok(val),
        None => Err(Errors::TwoIsNone),
    };

    unwrap_or_errors!(x, y)
}
    • 1

相关问题