rust - '&&x' 模式匹配是否会导致 x 被复制？

Question

在 std::iter::Iterator::filter() 的文档中它解释了值通过引用传递给闭包，并且由于许多迭代器产生引用，在这种情况下传递的值是对引用的引用。它提供了一些改进人体工程学的建议，通过使用 &x模式来删除一级间接，或 &&x模式以删除两个间接级别。

但是，我发现如果被迭代的项目没有实现 Copy，则第二个模式不会编译。 :

#[derive(PartialEq)]
struct Foo(i32);

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

    // This works
    let _ = a.iter().filter(|&x| *x != Foo(1));

    // This also works
    let _ = a.iter().filter(|&x| x != &Foo(1));

    // This does not compile
    let _ = a.iter().filter(|&&x| x != Foo(1));
}

你得到的错误是:

error[E0507]: cannot move out of a shared reference
  --> src/main.rs:14:30
   |
14 |     let _ = a.iter().filter(|&&x| x != Foo(1));
   |                              ^^-
   |                              | |
   |                              | data moved here
   |                              | move occurs because `x` has type `Foo`, which does not implement the `Copy` trait
   |                              help: consider removing the `&`: `&x`

这是否意味着如果我使用 &&x解构模式，值为 Copy , Rust 会默默地复制我迭代的每个值吗？如果是这样，为什么会这样？

Answer 1

在 Rust 中，函数或闭包参数是无可辩驳的模式。

在 Rust reference ， 它说:

By default, identifier patterns bind a variable to a copy of or move from the matched value depending on whether the matched value implements Copy.

所以，在这种情况下:

let _ = a.iter().filter(|&x| *x != Foo(1));

闭包被传递一个对被迭代项的引用的引用；因此 x绑定(bind)到对该项目的引用的副本。你总是可以复制一个引用(它基本上是一个无操作)，所以这总是成功的。

在这种情况下:

let _ = a.iter().filter(|&&x| x != Foo(1));

x被绑定(bind)到项目本身的副本 - 如果项目不是 Copy 则失败.

引用资料还说:

This can be changed to bind to a reference by using the ref keyword, or to a mutable reference using ref mut.

但在这种情况下，这并不是那么有用: &&ref x结果 x 是对该项目的引用，就像您使用了 &x 一样.