I query an optional component mutably in bevy and it compiles but does not modify it. Why?

Question

The unofficial bevy cheat book explains how queries work:

The first type parameter for a query is the data you want to access. Use & for shared/readonly access and &mut for exclusive/mutable access. Use Option if the component is not required (you want to access entities with or without that component). If you want multiple components, put them in a tuple.

It implies that I could specify something like this to modify an Optional component and also seeing the entities where it is None:

fn my_mut_system(query: Query<(&Person, Option<&mut Name>)>) {
  // I can mutate the Name here, if the person has one.
}

But i couldn't get that to work. (Solution at the end of the question).
While attempting, I ran into an example that compiles but does the wrong thing, and I would like to understand what is going on.

What i Tried

Readonly Optional works:

fn my_second_system(query: Query<(&Person, Option<&Name>)>) {
    for (_person,name) in &query {
        println!("Hello Again, {:?}", name);
    }
}

Fetching only the components that have a Name, also works:

// Fetching Name directly: works
fn my_update_system(query: Query<&Name, With>) {
    for name in &query {
        println!("Hello, {}", name.0);
    }
}

And if I add a lot of mut keywords, I can even mutate the name:

fn my_update_system(mut query: Query<&mut Name, With>) {
    for mut name in &mut query {
        println!("Hello, {}. I'll call you Bernhard.", name.0);
        name.0 = "Bernhard".to_string();
    }
}

That all works. The name change is reflected in further systems.

But when I try to also receive the components that do not have a name, I struggle:

// This builds but does the wrong thing!
fn my_mut_system(query: Query<(&Person, Option<&mut Name>)>) {
    for (_person, mut name_option) in &query {
        if let Some(ref mut name) = &mut name_option {
            println!("Hello a third time, {:?}", name);
            *name = &Name("Renamedinho".to_string());
        } else {
            println!("Hello, Anon.");
        }
    }
}

This example builds and runs without warnings, but the next system (chained after this my_mut_system) does not see the name change.

The same code, with the type hints that rust-analyzer adds in vscode:

I thought what should happen here is this: I get an Option that contains a mutable reference to a Name. If I follow that reference with *name =, I can assign a new Name into the Option. But clearly, that is not what is happening, since the compiler required a *name = &Name instead of the *name = Name I was expecting...

Note that trying to avoid that roundabout does not compile:

// This does not work!
fn my_mut_system_one(query: Query<(&Person, Option<&mut Name>)>) {
    for (_person, mut name_option) in &query {
        // Note: maybe I could even drop both of these ref mut and &mut ?
        // The confusion_two.rs file seems to indicate so.
        if let Some(name) = &mut name_option {
            println!("Hello a third time, {:?}", name);
            name.0 = "Renamedinho One".to_string();
        } else {
            println!("Hello, Anon.");
        }
    }
}

Even though the type Option<&mut Name> contains mut, the compiler says:

error[E0594]: cannot assign to name.0, which is behind a & reference

error[E0594]: cannot assign to `name.0`, which is behind a `&` reference
  --> src/main.rs:63:13
   |
63 |             name.0 = "Renamedinho One".to_string();
   |             ^^^^^^ cannot assign

For more information about this error, try `rustc --explain E0594`.
error: could not compile `wobbler-repro` (bin "wobbler-repro") due to 1 previous error

In this gist is an example snippet + example output of what i mentioned above.

Solution

Making the whole query mut allows this:

// This seems to work
fn my_mut_system_two(mut query: Query<(&Person, Option<&mut Name>)>) {
    for (_person, mut name_option) in &mut query {
        if let Some(name) = &mut name_option {
            println!("Hello a third time, {:?}", name);
            name.0 = "Succeederinho".to_string();
        } else {
            println!("Hello another time, Anon.");
        }
    }
}

Question

What happened in the broken my_mut_system?
- Why does my_mut_system not modify the name permanently?
- What's up with the unexpected need for an ampersand in *name = &Name(...?
- Why did this compile, if it does not actually have mut access to the query and the option?

I query an optional component mutably in bevy and it compiles but does not modify it. Why?

What i Tried

Solution

Question

Answers (1)

Related Questions