rust - 何时可以将双 && 缩写为单 &

Question

在模式匹配中，可以将 &[&] [mut] 附加到标识符，例如 v.iter().filter(|&e 中的 &e | ...) 。这称为reference patterns .

在使用此模式时，我发现了不一致的行为:

• 对于双重借用值，&&e 有效，但 &e 也有效。

• 但是，当可变时，&&mut e 可以工作，而 &mut e 则不起作用。

为什么？

fn main() {

    let mut v = vec![1, 2, 3, 4, 5];

    v.iter()
        .filter(|e| *e * 2 >= 8)
        .for_each(|e| println!("{}", e)); //=> 4 5

    v.iter()
        .filter(|e| **e * 2 >= 8)
        .for_each(|e| println!("{}", e));

    v.iter()
        .filter(|&e| e * 2 >= 8)
        .for_each(|e| println!("{}", e));

    v.iter()
        .filter(|&&e| e * 2 >= 8)
        .for_each(|e| println!("{}", e));

    //NG
    // v.iter_mut()
    //     .filter(|&mut e| e * 2 >= 8)
    //     .for_each(|e| println!("{}", e));

    v.iter_mut()
        .filter(|&&mut e| e * 2 >= 8)
        .for_each(|e| println!("{}", e));

}

Rust Playground

Answer 1

从高层次的角度来看:

&mut T 是 T 类型的可变引用，&&mut T 是 &mut T 的不可变引用.

从编译器角度来看: ( ref )

The grammar production for reference patterns has to match the token&& to match a reference to a reference because it is a token byitself, not two & tokens.

Adding the mut keyword dereferences a mutable reference

基本上，&&将不可变引用指向不可变引用，如果存在mut，它会取消引用可变引用(不可变引用到可变引用，即如上所述)。

---

• When mutable, however, &&mut e works whilst &mut e doesn't work.

&mut e 不起作用，因为 method filter来自 std::iter 期望您定义一个具有不可变引用参数的闭包:

fn filter<P>(self, predicate: P) -> Filter<Self, P>
where
    P: FnMut(&Self::Item) -> bool, 

&&mut T 模式之所以有效，是因为 Self::Item 是一个 &mut T，因为您正在使用 iter_mut() >.