Modifying self in `iter_mut().map(..)`, aka mutable functional collection operations

Question

How do I convert something like this:

let mut a = vec![1, 2, 3, 4i32];
for i in a.iter_mut() {
    *i += 1;
}

to a one line operation using map and a closure?

I tried:

a.iter_mut().map(|i| *i + 1).collect::<Vec<i32>>();

The above only works if I reassign it to a. Why is this? Is map getting a copy of a instead of a mutable reference? If so, how can I get a mutable reference?

Answer 1

Your code dereferences the variable (*i) then adds one to it. Nowhere in there does the original value get changed.

The best way to do what you asked is to use Iterator::for_each:

a.iter_mut().for_each(|i| *i += 1);

This gets an iterator of mutable references to the numbers in your vector. For each item, it dereferences the reference and then increments it.

You could use map and collect, but doing so is non-idiomatic and potentially wasteful. This uses map for the side-effect of mutating the original value. The "return value" of assignment is the unit type () - an empty tuple. We use collect::<Vec<()>> to force the Iterator adapter to iterate. This last bit ::<...> is called the turbofish and allows us to provide a type parameter to the collect call, informing it what type to use, as nothing else would constrain the return type.:

let _ = a.iter_mut().map(|i| *i += 1).collect::<Vec<()>>();

You could also use something like Iterator::count, which is lighter than creating a Vec, but still ultimately unneeded:

a.iter_mut().map(|i| *i += 1).count();

As Ry- says, using a for loop is more idiomatic:

for i in &mut a {
    *i += 1;
}