In a struct with 2 Vecs, how can one Vec's elements hold immutable borrows of the other's?

Question

The code goes something like this:

struct Model {
    // This is Vec #1.
    recorded_curves: Vec<Curve>,
    // This is the Vec whose elements hold references to #1's.
    ongoing_comparisons: Vec<Comparison>,
}

struct Comparison {
   // `recording` references an element in `Model.recorded_curves`.
   recording: &Curve,
   // ...
}

And later, inside a function called event(), I have this:

for recording in model.recorded_curves.iter() {
    model.ongoing_comparisons.push(Comparison {
        recording,
        // ... 
    });
}

Rust demands I add lifetimes to Comparison, but to do that, I have to (as far as I know) use the same lifetime for Model. Afterward, the structs looked like this:

struct Comparison<'a> {
    recording: &'a Curve,
    // ...
}

struct Model<'a> {
    recorded_curves: Vec<Curve>,
    ongoing_comparisons: Vec<Comparison<'a>>,
}

fn event<'a>(_app: &App, model: &'a mut Model<'a>, event: Event) { /* ... */ }

Unfortunately, this brings its own problem. I'm using nannou, where I register event() as a callback, and it doesn't let me use my custom lifetime ('a):

error[E0308]: mismatched types
  --> src/main.rs:17:30
   |
17 |     nannou::app(model).event(event).simple_window(view).run();
   |                              ^^^^^ one type is more general than the other
   |
   = note: expected fn pointer `for<'r, 's> fn(&'r nannou::App, &'s mut Model<'_>, nannou::Event)`
              found fn pointer `for<'a, 'r> fn(&'r nannou::App, &'a mut Model<'a>, nannou::Event)`

Is there a way to accomplish this without using lifetime annotations? Otherwise, could I somehow make the program work with the annotations?

Answer 1

There are multiple solutions to this problem, but in your case I would probably use Reference Counting Smart Pointers.

Depending on your usecase, there are several options for the members of your recorded_curves vector:

• Rc<Curve> - single threaded, immutable
• Rc<RefCell<Curve>> - single threaded, but mutable. Fails at runtime if you want to borrow it twice simultaneously.
• Arc<Curve> - multi threaded, immutable
• Arc<Mutex<Curve>> - multi threaded, mutable, synchronized via mutex

My educated guess is that you probably have a single threaded, but mutable situation, so I'd do:

struct Model {
    // This is Vec #1.
    recorded_curves: Vec<Rc<RefCell<Curve>>>,
    // This is the Vec whose elements hold references to #1's.
    ongoing_comparisons: Vec<Comparison>,
}

struct Comparison {
   // `recording` references an element in `Model.recorded_curves`.
   recording: Rc<RefCell<Curve>>,
   // ...
}

---

If you had two different structs, one holding the data and one holding the references, and the compiler can prove that the data definitely outlives the references, then it's absolutely no problem to hold references to vector elements.

Here is an example to demonstrate that. It has two structs, DataVec and RefVec, one holding the data and the other one holding mutable references. Then, the RefVec gets passed into a function that sorts it and then stores the sorted positions in the RefVec. You can see that this modifies the original DataVec, so that every element now holds the position it would be in after sorting.

#[derive(Debug)]
struct Data(usize);

#[derive(Debug)]
struct DataVec {
    elements: Vec<Data>,
}

#[derive(Debug)]
struct RefVec<'a> {
    elements: Vec<&'a mut Data>,
}

fn convert_to_order(data: &mut RefVec) {
    data.elements.sort_by_key(|el| el.0);
    for (pos, element) in data.elements.iter_mut().enumerate() {
        element.0 = pos;
    }
}

fn main() {
    let mut datavec = DataVec {
        elements: [5, 8, 3, 7, 9, 4].into_iter().map(|e| Data(e)).collect(),
    };

    println!("Data before: {:?}", datavec);

    let mut refvec = RefVec {
        elements: datavec.elements.iter_mut().collect(),
    };

    println!("Reference Vector: {:?}", refvec);

    convert_to_order(&mut refvec);

    println!("Reference Vector after sorting and labeling: {:?}", refvec);
    println!("Data after: {:?}", datavec);
}

Data before: DataVec { elements: [Data(5), Data(8), Data(3), Data(7), Data(9), Data(4)] }
Reference Vector: RefVec { elements: [Data(5), Data(8), Data(3), Data(7), Data(9), Data(4)] }
Reference Vector after sorting and labeling: RefVec { elements: [Data(0), Data(1), Data(2), Data(3), Data(4), Data(5)] }
Data after: DataVec { elements: [Data(2), Data(4), Data(0), Data(3), Data(5), Data(1)] }

Note that if you'd switch the last two println!()s, you would get an error. You can only read datavec after refvec was dropped, which automatically happens between the two prints. The reason is that once a value is borrowed mutably, you can't access the original value at all until that borrow is returned.