Unable to borrow a Vec inside of a closure - rust

Question

I have a vector of Units. I'm trying to construct a Vec<Vec<Unit>> variable, called world. In the process of creating tiles, I need to know what tiles are adjacent that it knows of.
I have a function that returns a vector of points ((usize, usize)) that are adjacent to another point, and I'm converting that to an iterator, mapping over it, and getting the actual unit associated with that position in world if it's there, or the current line which has not yet been committed to world.
I need to access that line inside the closure that map takes, but I also need to access it later.
fn adjacent((x, y): (usize, usize)) -> Vec<(usize, usize)> {
vec![
(x+1, y),
(x-1, y),
(x, y+1),
(x, y-1),
]
}
struct Unit {
pub tiles: Vec<Tile>,
}
#[derive(Copy, Clone)]
enum Tile {
Floor, Wall, Empty
}
fn main() {
let heightmap = vec![
vec![3, 3, 3, 3, 3, 3],
vec![3, 1, 1, 1, 1, 3],
vec![3, 1, 1, 1, 1, 3],
vec![3, 1, 1, 1, 1, 3],
vec![3, 1, 1, 1, 1, 3],
vec![3, 1, 1, 1, 1, 3],
vec![3, 3, 3, 3, 3, 3],
];
let (sx, sy) = (5, 5);
let mut world: Vec<Vec<Unit>> = vec![];
for y in 0..sy {
let mut line: Vec<Unit> = vec![];
for x in 0..sx {
let mut tiles: Vec<Tile> = vec![];
let height = heightmap[y][x];
let adj = adjacent((x, y))
.iter()
.map(|&(x, y)| {
let list = if y > world.len() {
vec![]
} else if y == world.len() {
line
} else {
world[y]
};
if x >= list.len() {
Tile::Empty
} else {
if height as usize >= list[x].tiles.len() {
Tile::Empty
} else {
list[x].tiles[height as usize]
}
}
})
.collect::<Vec<_>>();
for z in 0..(height as isize - 1) {
tiles.push(Tile::Wall);
}
line.push(Unit {
tiles: tiles,
});
}
world.push(line);
}
}
Here is the Rust Playground.
I would have rather used unwrap_or in combination with get and so on but that leads to other errors with temporary values, and that would be more complicated anyway, so the above code, while probably not optimal, is as simple as I can get it while still duplicating the error. I've found out that a lot of the errors I get with Rust is because what I'm doing isn't the best way to go about it, so if there is a more idiomatic way, I would certainly like to know.
I've tried to make Unit cloneable (deriving Clone and Copy) but Rust won't let me for some reason, even though all it is made up of is vectors which are cloneable if their members are.

Answer 1

Here's a smaller example of your problem:
fn main() {
let mut line = vec![1];
let something_to_iterate_over = vec![true, false, true];
for _ in 0..2 {
let _dummy: Vec<_> = something_to_iterate_over
.iter()
.map(|&value| {
let maybe_moved_line = if value { vec![] } else { line };
() // Don't care about the return value
})
.collect();
line.push(2);
}
}
The first part of the error message is:
error[E0382]: capture of moved value: `line`
--> src/main.rs:9:67
|
8 | .map(|&value| {
| -------- value moved (into closure) here
9 | let maybe_moved_line = if value { vec![] } else { line };
| ^^^^ value captured here after move
|
= note: move occurs because `line` has type `std::vec::Vec<i32>`, which does not implement the `Copy` trait
error[E0382]: use of moved value: `line`
--> src/main.rs:14:9
|
8 | .map(|&value| {
| -------- value moved (into closure) here
...
14 | line.push(2);
| ^^^^ value used here after move
|
= note: move occurs because `line` has type `std::vec::Vec<i32>`, which does not implement the `Copy` trait
As the error message is attempting to convey, the code no longer has ownership of the variable line after the map call because the ownership has been transferred to the closure.
The code is attempting to give a single Vec to someone else while keeping it for itself, and that's simply not how ownership works. I can't give you my car and then continue to drive it everyday — it's not mine to drive!
The smallest amount of change to get your code to compile is to stop trying to give away the one and only line, but instead to clone it as needed:
Add #[derive(Clone)] to Unit
Clone line and world[y] inside the closure: line.clone(), world[y].clone()
After doing this, the code never gives up ownership of line so it can be cloned whenever needed.