Question

我尝试将基于Option输入的行为切换到某个功能。我们的想法是根据给定的Option是否存在进行迭代。这是一个极小的，如果愚蠢的例子：

use std::iter;

fn main() {
    let x: Option<i64> = None;

    // Repeat x 5 times if present, otherwise count from 1 to 5
    for i in match x {
        None => 1..5,
        Some(x) => iter::repeat(x).take(5),
    } {
        println!("{}", i);
    }
}

我收到错误：

error[E0308]: match arms have incompatible types
  --> src/main.rs:7:14
   |
7  |       for i in match x {
   |  ______________^
8  | |         None => 1..5,
9  | |         Some(x) => iter::repeat(x).take(5),
   | |                    ----------------------- match arm with an incompatible type
10 | |     } {
   | |_____^ expected struct `std::ops::Range`, found struct `std::iter::Take`
   |
   = note: expected type `std::ops::Range<{integer}>`
              found type `std::iter::Take<std::iter::Repeat<i64>>`

这当然很有道理，但我真的很想根据条件选择我的迭代器，因为for循环中的代码是非平凡的并且复制粘贴所有这些只是为了改变迭代器选择非常难看且不可维护。

我尝试在两个臂上使用as Iterator<Item = i64>，但这给了我一个关于unsized类型的错误，因为它是一个特征对象。有一个简单的方法可以解决这个问题吗？

当然，我可以使用.collect()，因为它们返回相同的类型并迭代该向量。这是一个很好的快速修复，但对于大型列表似乎有点过分。

Answer 1

您需要的引用：

use std::iter;

fn main() {
    let mut a;
    let mut b;

    let x: Option<i64> = None;

    // Repeat x 5 times if present, otherwise count from 1 to 5
    let iter: &mut Iterator<Item = i64> = match x {
        None => {
            a = 1..5;
            &mut a
        }
        Some(x) => {
            b = iter::repeat(x).take(5);
            &mut b
        }
    };

    for i in iter {
        println!("{}", i);
    }
}

此解决方案的主要缺点是您必须为每种具体类型分配堆栈空间。这也意味着每种类型的变量。一件好事是只需要初始化已使用的类型。

同样的想法，但需要堆分配是使用盒装特征对象：

use std::iter;

fn main() {
    let x: Option<i64> = None;

    // Repeat x 5 times if present, otherwise count from 1 to 5
    let iter: Box<Iterator<Item = i64>> = match x {
        None => Box::new(1..5),
        Some(x) => Box::new(iter::repeat(x).take(5)),
    };

    for i in iter {
        println!("{}", i);
    }
}

当您想要return the iterator from a function时，这非常有用。采用的堆栈空间是单个指针，只分配所需的堆空间。

Answer 2

either crate提供Either类型。如果Either的两半都是迭代器，那么Either：

也是如此

extern crate either;

use either::Either;
use std::iter;

fn main() {
    let x: Option<i64> = None;

    // Repeat x 5 times if present, otherwise count from 1 to 5
    let iter = match x {
        None => Either::Left(1..5),
        Some(x) => Either::Right(iter::repeat(x).take(5)),
    };

    for i in iter {
        println!("{}", i);
    }
}

与a previous answer类似，这仍然会为您拥有的每种具体类型占用堆栈空间。但是，您不需要为每个具体值提供单个变量。

与特征对象引用不同，此类型也可以是returned from a function。与盒装特征对象相比，无论选择哪种具体类型，它总是在堆栈上使用固定大小。

您也可以在其他地方找到此类型（或语义等效语句），例如futures::Either

Answer 3

我个人更喜欢创建一系列链接在一起的Either值，而不是使用Option<Iterator>。像这样：

playground

use std::iter;

fn main() {
    let x: Option<i64> = None;

    // Repeat x 5 times if present, otherwise count from 1 to 5
    for i in pick(x) {
        println!("{}", i);
    }
}

fn pick(opt_x: Option<i64>) -> impl Iterator<Item = i64> {
    let iter_a = if let None = opt_x {
        Some(1..5)  
    } else {
        None
    };

    let iter_b = if let Some(x) = opt_x {
        Some(iter::repeat(x).take(5))
    } else {
        None
    };

    iter_a.into_iter().flatten().chain(iter_b.into_iter().flatten())
}

与使用Either相比，它不那么明显，但是它避免了使用其他箱子，有时效果非常好。

Answer 4

这里是@Niko出色解决方案的一种变体，它使用单个match表达式而不是几个if let表达式，这在处理更多条件情况时可能更方便：

use std::iter;

fn main() {
    let x: Option<i64> = None;

    // Repeat x 5 times if present, otherwise count from 1 to 5
    for i in pick(x) {
        println!("{}", i);
    }
}

fn pick(opt_x: Option<i64>) -> impl Iterator<Item = i64> {
    let mut iter_a = None;
    let mut iter_b = None;

    match opt_x {
        None => iter_a = Some(1..5),
        Some(x) => iter_b = Some(iter::repeat(x).take(5)),
    }

    iter_a.into_iter().flatten().chain(iter_b.into_iter().flatten())
}

有条件地迭代几个可能的迭代器之一

4 个答案: