How to mutably borrow more tnan one resource in an exclusive_system?

[bcolloran]

I have a Rust newbie question that I'm hoping is an easy answer for someone, but I've been digging around and I'm a bit stuck.

I'm trying to mutably access a couple of resources in an exclusive system via World methods. Schematically, the naive (non working) approach would look like this:

struct ResourceA {
    num: u32,
}
struct ResourceB {
    num: u32,
}

pub fn exclusive_sys_1(world: &mut World) {
    let mut res_a = world.resource_mut::<ResourceA>();
    let mut res_b = world.resource_mut::<ResourceB>();
    res_a.num += 1;
    res_b.num += 1;
}

which fails with:

error[E0499]: cannot borrow `*world` as mutable more than once at a time
  --> src/snapshot_systems.rs:80:21
   |
79 |     let mut res_a = world.resource_mut::<ResourceA>();
   |                     --------------------------------- first mutable borrow occurs here
80 |     let mut res_b = world.resource_mut::<ResourceB>();
   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ second mutable borrow occurs here
81 |     res_a.num += 1;
   |     ----- first borrow later used here

Still wrapping my head around borrowing... seems that .resource_mut() method borrows all of world rather than just the resource indicated.

So, looking for another approach, I found .get_resource_unchecked_mut() while digging around in bevy's code. Using that method, the system would look like:

pub unsafe fn exclusive_sys_2(world: &mut World) {
    let res_a = &mut world
        .get_resource_unchecked_mut::<ResourceA>()
        .expect("must exist");
    let res_b = &mut world
        .get_resource_unchecked_mut::<ResourceB>()
        .expect("must exist");
    res_a.num += 1;
    res_b.num += 1;
}

in this case, the function itself seems to be fine (no compiler errors there), but it seems it's not possible to use an unsafe function as a bevy system, or at least not as an exclusive system:

error[E0599]: no method named `exclusive_system` found for fn item `for<'r> unsafe fn(&'r mut bevy::prelude::World) {exclusive_sys_2}` in the current scope
   --> src/main.rs:211:18
    |
210 |             snapshot_systems::exclusive_sys_2
    |             --------------------------------- this is a function, perhaps you wish to call it
211 |                 .exclusive_system()
    |                  ^^^^^^^^^^^^^^^^ method not found in `for<'r> unsafe fn(&'r mut bevy::prelude::World) {exclusive_sys_2}`

I'm sure there's a ton I'm doing wrong, would love any tips or advice about how to mutably access multiple resources in an exclusive system, and/or other suggestions. Thanks! :-)

[bcolloran]

Oh oops, I just noticed resource_scope which looks like maybe it can work for my use case (which of course is a bit more complex than the simple example above). I'll investigate and report back...

[nicopap]

Your question is actually two questions, so here are the answers

How to access multiple resources mutably at the same time on a &mut World

There is two ways to go about it:

1. resource_scope method on World.

world.resource_scope(|world, mut a: Mut<A>| {
    let b = world.get_mut::<B>(entity).unwrap();
    a.0 += b.0;
});

This incurs rightward drift, but it's the quick and dirty solution

2. Use SystemState to "emulate" a system parameter-style interface.

let mut system_state: SystemState<(
    EventWriter<MyEvent>,
    Option<ResMut<MyResource>>,
    Query<&MyComponent>,
    )> = SystemState::new(&mut world);
let (event_writer, maybe_resource, query) = system_state.get_mut(&mut world);

I find that SystemState is a very nifty API that solves a lot of problems, but most of the time resource_scope is enough.

Why can't I make my system exclusive?

Systems can't be unsafe fn (unsafe fn have a distinct type from normal fns), you shouldn't use unsafe the way you do here, and instead limit them to the element that is actually unsafe (and generally document why the code you call in your unsafe is actually sound). Though in this case you don't need unsafe. Generally speaking, a function marked unsafe is a function that may be unsound if not used correctly and should have a doc string explaining what is unsound and how to avoid it (which I think is absolutely not what you want here)

[bcolloran]

Wow, super impressed that you were able to write such a helpful reply so fast!!! Many thanks @nicopap :-)

[bcolloran]

For anyone who may come across this one day, here are concrete applications of @nicopap's recommendations extended to the toy scenario at top of the thread:

pub fn exclusive_sys_3(world: &mut World) {
    world.resource_scope(|world, mut res_a: Mut<ResourceA>| {
        let mut res_b = world.resource_mut::<ResourceB>();
        res_a.num += 1;
        res_b.num += 1;
    });
}

pub fn exclusive_sys_4(world: &mut World) {
    let mut sys_state: SystemState<(ResMut<ResourceA>, ResMut<ResourceB>)> =
        SystemState::new(world);

    let (mut res_a, mut res_b) = sys_state.get_mut(world);
    res_a.num += 1;
    res_b.num += 1;
}

For my particular use case, it looks like SystemState will be perfect. Thanks again @nicopap for pointing me in the right direction :-)

[hymm]

There's also a third way, which is to remove the resource and insert it m back in after you're done.

let res = world.remove_resource<R>().unwrap();
// do something with `res`
world.insert_resource(res);