Question

我有以下代码示例：

fn main()
{
    let names : Vec<Vec<String>> = vec![
        vec!["Foo1".to_string(), "Foo2".to_string()],
        vec!["Bar1".to_string(), "Bar2".to_string()]
    ];
    let ids : Vec<i64> = vec![10, 20];

    names.iter().enumerate().flat_map(|(i,v)| {
        let id : i64 = ids[i];
        v.iter().map(|n| 
            (n.clone(), id)
        )
    });
}

现在，当我使用rustc进行编译时，收到以下错误消息：

error[E0597]: `id` does not live long enough
  --> main.rs:12:16
   |
11 |         v.iter().map(|n| 
   |                      --- capture occurs here
12 |             (n.clone(), id)
   |                         ^^ borrowed value does not live long enough
13 |         )
14 |     });
   |     -- borrowed value needs to live until here
   |     |
   |     borrowed value only lives until here

但是据我了解，id的类型为i64，因此应该能够将其复制到捕获中，这正是我所需要的吗？

我也尝试内联id变量，但无济于事：

error[E0597]: `i` does not live long enough
  --> main.rs:11:21
   |
10 |             v.iter().map(|n| 
   |                          --- capture occurs here
11 |                 (n.clone(), ids[i])
   |                                 ^ borrowed value does not live long enough
12 |             )
13 |         });
   |         -- borrowed value needs to live until here
   |         |
   |         borrowed value only lives until here

那么如何将我的整数复制到闭包中而不是借用它呢？

我尝试使用move，但是rustc也不喜欢：

error[E0507]: cannot move out of captured outer variable in an `FnMut` closure
  --> main.rs:10:17
   |
7  |         let ids : Vec<i64> = vec![10, 20];
   |             --- captured outer variable
...
10 |             v.iter().map(move |n| 
   |                          ^^^^^^^^ cannot move out of captured outer variable in an `FnMut` closure

所以我需要某种方式获取rustc来仅移动/复制某些变量，而不移动/复制其他变量？

Answer 1

当您在Rust中创建一个闭包时，它会通过值或引用来捕获变量。不可能混合两者。默认情况下，它通过引用捕获，但是使用move关键字，它通过值捕获（即，它将捕获的变量移动到闭包内部）。

因此，在您的第一个代码中，您需要将id移动到闭包内：

fn main() {
    let names: Vec<Vec<String>> = vec![
        vec!["Foo1".to_string(), "Foo2".to_string()],
        vec!["Bar1".to_string(), "Bar2".to_string()],
    ];
    let ids: Vec<i64> = vec![10, 20];

    names.iter().enumerate().flat_map(|(i, v)| {
        let id: i64 = ids[i];
        v.iter().map(move |n| (n.clone(), id))
    });
}

然后，您询问是否可以“内联” ids：

fn main() {
    let names: Vec<Vec<String>> = vec![
        vec!["Foo1".to_string(), "Foo2".to_string()],
        vec!["Bar1".to_string(), "Bar2".to_string()],
    ];
    let ids: Vec<i64> = vec![10, 20];

    names.iter().enumerate().flat_map(|(i, v)| {
        v.iter().map(|n| (n.clone(), ids[i]))
    });
}

您根本不能将ids放在内部闭包中，因为您已经在FnMut闭包中（需要互斥访问）。因此，您不能借用或移动ids，因为FnMut闭包已经借用了它。最小复制量：

fn main() {
    let mut i = 0;

    let mut closure = || {
        i = 2;
        || {
            println!("i = {}", i);
        }
    };

    closure()();
}

Answer 2

您可以使用move关键字将变量移至结束位置。在这里，您需要像这样更改闭包：

v.iter().map(move |n|  // move is the keyword for moving variables into closure scope.
    (n.clone(), id)
)

Playground

如何在Rust中复制而不是借用i64到闭包中？

2 个答案: