Linking Rust objects to one another mutably causes borrowing problems - rust

Question

I have a group of Rust struct instances that represent squares on a game board. Each square knows which other squares can be reached from itself.
Here is my example:
enum Direction {
North,
South,
East,
West,
}
#[derive(Debug)]
struct Square {
x: u16,
y: u16,
}
impl Square {
fn new(x: u16, y: u16) -> Self {
Square { x, y }
}
fn spawn_another_square(&self, d: Direction) -> Self {
let mut new_x = self.x;
let mut new_y = self.y;
match d {
Direction::North => new_y -= 1,
Direction::South => new_y += 1,
Direction::East => new_x += 1,
Direction::West => new_x -= 1,
}
Self::new(new_x, new_y)
}
}
The Square struct has only x and y coordinates in this example, no real data. The struct implements Debug so we can print it, and two functions: a new(), and a spawn_another_square() that returns a new square, with the coordinates of this one, but shifted north, south, east or west as desired.
If we add a main() to test this part, it works.
fn main() {
let northern_square = Square::new(10, 10);
let central_square = northern_square.spawn_another_square(Direction::South);
let western_square = central_square.spawn_another_square(Direction::West);
let eastern_square = central_square.spawn_another_square(Direction::East);
let southern_square = central_square.spawn_another_square(Direction::South);
println!("Northern square: {:?}", northern_square);
println!("Central square: {:?}", central_square);
println!("Western square: {:?}", western_square);
println!("Eastern square: {:?}", eastern_square);
println!("Southern square: {:?}", southern_square);
}
The main first creates the northern_square, using new(), at arbitrary coordinates 10, 10. This is then spawn_another_square()'d into a new central_square that is shifted Direction::South of the first. Then the central square is spawned to make the others. You get the idea.
Next step is to add information about the paths that exist between squares.
#[derive(Debug)]
struct Square {
x: u16,
y: u16,
to_the_north: Option<&Square>,
to_the_south: Option<&Square>,
to_the_east: Option<&Square>,
to_the_west: Option<&Square>,
}
impl Square {
fn new(x: u16, y: u16) -> Self {
Square {
x,
y,
to_the_north: None,
to_the_south: None,
to_the_east: None,
to_the_west: None,
}
}
fn spawn_another_square(&self, d: Direction) -> Self {
let mut new_x = self.x;
let mut new_y = self.y;
match d {
Direction::North => new_y -= 1,
Direction::South => new_y += 1,
Direction::East => new_x += 1,
Direction::West => new_x -= 1,
}
// neighbour squares will be None on new square, even if set on this square
Self::new(new_x, new_y)
}
}
Here we can see four new elements of the struct, to record which square you will find in each of the four directions. The new elements are Option<&Square>, since it is possible for there to be no square at all in some directions, and so that the Square instances can be created before the path information is known. Also, we don't want the squares to own one another, only to point to one another; it wouldn't be possible for east and west both to own central. Also, the new() function has been updated to supply the None values for the new elements.
Of course my example doesn't compile because expected named lifetime parameter, so let's fix that...
#[derive(Debug)]
struct Square<'a> {
x: u16,
y: u16,
to_the_north: Option<&'a Square<'a>>,
to_the_south: Option<&'a Square<'a>>,
to_the_east: Option<&'a Square<'a>>,
to_the_west: Option<&'a Square<'a>>,
}
impl<'a> Square<'a> {
fn new(x: u16, y: u16) -> Self {
Square {
x,
y,
to_the_north: None,
to_the_south: None,
to_the_east: None,
to_the_west: None,
}
}
fn spawn_another_square(&self, d: Direction) -> Self {
let mut new_x = self.x;
let mut new_y = self.y;
match d {
Direction::North => new_y -= 1,
Direction::South => new_y += 1,
Direction::East => new_x += 1,
Direction::West => new_x -= 1,
}
// neighbour squares will be None on new square, even if set on this square
Self::new(new_x, new_y)
}
}
It compiles, but it looks like a lot of extra <'a>s.
Now to try setting some paths, with a new function implemented on the Square struct, and an updated main(). Here's the whole thing:
enum Direction {
North,
South,
East,
West,
}
#[derive(Debug)]
struct Square<'a> {
x: u16,
y: u16,
to_the_north: Option<&'a Square<'a>>,
to_the_south: Option<&'a Square<'a>>,
to_the_east: Option<&'a Square<'a>>,
to_the_west: Option<&'a Square<'a>>,
}
impl<'a> Square<'a> {
fn new(x: u16, y: u16) -> Self {
Square {
x,
y,
to_the_north: None,
to_the_south: None,
to_the_east: None,
to_the_west: None,
}
}
fn spawn_another_square(&self, d: Direction) -> Self {
let mut new_x = self.x;
let mut new_y = self.y;
match d {
Direction::North => new_y -= 1,
Direction::South => new_y += 1,
Direction::East => new_x += 1,
Direction::West => new_x -= 1,
}
Self::new(new_x, new_y) // neighbour squares will be None on new square, even if set on this square
}
fn set_a_path(&mut self, dir: Direction, dest: &'a Square) {
match dir {
Direction::North => self.to_the_north = Some(dest),
Direction::South => self.to_the_south = Some(dest),
Direction::East => self.to_the_east = Some(dest),
Direction::West => self.to_the_west = Some(dest),
};
}
}
fn main() {
let mut northern_square = Square::new(10, 10);
let mut central_square = northern_square.spawn_another_square(Direction::South);
let mut western_square = central_square.spawn_another_square(Direction::West);
let mut eastern_square = central_square.spawn_another_square(Direction::East);
let mut southern_square = central_square.spawn_another_square(Direction::South);
northern_square.set_a_path(Direction::South, &central_square);
println!("Northern square: {:?}", northern_square);
println!("Central square: {:?}", central_square);
println!("Western square: {:?}", western_square);
println!("Eastern square: {:?}", eastern_square);
println!("Southern square: {:?}", southern_square);
}
This works, changing all the square's variables to be mutable, then setting a path with set_a_path() from the northern_square, heading South, to the central_square. This runs OK.
But adding extra paths causes my problem. One more line in main is enough.
central_square.set_a_path(Direction::East, &eastern_square);
This causes the error.
error[E0502]: cannot borrow `central_square` as mutable because it is also borrowed as immutable
--> src/main.rs:51:5
|
49 | northern_square.set_a_path(Direction::South, &central_square);
| --------------- immutable borrow occurs here
50 | // central_square.set_a_path(Direction::North, &northern_square);
51 | central_square.set_a_path(Direction::East, &eastern_square);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable borrow occurs here
...
54 | println!("Northern square: {:?}", northern_square);
| --------------- immutable borrow later used here
Am I completely on the wrong path? Am I going about this in an 'object oriented' way, and not a sufficiently Rusty way? Or am I close, maybe just missing the odd & ref mut * combination?
The square variables need to be mutable, to add the references to the other squares. I don't think we could create the squares with the paths already coded in, because the first square's neighbours would not have been created in time for it to receive its info.

