Rust not allowing mutable borrow when splitting properly

Question

struct Test {
    a: i32,
    b: i32,
}

fn other(x: &mut i32, _refs: &Vec<&i32>) {
    *x += 1;
}

fn main() {
    let mut xes: Vec<Test> = vec![Test { a: 3, b: 5 }];
    let mut refs: Vec<&i32> = Vec::new();
    for y in &xes {
        refs.push(&y.a);
    }
    xes.iter_mut().for_each(|val| other(&mut val.b, &refs));
}

Although refs only holds references to the a-member of the elements in xes and the function other uses the b-member, rust produces following error:

error[E0502]: cannot borrow `xes` as mutable because it is also borrowed as immutable
  --> /src/main.rs:16:5
   |
13 |     for y in &xes {
   |              ---- immutable borrow occurs here
...
16 |     xes.iter_mut().for_each(|val| other(&mut val.b, &refs));
   |     ^^^ mutable borrow occurs here                   ---- immutable borrow later captured here by closure

Playground

Is there something wrong with the closure? Usually splitting borrows should allow this. What am I missing?

Answer 1

Splitting borrows only works from within one function. Here, though, you're borrowing field a in main and field b in the closure (which, apart from being able to consume and borrow variables from the outer scope, is a distinct function).

As of Rust 1.43.1, function signatures cannot express fine-grained borrows; when a reference is passed (directly or indirectly) to a function, it gets access to all of it. Borrow checking across functions is based on function signatures; this is in part for performance (inference across functions is more costly), in part for ensuring compatibility as a function evolves (especially in a library): what constitutes a valid argument to the function shouldn't depend on the function's implementation.

As I understand it, your requirement is that you need to be able to update field b of your objects based on the value of field a of the whole set of objects.

I see two ways to fix this. First, we can capture all mutable references to b at the same time as we capture the shared references to a. This is a proper example of splitting borrows. A downside of this approach is that we need to allocate two Vecs just to perform the operation.

fn main() {
    let mut xes: Vec<Test> = vec![Test { a: 3, b: 5 }];
    let mut x_as: Vec<&i32> = Vec::new();
    let mut x_bs: Vec<&mut i32> = Vec::new();
    for x in &mut xes {
        x_as.push(&x.a);
        x_bs.push(&mut x.b);
    }
    x_bs.iter_mut().for_each(|b| other(b, &x_as));
}

Here's an equivalent way of building the two Vecs using iterators:

fn main() {
    let mut xes: Vec<Test> = vec![Test { a: 3, b: 5 }];
    let (x_as, mut x_bs): (Vec<_>, Vec<_>) =
        xes.iter_mut().map(|x| (&x.a, &mut x.b)).unzip();
    x_bs.iter_mut().for_each(|b| other(b, &x_as));
}

Another way is to avoid mutable references completely and to use interior mutability instead. The standard library has Cell, which works well for Copy types such as i32, RefCell, which works for all types but does borrowing checking at runtime, adding some slight overhead, and Mutex and RwLock, which can be used in multiple threads but perform lock checks at runtime so at most one thread gets access to the inner value at any time.

Here's an example with Cell. We can eliminate the two temporary Vecs with this approach, and we can pass the whole collection of objects to the other function instead of just references to the a field.

use std::cell::Cell;

struct Test {
    a: i32,
    b: Cell<i32>,
}

fn other(x: &Cell<i32>, refs: &[Test]) {
    x.set(x.get() + 1);
}

fn main() {
    let xes: Vec<Test> = vec![Test { a: 3, b: Cell::new(5) }];
    xes.iter().for_each(|x| other(&x.b, &xes));
}