Map boxed values to mutable dereferenced values in Rust - iterator

Question

I have a iterator over a series of Boxed values. I would like to map this iterator to one over mutable references to the boxed values.
The following simplified example shows how this can be accomplished for immutable references. This example compiles fine.
let indices = [0usize, 1usize, 2usize];
let vec = vec![Box::new(1.0), Box::new(2.0), Box::new(3.0)];
let i = indices.iter().map(|index| vec[*index].deref()).map(|x| *x + 1.0);
However, for mutable references, like the example below, the compiler produces an error.
let indices = [0usize, 1usize, 2usize];
let mut vec = vec![Box::new(1.0), Box::new(2.0), Box::new(3.0)];
let i = indices.iter().map(|index| vec[*index].deref_mut()).map(|x| *x = *x + 1.0);
The compiler error is the following:
error[E0495]: cannot infer an appropriate lifetime for lifetime parameter in function call due to conflicting requirements
--> src\port_graph/mod.rs:200:40
|
200 | let i = indices.iter().map(|index| vec[*index].deref_mut()).map(|x| *x = *x + 1.0);
| ^^^^^^^^^^^
|
note: first, the lifetime cannot outlive the lifetime as defined on the body at 200:39...
--> src\port_graph/mod.rs:200:40
|
200 | let i = indices.iter().map(|index| vec[*index].deref_mut()).map(|x| *x = *x + 1.0);
| ^^^^^^^^^^^^^^^^^^^^^^^
note: ...so that closure can access `vec`
--> src\port_graph/mod.rs:200:40
|
200 | let i = indices.iter().map(|index| vec[*index].deref_mut()).map(|x| *x = *x + 1.0);
| ^^^
note: but, the lifetime must be valid for the scope of call-site for function at 200:39...
--> src\port_graph/mod.rs:200:40
|
200 | let i = indices.iter().map(|index| vec[*index].deref_mut()).map(|x| *x = *x + 1.0);
| ^^^^^^^^^^^^^^^^^^^^^^^
note: ...so that return value is valid for the call
--> src\port_graph/mod.rs:200:32
|
200 | let i = indices.iter().map(|index| vec[*index].deref_mut()).map(|x| *x = *x + 1.0);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
How could this be fixed?
Edit: For a simple vector, one can simply do the following. However, the examples above are a simplicifation of a case where I want to iterate over a subset of nodes in a graph (petgraph crate), and I don't want to consume the graph itself.
let mut vec = vec![Box::new(1.0), Box::new(2.0), Box::new(3.0)];
let i = vec.iter_mut().map(|boxed| boxed.deref_mut()).map(|x| *x = *x + 1.0);

Answer 1

There is a tremendous difference between immutable and mutable references. The core principle of borrowing is:
Aliasing XOR Mutability
The Rust language guarantees that if you have a mutable reference, there is no other reference which aliases the same object.
In your case, instead of mapping again, let's collect... the addresses:
let c: Vec<_> = indices.iter().map(|index| vec[*index].deref())
.map(|x| x as *const _ as usize)
.collect();
println!("{:?}", c);
We get the list of addresses of elements in the vector.
The only reason those addresses differ is because the indices differ. If we are sneaky, and initialize indices to [0, 1, 2, 1], then we get aliasing.
If we can get aliasing based on a runtime property, then we should NOT also get mutability; and therefore the type system enforces this.
How is it enforced?
The vec is borrowed by the closure.
with deref, the closure borrows &Vec
with deref_mut, the closure borrows &mut Vec
You can witness the first one yourself:
let i = indices.iter().map(|index| vec[*index].deref())
.map(|x| x as *const _ as usize);
vec[0] = Box::new(3.0);
will fail with a note that the vector is already borrowed immutably by the closure.
The second one is a logical extension:
deref_mut takes a &mut self in argument,
which requires IndexMut which also takes a &mut self in argument,
therefore the closure requires mutable access to the vector.
So, each time you call the closure, it accesses a &mut Vec. Therefore, each time you call the closure NOTHING must alias this &mut Vec, and thus, no reference must leak outside the closure.
How is this achieved?
By tightening the lifetime of the reference that you get access to in the closure: each time you invoke the closure, you get a &'scope mut Vec reference where 'scope is the scope of the closure body and no more.
(This also relates to reborrowing and the fact that &mut T is not Copy: since you cannot be handed over a copy of the internally stored &mut T as it's not Copy, you are handed over a re-borrow &mut *vec which has a fresh lifetime).
What's the solution then?
Perform any and all computations directly in the closure where you have access to the Vec. In this closure, you have mutable access after all.
fn main() {
let indices = [0usize, 1usize, 2usize];
let mut vec = vec![Box::new(1.0), Box::new(2.0), Box::new(3.0)];
let c: Vec<_> =
indices.iter()
.map(|index| {
*vec[*index] = *vec[*index] + 1.0;
*vec[*index]
})
.collect();
println!("{:?}", c);
}
Correctly display [2, 3, 4].