Rust 当迭代器中的项多于预期时返回错误_Rust

Rust 当迭代器中的项多于预期时返回错误

rust

Rust 当迭代器中的项多于预期时返回错误,rust,Rust,选项将部分映射到正常和无映射到错误，例如：如果我想验证迭代器在已经获取了必要的项（预期数量）之后是否返回None，我应该使用什么？我正在寻找返回Ok如果None，在其他情况下返回自定义错误的内容： let _ = iterator.next().the_method_i_search(|elem| MyError::MyCase(elem))?; 我知道我能做到： if let Some(elem) = iterator.next() { return Err(MyError::My

选项

将

部分

映射到

正常

和

无

映射到

错误

，例如：

如果我想验证迭代器在已经获取了必要的项（预期数量）之后是否返回

None

，我应该使用什么？我正在寻找返回

Ok

如果

None

，在其他情况下返回自定义错误的内容：

let _ = iterator.next().the_method_i_search(|elem| MyError::MyCase(elem))?;

我知道我能做到：

if let Some(elem) = iterator.next() {
    return Err(MyError::MyCase(elem));
}

但是我喜欢Rust中的

？

操作符和方法链接的简洁性。

我假设最初的问题是从迭代器中获取N个元素，然后在迭代器之后还有更多元素时出错。我首先解决了这个问题，创建了一个新的迭代器适配器

takequickly

，它生成一个

Result

s的迭代器。在第一次

检索之后，迭代器将开始将项目作为错误返回

use std::iter::Iterator;

struct TakeExactly<I> {
    it: I,
    n: usize,    
}

impl<I> Iterator for TakeExactly<I>
where 
    I: Iterator
{
    type Item = Result<I::Item, I::Item>;

    fn next(&mut self) -> Option<Self::Item> {
        match (self.it.next(), self.n) {
            (None, _) => None,
            (Some(x), 0) => Some(Err(x)),
            (Some(x), _) => {
                self.n -= 1;
                Some(Ok(x))
            },
        }
    }
}

使用std:：iter:：Iterator；
结构{
它:我,，
n:使用，
}
take函数的impl迭代器
哪里
I：迭代器
{
类型项=结果；
fn下一步（&mut self）->选项{
匹配（self.it.next（），self.n）{
（无，）=>无，
（一些（x），0）=>一些（错误（x）），
（部分（x），）=>{
n-=1；
一些（Ok（x））
},
}
}
}

让我们也做一个实用函数：

fn take_exactly<I: IntoIterator>(it: I, n: usize) -> TakeExactly<I::IntoIter> {
    TakeExactly {
        it: it.into_iter(),
        n,
    }
}

准确地取（it:I，n:usize）->准确地取{ 完全正确{ it:it.into_iter（）， N } } 完成此操作后，我们可以轻松收集预期数量的物品，如下所示：

let x: Result<Vec<_>, _> = take_exactly(vec![5, 4, 3], 2).collect();
assert_eq!(x, Err(3));

let x: Result<String, _> = take_exactly("Rustacean".chars(), 9).collect();
assert_eq!(x, Ok("Rustacean".to_string()));

让x:Result=take_精确（vec！[5,4,3]，2）.collect（）；
断言！（x，Err（3））；
设x:Result=take_（Rustacean.chars（），9.collect（）；
断言！（x，Ok（“Rustacean.to_string（））；

这是可能的，因为

Result

通过委托所有

Ok

值的集合来实现迭代器的

FromIterator

，如果找到一个值，就会产生第一个错误

我将假设最初的问题是从迭代器中获取N个元素，然后在迭代器之后仍有更多元素时引发错误。我首先解决了这个问题，创建了一个新的迭代器适配器

takequickly