Rust 中 Iterator::find 的解构引用

Question

我正在阅读 Rust by Example，但在搜索迭代器时遇到了 this section 的问题。

pub trait Iterator {
    // The type being iterated over.
    type Item;

    // `find` takes `&mut self` meaning the caller may be borrowed
    // and modified, but not consumed.
    fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where
        // `FnMut` meaning any captured variable may at most be
        // modified, not consumed. `&Self::Item` states it takes
        // arguments to the closure by reference.
        P: FnMut(&Self::Item) -> bool {}
}

fn main() {
    let vec1 = vec![1, 2, 3];
    let vec2 = vec![4, 5, 6];

    // `iter()` for vecs yields `&i32`.
    let mut iter = vec1.iter();
    // `into_iter()` for vecs yields `i32`.
    let mut into_iter = vec2.into_iter();

    // `iter()` for vecs yields `&i32`, and we want to reference one of its
    // items, so we have to destructure `&&i32` to `i32`
    println!("Find 2 in vec1: {:?}", iter     .find(|&&x| x == 2));
    // `into_iter()` for vecs yields `i32`, and we want to reference one of
    // its items, so we have to destructure `&i32` to `i32`
    println!("Find 2 in vec2: {:?}", into_iter.find(| &x| x == 2));
}

如果 iter() 产生 &i32 而 Iterator::find 产生 &mut self，为什么我们需要 2 个符号 &&x 而不是一个 &x？就此而言，为什么 &mut x 不匹配函数的签名？

同样，如果 into_iter() 产生 i32 而 Iterator::find 产生 &mut self，为什么我们不写 &mut x 而不是 &x在管道之间？

Answer 1

find() 占用 &mut self 的事实无关紧要。这意味着 迭代器 需要可变地借用，即 iter.find(f) 实际上是 Iterator::find(&mut iter, f).

|&&x|/|&x|为回调类型F where F: FnMut(&Self::Item) -> bool。 Self::Item 对于 iter 是 &i32，对于 into_iter 是 i32，所以我们分别以 &&i32 和 &i32 结尾。

Rust 中 Iterator::find 的解构引用

Destructuring references for Iterator::find in Rust

rust