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

Estou tentando dividir a Stringretenção de cada correspondência de padrão, mas com a parte correspondente retida como o início da próxima substring, em vez do terminador da última.

Implementação atual:

let s = String::from("AaaBbCc");
for block in s.split_inclusive(|c: char| c.is_uppercase()) {
    println!("{block}")
}

Saída atual

A
aaB
bC
c

Saída desejada

Aaa
Bb
Cc

Como isso pode ser alcançado?

Eu encontrei vários casos semelhantes a este:

if let Some(x) = formula_chars.peek() {
    if x.is_lowercase() {
        todo!()
    }
}

onde eu gostaria que uma expressão fosse avaliada como falsa se Optionfor Nonealguma operação na Somevariante (neste caso is_lowercase()) retorna falso. No entanto, a única maneira que encontrei de fazer isso é usando ifinstruções aninhadas conforme mostrado acima. Existe alguma maneira de fazer isso com uma única expressão? de preferência algo parecido com o código abaixo:

nota: o código abaixo não funciona, é apenas para ilustrar o comportamento desejado

if formula_chars.peek().unwrap_or(false).is_lowercase() {
    todo!()
}

PS, neste caso específico, eu sei que poderia unwrap_orusar apenas um caractere não minúsculo, por exemplo

if formula_chars.peek().unwrap_or('_').is_lowercase() {
    todo!()
}

mas estou procurando uma solução mais geral (e de preferência menos complicada)

Estou tentando escrever uma função para encontrar o valor de uma mão de cartas. Como parte disso, preciso verificar se a mão é flush. Meu código para fazer isso é:

use itertools::Itertools;     // allows use of .all_equal()

fn find_hand_value(player_hand: Hand) {
    let is_flush: &bool = &player_hand.cards.map(|card| card.suit).iter().all_equal();
    // ... further checks
    println!("{:?}", player_hand)    // print takes ownership to represent further use of the hand
    // return hand value
}

No entanto, se você tentar executar este código, encontrará um erro mostrando que player_hand.cardsfoi parcialmente movido devido à chamada do método para map. Considerando que o mapa é solicitado a um empréstimo imutável de, player_handsnão entendo como isso é possível, pois parece estar em contradição direta com as regras de empréstimo da ferrugem.

Alguém poderia explicar o que está acontecendo aqui e como/por que isso é possível? Obrigado,

Para contexto:

#[derive(Debug)]
struct Hand {
    cards: [Card; 5],
}

#[derive(Debug)]
struct Card {
    suit: Suit,
    value: Value,
}

#[derive(Debug, PartialEq, Eq)]
enum Suit {
    Hearts,
    Diamonds,
    Spades,
    Clubs,
}

#[derive(Debug, Ord, PartialOrd, Eq, PartialEq)]
enum Value {
    Two,
    Three,
    Four,
    Five,
    Six,
    Seven,
    Eight,
    Nine,
    Ten,
    Jack,
    Queen,
    King,
    Ace,
}

Estou procurando obter um número conhecido de insumos em ferrugem. Neste caso, estou considerando mãos de pôquer para o problema 54 do projeto Euler, onde cada linha é analisada em duas mãos de cinco cartas cada. Encontrei duas abordagens principais para esta situação, das quais não gosto.

Abordagem 1:

let mut buffer_1 = Vec::with_capacity(5);
for i in 0..5 {
    buffer_1.push(i)
}
assert_eq!(buffer_1.len(), 5);

Abordagem 2:

let mut buffer_2 = [None, 5];
for i in 0..5 {
    buffer_2[i as usize] = Some(i)
}

A abordagem 1 está na pilha, apesar de ter um tamanho conhecido em tempo de compilação, e a abordagem 2 me fornece valores opcionais onde eu sei que tudo é um arquivo Some. O que eu gostaria idealmente é algo capaz de coletar alguma função ou colsure em um array ou similar. por exemplo

fn array_from_colsure<T>(length: usize, closure: fn() -> T) -> Option<[T; length]> {
    // implementation
}
#[test]
fn array_from_closure_test() {
    let a: [i32; 5] = array_from_colsure(5, || {for i in 0..5 {i}}).unwrap()
}

Esclarecimento: estou procurando algo com essa funcionalidade e não criá-lo do zero.

Como mostra a excelente resposta de Silvio Mayolo (editei um pouco a funcionalidade desejada desde a pergunta original), implementar minha sugestão exigirá uma quantidade enorme de unsafecódigo (sem mencionar um enorme esforço para uma otimização tão pequena). Portanto, não é sensato fazê-lo para um pequeno número de projetos.