Need some help with fighting Query lifetimes to make a prototype of query views

[vladbat00]

Hi everyone!

I've been playing around with a prototype of query Views. The idea of "query views" pretty much boils down to being able to map queries to "sub-queries".
Assuming, we've got a query Query<(&ComponentA, &ComponentB, &ComponentC)>, we could do the following:

let view = query.map(|a, b, _c| (a, b));
for (a, b) in view.iter() {
  // ...
}

This is the only version of the implementation for it that I could compile: vladbat00@ed25a8c

examples/ecs/query_views.rs example is working, but if you add another call of q.iter_mut() inside service function, the compilation will fail. And it's pretty much obvious to me why: iter_mut signature makes it so that self is borrowed for 'q lifetime, which is practically the lifetime of the query itself.

Unfortunately, I can't come up with anything else that would compile. If anyone could help me to figure out how to get rid of 'q lifetime for fn iter_mut(&'q mut self), I'd be very grateful.

[cart]

That lifetime is what makes this api safe. If we don't tie the iterator lifetime to Query, then people could call iter_mut() twice, which violates rusts aliased mutability rules.

[vladbat00]

Is it a problem to iterate over query items more than once? What I mean is the following:

let view = query.map(|a, b, _c| (a, b));
for (a, b) in view.iter_mut() {
  // ...
}
for (a, b) in view.iter_mut() {
  // ...
}

To me, It doesn't seem to be unsafe, since the query isn't mutably borrowed more than once at a time. But with my implementation it is, since &'s mut syntax extends the borrow for the whole 's lifetime, so I get the following error in my example:

error[E0499]: cannot borrow `*q` as mutable more than once at a time
  --> examples/ecs/query_views.rs:38:19
   |
34 | fn service<'s>(q: &'s mut impl QueryableMut<'s, Item = (&'s ComponentA, &'s ComponentB)>) {
   |            -- lifetime `'s` defined here
35 |     for (a, b) in q.iter_mut() {
   |                   ------------
   |                   |
   |                   first mutable borrow occurs here
   |                   argument requires that `*q` is borrowed for `'s`
...
38 |     for (a, b) in q.iter_mut() {
   |                   ^ second mutable borrow occurs here

On the other hand, if the view borrowed the query only for the lifetime of the local scope, the code would compile and I'd expect it to be pretty much safe. Please correct me if I'm wrong here.

The problem is that I just can't find the way to write the declaration of iter_mut for QueryableMut that would express that kind of lifetime (and compile 🙂).

[bjorn3]

The following would be allowed if not for the fact that you can only iterate once:

let a = view.iter_mut().next().unwrap();
let b = view.iter_mut().next().unwrap();
aasert_eq!(a as *mut _, b as *mut _); // aliasing mutable references

[vladbat00]

@bjorn3 I'm not sure I understand why. You can try iterating more than once with regular queries, it'll work just fine. The example you've provided won't compile indeed, but for a different reason. iter_mut creates an iterator, which mutably borrows the query. next fetches an item, returning a reference to it, which also keeps both the query and iterator mutably borrowed. Since Rust doesn't allow creating two mutable references, calling iter_mut once again, while a (as in your example) still lives, won't compile. But it's just mutability rules, and it has nothing to do with the fact whether Query::iter_mut extends the borrow to 's lifetime (it actually doesn't).
Apologies for "mansplaining" you the principles that you most likely know yourself, but I just wanted to express my train of thought on why I don't think that your example is related.

I'm still convinced that this code should be valid for both queries and views:

for (a, b) in view.iter_mut() {
  // ...
}
for (a, b) in view.iter_mut() {
  // ...
}