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

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

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

我正在尝试拆分String保留每个模式匹配，但将匹配的部分保留为下一个子字符串的开头而不是最后一个子字符串的终止符。

当前实施：

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

电流输出

A
aaB
bC
c

期望输出

Aaa
Bb
Cc

如何实现这一点？

我已经遇到过几起类似的情况：

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

我希望表达式的计算结果为 false，如果某个OptionisNone或对Some变体的某些操作（在本例中is_lowercase()）返回 false。但是，我发现这样做的唯一方法是使用if如上所示的嵌套语句。有没有办法用单个表达式做到这一点？最好是类似以下代码的内容：

注意：下面的代码不起作用，它只是为了说明所需的行为

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

PS 在这种特定情况下我知道我可以unwrap_or使用非小写字符例如

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

但我正在寻找一个更通用（最好是更少麻烦的）解决方案

我正在尝试编写一个函数来查找一手牌的价值。作为其中的一部分，我需要检查这手牌是否是同花。我这样做的代码是：

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
}

但是，如果您尝试运行此代码，您将遇到一个错误，显示player_hand.cards由于方法调用而已部分移动map。考虑到地图是在不可变的借用上调用的，player_hands我不明白这是怎么可能的，因为它似乎与 Rust 的借用规则直接矛盾。

有人可以解释一下这里发生了什么以及如何/为什么可能吗？谢谢，

对于上下文：

#[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,
}

我希望在 Rust 中获取已知数量的输入。在本例中，我正在考虑欧拉项目第 54 题的扑克手牌，其中每行解析为两手牌，每手牌五张。对于这种情况，我发现有两种主要方法，但我都不喜欢。

方法一：

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

方法二：

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

尽管在编译时大小已知，但方法 1 位于堆上，而方法 2 为我提供了一个可选值，其中我知道所有内容都是Some. 我理想的情况是能够将某些函数或集合收集到数组或类似的数组中。例如

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

澄清： 我希望找到具有此功能的东西，而不是从头开始创建它。

正如 Silvio Mayolo 的出色回答所示（自最初的问题以来，我对所需的功能进行了轻微的编辑），实现我的建议将需要大量的代码unsafe（更不用说为如此小的优化付出巨大的努力）。所以对于少数项目来说这样做是不明智的。