iterator - 有没有一种方法可以删除基于结果进行过滤和分区的迭代器链中项目的展开？

Question

我创建了这个示例代码:

fn main() {
    let books = vec![
        Book {
            data: Ok("type1".to_owned()),
            metadata: "meta1".to_owned(),
        },
        Book {
            data: Err("-".to_owned()),
            metadata: "meta2".to_owned(),
        },
        Book {
            data: Ok("type2".to_owned()),
            metadata: "meta2".to_owned(),
        },
    ];

    // metadata without data being error
    let (book_type_1, book_type_2): &(Vec<_>, Vec<_>) = &books
        .iter()
        .filter(|f| f.data.is_ok())
        .partition(|p| p.data.as_ref().unwrap() == "type1");

    println!("Books {:?}", books);
    println!("Type 1 {:?}", book_type_1); // Should be the original Vec<Book> with Type 1 filtered.
    println!("Type 2 {:?}", book_type_2); // Should be the original Vec<Book> with Type 2 filtered.
}

#[derive(Debug)]
struct Book {
    data: Result<String, String>,
    metadata: String,
}

在 let (book_type_1, book_type_2) 表达式上，我需要使用 Book::data 两次，但我已经过滤了它，所以我知道它不能错误。有没有一种方法可以进行重组以删除此处 unwrap 的使用？

Answer 1

我会按照描述使用 flat_map in the other answer ，但我会将生成的值保留为 Result。 结果 implements IntoIterator ，因此您可以直接在 flat_map 中使用它。

我还会使用Result::as_ref而不是明确地写出匹配。

然后我会使用Itertools::partition_map同时在类型之间进行选择并删除额外的属性:

extern crate itertools;
use itertools::{Either, Itertools};

// ...

let (book_type_1, book_type_2): (Vec<_>, Vec<_>) = books
    .iter()
    .flat_map(|b| b.data.as_ref().map(|data| (b, data)))
    .partition_map(|(b, data)| {
        if data == "type1" {
            Either::Left(b)
        } else {
            Either::Right(b)
        }
    });

注意:

• 没有理由引用结果元组。
• 这仅在您迭代书籍引用时才有效。

如果您需要对拥有的 Book 进行操作，我会将比较移至 flat_map 调用中并将其传递:

let (book_type_1, book_type_2): (Vec<_>, Vec<_>) = books
    .into_iter()
    .flat_map(|book| {
        book.data
            .as_ref()
            .ok()
            .map(|data| data == "type1")
            .map(|is_type1| (is_type1, book))
    })
    .partition_map(|(is_type1, book)| {
        if is_type1 {
            Either::Left(book)
        } else {
            Either::Right(book)
        }
    });

还有一种实用的解决方案，将所有错误分类到与其中一种类型相同的垃圾箱中。由于您知道不会出现任何错误，因此这没有任何效果:

let (book_type_1, book_type_2): (Vec<_>, Vec<_>) = books
    .iter()
    .filter(|f| f.data.is_ok())
    .partition(|p| p.data.as_ref().ok().map_or(false, |d| d == "type1"));

另请参阅:

• What's the most idiomatic way of working with an Iterator of Results?