idiomatic mutable arena traversal dependent on immutable member - rust

Question

How should I rewrite the following code idiomatically?
The problem seems to be that traversal could be modified during action(). One solution would be to create a temporary copy of traversal inside of traverse, but that would be a burden if traversal is large.
Maybe Idiomatically access an element of a vector mutably and immutably is the canonical version of this, but I am not sure (and have not fully understood the referenced issue)?
struct Foo {}
struct Bar {
traversal: Vec<usize>,
arena: Vec<Foo>,
}
impl Bar {
fn action(&mut self, foo_idx: usize) {
// mutate self.arena[foo_idx]
}
fn traverse(&mut self) {
for i in &self.traversal {
self.action(*i);
}
}
}
current error:
error[E0502]: cannot borrow `*self` as mutable because it is also borrowed as immutable
--> src/main.rs:15:13
|
14 | for i in &self.traversal {
| ---------------
| |
| immutable borrow occurs here
| immutable borrow later used here
15 | self.action(*i);
| ^^^^^^^^^^^^^^^ mutable borrow occurs here

Answer 1

In your case, Bar has two apparently disjoint fields, so it should be possible to hold references to each of them at the same time. The problem, though, is even though action only touches arena, rust assesses the borrowing rules based on the function's prototype:
fn action(&mut self, foo_idx: usize)
which indicates that it takes a mutable borrow of self.
Here are a few possible solutions:
Inline
If the mutation being performed inside action is simple, and isn't called from anywhere else, then just do it inline inside traverse:
struct Foo {}
struct Bar {
traversal: Vec<usize>,
arena: Vec<Foo>,
}
impl Bar {
fn traverse(&mut self) {
for i in &self.traversal {
// mutate arena here
self.arena[*i] = Foo{};
}
}
}
Refactor
If traversal and arena are really two different things, maybe it makes more sense for them to belong to separate types, like this:
struct Foo {}
struct Baz(Vec<Foo>);
impl Baz {
fn action(&mut self, foo_idx: usize) {
self.0[foo_idx] = Foo{};
}
}
struct Bar {
traversal: Vec<usize>,
arena: Baz,
}
impl Bar {
fn traverse(&mut self) {
for i in &self.traversal {
self.arena.action(*i);
}
}
}
Associated Function
A variation on the above theme is to simply change the prototype of action so that it takes only the field it will modify as input. action is no longer a method as such - it does not take self - but is still associated with the type Bar:
struct Foo {}
struct Bar {
traversal: Vec<usize>,
arena: Vec<Foo>,
}
impl Bar {
fn action(arena: &mut Vec<Foo>, foo_idx: usize) {
arena[foo_idx] = Foo{};
}
fn traverse(&mut self) {
for i in &self.traversal {
Self::action(&mut self.arena, *i);
}
}
}
Traverse via index
Instead of iterating the traversal Vec, you can avoid taking the initial immutable borrow like this:
struct Foo {}
struct Bar {
traversal: Vec<usize>,
arena: Vec<Foo>,
}
impl Bar {
fn action(&mut self, foo_idx: usize) {
// mutate self.arena[foo_idx]
}
fn traverse(&mut self) {
for traversal_idx in 0..self.traversal.len() {
let i = self.traversal[traversal_idx];
self.action(i);
}
}
}

Answer 2

I can think of two ways to do this (plus an easier way that's less general). The first is to destructure the struct so you aren't dealing with self anymore, but only its data. Then the data are independent so you the ownership of arena and traverse won't conflict anymore because they are independent. The disadvantage is that the function parameters get more complex.
struct Foo {
pub i: i32,
}
struct Bar {
traversal: Vec<usize>,
arena: Vec<Foo>,
}
impl Bar {
fn action(arena: &mut Vec<Foo>, foo_idx: usize) {
arena[foo_idx].i += 1;
}
fn traverse(&mut self) {
let Bar { traversal, arena } = self;
for i in traversal {
Self::action(arena, *i);
}
}
}
The other way has a nicer API but is more risky: take just one value out of self (use std::mem::take or std::mem::replace) so you can reference it with no dependency on self. This is a liability is because you need to remember to put the value back in afterwards, and if you are using Result, ? can make the function return early and not execute the cleanup.
struct Foo {
pub i: i32,
}
struct Bar {
traversal: Vec<usize>,
arena: Vec<Foo>,
}
impl Bar {
fn action(&mut self, foo_idx: usize) {
self.arena[foo_idx].i += 1;
}
fn traverse(&mut self) {
let traversal = std::mem::take(&mut self.traversal);
for i in traversal.iter() {
self.action(*i);
}
self.traversal = traversal;
}
}
If your real code is only iterating as in this example, there is an easier way to solve it: change the vector to Rc<Vec<Foo>>. That way you can use Rc::clone to get a copy of the variable that's independent of self, but points at the same data.