Rust 迭代器和展望（peek/multipeek）

Question

我正在尝试在 Rust 中使用带有迭代器的模式并在某个地方掉下来，显然很简单。

我想遍历一个容器并找到一个带有谓词 [A] 的元素（简单），然后期待使用另一个谓词并获取该值 [B] 并使用 [B] 来改变 [A]某种方式。在这种情况下，[A] 是可变的，而 [B] 可以是不可变的；这对我没有影响，只有借阅检查器（正确）。

这将有助于通过一个简单的场景来理解这一点，所以我添加了一个小 sn-p 让人们看到问题/尝试的目标。我玩过 itertools 并闯入 for/while 循环，尽管我想尽可能地保持习惯。

愚蠢的示例场景

查找一个偶数，找到下一个能被 3 整除的数字并添加到初始数字。

#[allow(unused)]
fn is_div_3(num: &u8) -> bool {
    num % 3 == 0
}

fn main() {
    let mut data: Vec<u8> = (0..100).collect();

    let count = data.iter_mut()
        .map(|x| {
            if *x % 2 == 0 {
                // loop through numbers forward to next is_div_3,
                // then x = x + that number
            }
            true
        })
        .count();

    println!("data {:?}, count was {} ", data, count);
}

playground

Answer 1

很遗憾，我来晚了，但我来了。

它并不完全漂亮，但并不像其他建议那么糟糕：

let mut data: Vec<u8> = (1..100).collect();

{
    let mut mut_items = data.iter_mut();
    while let Some(x) = mut_items.next() {
        if *x % 2 == 0 {
            let slice = mut_items.into_slice();
            *x += *slice.iter().find(|&x| x % 3 == 0).unwrap();
            mut_items = slice.iter_mut();
        }
    }
}

println!("{:?}", data);

给予

[1, 5, 3, 10, 5, 15, 7, 17, 9, 22, ...]

与 Matthieu M. 的解决方案一样。

关键是使用mut_items.into_slice()“重新借用”迭代器，有效地生成迭代器的本地（因此是安全的）克隆。

Answer 2

警告：下面显示的迭代器是unsafe，因为它允许获取单个可变元素的多个别名；更正后的版本跳到第二部分。 （如果返回类型包含不可变引用就可以了）。

如果你愿意编写自己的窗口迭代器，那就变得很容易了。

首先，迭代器的所有细节：

use std::marker::PhantomData;

struct WindowIterMut<'a, T>
    where T: 'a
{
    begin: *mut T,
    len: usize,
    index: usize,
    _marker: PhantomData<&'a mut [T]>,
}

impl<'a, T> WindowIterMut<'a, T>
    where T: 'a
{
    pub fn new(slice: &'a mut [T]) -> WindowIterMut<'a, T> {
        WindowIterMut {
            begin: slice.as_mut_ptr(),
            len: slice.len(),
            index: 0,
            _marker: PhantomData,
        }
    }
}

impl<'a, T> Iterator for WindowIterMut<'a, T>
    where T: 'a
{
    type Item = (&'a mut [T], &'a mut [T]);

    fn next(&mut self) -> Option<Self::Item> {
        if self.index > self.len { return None; }

        let slice: &'a mut [T] = unsafe {
            std::slice::from_raw_parts_mut(self.begin, self.len)
        };
        let result = slice.split_at_mut(self.index);

        self.index += 1;

        Some(result)
    }
}

在[1, 2, 3] 上调用它将返回(&[], &[1, 2, 3]) 然后(&[1], &[2, 3])，...直到(&[1, 2, 3], &[])。简而言之，它遍历切片的所有潜在分区（不进行混洗）。

哪个是安全的：

fn main() {
    let mut data: Vec<u8> = (1..100).collect();

    for (head, tail) in WindowIterMut::new(&mut data) {
        if let Some(element) = head.last_mut() {
            if *element % 2 == 0 {
                if let Some(n3) = tail.iter().filter(|i| *i % 3 == 0).next() {
                    *element += *n3;
                }
            }
        }
    }

    println!("{:?}", data);
}

不幸的是，它也可以用作：

fn main() {
    let mut data: Vec<u8> = (1..100).collect();

    let mut it = WindowIterMut::new(&mut data);
    let first_0 = { it.next(); &mut it.next().unwrap().0[0] };
    let second_0 = &mut it.next().unwrap().0[0];

    println!("{:?} {:?}", first_0 as *const _, second_0 as *const _);
}

在运行 print:0x7f73a8435000 0x7f73a8435000 时，显示两个可变引用为同一个元素起别名。

---

既然我们无法摆脱别名，我们就需要摆脱可变性；或至少遵循内部可变性（Cell 此处因为u8 是Copy）。

幸运的是，Cell 没有运行时成本，但它在人体工程学方面确实需要一些成本（所有这些 .get() 和 .set()）。

我也借此机会使迭代器更加通用，并重命名它，因为 Window 已经是不同概念的使用名称。

struct FingerIter<'a, T>
    where T: 'a
{
    begin: *const T,
    len: usize,
    index: usize,
    _marker: PhantomData<&'a [T]>,
}

impl<'a, T> FingerIter<'a, T>
    where T: 'a
{
    pub fn new(slice: &'a [T]) -> FingerIter<'a, T> {
        FingerIter {
            begin: slice.as_ptr(),
            len: slice.len(),
            index: 0,
            _marker: PhantomData,
        }
    }
}

impl<'a, T> Iterator for FingerIter<'a, T>
    where T: 'a
{
    type Item = (&'a [T], &'a T, &'a [T]);

    fn next(&mut self) -> Option<Self::Item> {
        if self.index >= self.len { return None; }

        let slice: &'a [T] = unsafe {
            std::slice::from_raw_parts(self.begin, self.len)
        };

        self.index += 1;
        let result = slice.split_at(self.index);

        Some((&result.0[0..self.index-1], result.0.last().unwrap(), result.1))
    }
}

我们将其用作积木：

fn main() {
    let data: Vec<Cell<u8>> = (1..100).map(|i| Cell::new(i)).collect();

    for (_, element, tail) in FingerIter::new(&data) {
        if element.get() % 2 == 0 {
            if let Some(n3) = tail.iter().filter(|i| i.get() % 3 == 0).next() {
                element.set(element.get() + n3.get());
            }
        }
    }

    let data: Vec<u8> = data.iter().map(|cell| cell.get()).collect();

    println!("{:?}", data);
}

On the playpen 打印：[1, 5, 3, 10, 5, 15, 7, 17, 9, 22, ...]，这似乎是正确的。