Answer 1

Quick Fix
For the immediate problem your Q ends with, the fix is very simple. You just need to declare the instance you need to mutate later as mut (see comments in code below).
More Info
Sharing references between instances is fine as long as you don't need to mutate the shared-referenced instances after they've been multiply shared. Or, if you're cloning/copying instances in lieu of sharing references, you'll be okay.
If we were really implementing a game board, we could avoid the need for shared references in the fields of squares by using array/Vec indices instead. If we had a single "board" instance that owned an array or Vec that owned all the squares. Fields like to_the_north could have type usize instead of a reference. Or, some sort of handle object based internally on array position could work.
Also, implementing the board as an array-like type is a type of optimization. With the way data is cached by the processor, "locality" of contiguous data can make sequential access very quick. This would be better than implementing the board as a web of references to heap allocated instances that aren't necessarily contiguous.
If something like the above simple design won't work (array with indices/handles), and if you do intend to share MUTABLE references between these squares, then you'll need to leverage Rust's smart pointer classes/structs. With Rust's borrowing rules, in many cases, the alternatives to using the smart pointers are less than desirable. The usage model for Rust generally expects the use of the smart pointer classes where mutable shared access is needed.
The relevant smart pointer classes are:
Rc - multiple owners; reference counted.
RefCell - single owner; mutable interior.
These are typically nested as Rc<RefCell<...>>. Or if you only need ref counted multiple owner access to an instance (without interior mutability), you'll only need Rc<...>. RefCell<...> can also be used independently where it has only has one owner, and the encapsulated item needs to be modified on demand, despite the object owning the RefCell itself being immutable.
For instances of classes shared between threads, the thread-safe analogs for the above are Arc (vs Rc) and Mutex (vs RefCell).
Caveat - circular references
A Vec/array implementation using indices as handles instead of refs avoids the following issue.
If you were to have square instances holding Rc<...> references to each other, you'll likely get memory cycles. And the reference counts in cycles may not ever decrement to 0, in which case if you're creating board after board, and even if they go out of scope, there may be some lingering heap-allocated ref-counted objects building up over time.
This may not matter if your application only ever creates one single board and uses that for the duration.
Among the solutions for handling this case are use of weak pointers. You can read more on how to deal with potential memory cycles here
fn main()
{
let northern_square = Square::new(10, 10);
// Add 'mut'
let mut central_square = northern_square.spawn_another_square(Direction::South);
let western_square = central_square.spawn_another_square(Direction::West);
let eastern_square = central_square.spawn_another_square(Direction::East);
let southern_square = central_square.spawn_another_square(Direction::South);
// Now this is okay.
central_square.set_a_path(Direction::East, &eastern_square);
println!("Northern square: {:?}", northern_square);
println!("Central square: {:?}", central_square);
println!("Western square: {:?}", western_square);
println!("Eastern square: {:?}", eastern_square);
println!("Southern square: {:?}", southern_square);
}