Closure may outlive the function while iterating over 2D array - rust

Question

I have a Vec<Vec<u32> and want to iterate over every item and see if it has a bigger number on the right side. Here's my code fragment:
matrix
.iter()
.enumerate()
.flat_map(|(y, row)| {
row.iter()
.enumerate()
.filter(|(x, cell)| (*x..row.len()).find(|x| &matrix[y][*x] > *cell).is_none())
})
.collect::<Vec<_>>();
Unfotunately, this code returns the following error:
error[E0373]: closure may outlive the current function, but it borrows `y`, which is owned by the current function
--> src/main.rs:16:25
|
16 | .filter(|(x, cell)| (*x..row.len()).find(|x| &matrix[y][*x] > *cell).is_none())
| ^^^^^^^^^^^ may outlive borrowed value `y` - `y` is borrowed here
|
note: closure is returned here
--> src/main.rs:14:13
|
14 | / row.iter()
15 | | .enumerate()
16 | | .filter(|(x, cell)| (*x..row.len()).find(|x| &matrix[y][*x] > *cell).is_none())
| |_______________________________________________________________________________________________^
help: to force the closure to take ownership of `y` (and any other referenced variables), use the `move` keyword
|
16 | .filter(move |(x, cell)| (*x..row.len()).find(|x| &matrix[y][*x] > *cell).is_none())
| ++++
If I use move here, then it changes to a different error:
error[E0507]: cannot move out of `matrix`, a captured variable in an `FnMut` closure
--> src/main.rs:16:25
|
9 | let matrix = prepare_matrix();
| ------ captured outer variable
...
13 | .flat_map(|(y, row)| {
| ___________________-
14 | | row.iter()
15 | | .enumerate()
16 | | .filter(move |(x, cell)| (*x..row.len()).find(|x| &matrix[y][*x] > *cell).is_none())
| | ^^^^^^^^^^^^^^^^ ------
| | | |
| | | variable moved due to use in closure
| | | move occurs because `matrix` has type `Vec<Vec<u32>>`, which does not implement the `Copy` trait
| | move out of `matrix` occurs here
17 | | })
| |_________- captured by this `FnMut` closure
I have tried to clone matrix and work on its clone for comparing, but it doesn't work either. How do I fix this?

Answer 1

The problem is that you return filter()'s closure from flat_map(), but it captures y, which is owned by flat_map(), and it captures it by reference because it is Copy.
As always, when we want to force a closure to capture something by copy/move, we add move to it:
.flat_map(|(y, row)| {
row.iter()
.enumerate()
.filter(move |(x, cell)| (*x..row.len()).find(|x| &matrix[y][*x] > *cell).is_none())
})
But now we have another problem:
error[E0507]: cannot move out of `matrix`, a captured variable in an `FnMut` closure
--> src/main.rs:10:25
|
2 | let matrix: Vec<Vec<u32>> = Vec::new();
| ------ captured outer variable
...
6 | .flat_map(|(y, row)| {
| ---------- captured by this `FnMut` closure
...
10 | .filter(move |(x, cell)| (*x..row.len()).find(|x| &matrix[y][*x] > *cell).is_none())
| ^^^^^^^^^^^^^^^^ ------
| | |
| | variable moved due to use in closure
| | move occurs because `matrix` has type `Vec<Vec<u32>>`, which does not implement the `Copy` trait
| move out of `matrix` occurs here
error[E0505]: cannot move out of `matrix` because it is borrowed
--> src/main.rs:6:19
|
3 | / matrix
4 | | .iter()
| |_______________- borrow of `matrix` occurs here
5 | .enumerate()
6 | .flat_map(|(y, row)| {
| -------- ^^^^^^^^^^ move out of `matrix` occurs here
| |
| borrow later used by call
...
10 | .filter(move |(x, cell)| (*x..row.len()).find(|x| &matrix[y][*x] > *cell).is_none())
| ------ move occurs due to use in closure
Because a move closure captures everything by move, it includes matrix. But matrix isn't Copy so we can't do that.
The way to force a move closure to capture something specific by reference is to add a variable containing a reference and capture it:
.flat_map(|(y, row)| {
let matrix = &matrix;
row.iter()
.enumerate()
.filter(move |(x, cell)| (*x..row.len()).find(|x| &matrix[y][*x] > *cell).is_none())
})