Rust：如何过滤掉“无”排放？

Question

我的用例是我想扫描一个迭代器，并在原始迭代器的段上产生累积值（这是用于标记器）。换句话说，它不是输入值和输出值之间的一对一映射。请注意，filter_map() 不起作用，因为我确实需要累加器值。

我找到了.scan()，这几乎就是我想要的：

#![allow(unused)]
fn main() {
    let a = [1, 2, 3];
    
    let mut iter = a.iter().scan(1, |state, &x| {
        if x == 2 {
            return None;
        }
    
        // each iteration, we'll multiply the state by the element
        *state = *state * x;
    
        // then, we'll yield the negation of the state
        Some(-*state)
    });
    
    println!("{:?}", &iter.next());
    println!("{:?}", &iter.next());
    println!("{:?}", &iter.next());
}

上述输出除外

Some(-1)
None
Some(-3)

当我想要它输出时

Some(-1)
Some(-3)
None

而且，不管你怎么想，这行不通：

        Some(-*state)
    }).filter(|x| x.is_some());

因为我实际上并没有迭代 Options：

error[E0599]: no method named `is_some` found for reference `&{integer}` in the current scope
  --> src/main.rs:15:21
   |
15 |     }).filter(|x| x.is_some());
   |                     ^^^^^^^ method not found in `&{integer}`

所以这就像是故意将迭代器方法与“缺少屈服值”的情况相屏蔽。

我有什么想法可以 a) 过滤掉那些缺失的产量，或者 b) 以完全不同的方式完成上述任务吗？

Answer 1

您可以使用filter_map 并在迭代器外部的变量中创建自己的累加器：

fn main() {
    let a = [1, 2, 3];

    let mut state = 1;

    let mut iter = a.iter().filter_map(|&x| {
        if x == 2 {
            return None;
        }

        // each iteration, we'll multiply the state by the element
        state = state * x;

        // then, we'll yield the negation of the state
        Some(-state)
    });

    println!("{:?}", &iter.next()); // Some(-1)
    println!("{:?}", &iter.next()); // Some(-3)
    println!("{:?}", &iter.next()); // None
}

Answer 2

只打印 3 iter.next() 应该是一个非常罕见的用例。大多数情况下会循环直到None 或在迭代器上使用fuse 或collect 之类的函数。这些函数中的每一个都会删除第一个 None 之后的所有结果。所以从迭代器返回None意味着：终止迭代器。

因此，您应该避免在扫描闭包中终止迭代器，例如

    let mut iter = a.iter().scan(1, |state, &x| {
        if x == 2 {
            return Some(None); // continue, but without value
        }
    
        // each iteration, we'll multiply the state by the element
        *state = *state * x;
    
        // then, we'll yield the negation of the state
        Some(Some(-*state)) // continue with value
    }).flatten(); // remove all missing values

或将扫描与过滤器分开：

let mut iter = a
    .iter()
    .scan(1, |state, &x| {
      if x == 2 {
        return Some((x, *state));
      }

      // each iteration, we'll multiply the state by the element
      *state = *state * x;

      // then, we'll yield the negation of the state
      Some((x, -*state))
    })
    .filter_map(|(x, state)| if x == 2 { None } else { Some(state) });