Início / coding / Perguntas / 79263513
Accepted
Pioneer_11
Asked: 2024-12-09 07:11:50 +0800 CST

Rust, faça algo se um grande número de resultados estiverem todos ok ou retorne um vetor de todos os erros

  • 772

Estou tentando analisar algumas entradas do usuário. As entradas são armazenadas em uma estrutura onde há muitas opções/resultados (para lidar com os dados não inicializados antes que o usuário os insira) e quando o usuário os envia, eles precisam ir para uma estrutura onde todos os valores são conhecidos.

Gostaria de poder ter um vetor com quaisquer erros para que eu possa dar feedback ao usuário sobre todos os erros com a entrada (não apenas o primeiro). No entanto, não consigo encontrar uma boa maneira de fazer isso.

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

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

Minha abordagem atual é:

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

O que não funciona porque o compilador não consegue dizer que x e y devem ser inicializados se o código atingir o Okbloco.

Nesse caso, eu poderia simplesmente desembrulhar e corresponder os dois resultados, mas essa abordagem se tornaria terrivelmente desajeitada para estruturas com um grande número de campos.

Basicamente, quero uma maneira de receber um grande número de resultados e analisá-los em uma estrutura se todos eles fornecerem Ok()ou retornarem um vetor contendo todos os erros, caso contrário, como implementar unwrap_or_errorsem

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 respostas

  1. Best Answer

    Você pode usar a correspondência de padrões de tupla para o caso de sucesso e o achatamento do iterador para o caso de falha:

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

    Isso ainda é um pouco redundante, mas você pode mudar para uma macro para corrigir isso:

    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

relate perguntas