How to use data generated from builder pattern

Question

I'm new to Rust and this is basically the first Rust code I'm trying to write. Below is a simplified version of the problematic code I'm working on, but the errors are exactly the same.

struct A {
    pub value : i32
}

impl A {
    pub fn new() -> Self {
        A {value : 0}
    }
}

struct B {
    vec_a : Vec
}

impl B {
    pub fn new() -> Self {
        B {
            vec_a : Vec::new()
        }
    }
    pub fn create_A(&mut self) -> &mut A {
        let a = A::new();
        self.vec_a.push(a);
        let last_index = self.vec_a.len() - 1;
        &mut self.vec_a[last_index]
    }
}

fn main() {
    let mut b = B::new();
    let a1 : &mut A = b.create_A();
    let a2 : &mut A = b.create_A();
    
    println!("{}, {}", a1.value, a2.value);
}

The code gives below compilation error:

error[E0499]: cannot borrow `b` as mutable more than once at a time
  --> src/main.rs:32:23
   |
31 |     let a1 : &mut A = b.create_A();
   |                       ------------ first mutable borrow occurs here
32 |     let a2 : &mut A = b.create_A();
   |                       ^^^^^^^^^^^^ second mutable borrow occurs here
33 |     
34 |     println!("{}, {}", a1.value, a2.value);
   |                        -------- first borrow later used here

It seems to me that the compiler is telling me that the using of a1 is not safe as it is generated from b, and yet there is another mutable borrow of b after a1, that may change b, so that the data in a1 is invalid now. Am I understanding this error correctly? If so, how do I tell the compiler a1 and a2 are completely different part of b and using a1 later on is fine?

Code in Rust Playground

Finomnis · Answer

Yes your understanding is correct. a1 is borrowed from b, and while a1 exists, you cannot modify b.

If so, how do I tell the compiler a1 and a2 are completely different part of b and using a1 later on is fine?

That's wrong, and the fact that you assume it is possible shows how valuable the borrow checker is. Even in C++, your code would be undefined behaviour.

Adding an element to a vector could cause a memory reallocation, invalidating all references to elements in that vector. It's the same in C++.

Therefore the compiler is right: You cannot do this. self.vec_a.push() will potentially invalidate your a1 reference.

Even if a reallocation would not happen, your code would still be unsound.

Nothing in b keeps track of the references to the vector. Therefore if you could access b while a1 (a &mut reference into b) exists, you could get another reference &b.vec_a[0]. Then you would have a &mut and a & reference to the same A object at the same time, which is forbidden/unsound.

What are you trying to accomplish? I'm sure there is a different programming pattern that is more suited for Rust. The one you are using right now is simply not compatible with Rust.

How to use data generated from builder pattern

1 Answers