Add run_system_singleton

[hxYuki]

Objective

• Add a handy way running one-shot system for some casual cases. You will not have to register an id and store it if you just call systems from single source.
• Resolves Add one default SystemId registration for one-shot systems #10382

Solution

• Add a new method that runs systems directly and keeps their states indexed by names.

---

Changelog

• Added World::run_system_singleton and corresponding command Command::run_system_singleton.

[github-actions]

Welcome, new contributor!

Please make sure you've read our contributing guide and we look forward to reviewing your pull request shortly ✨

[SkiFire13]

Thinking more about the closure thing, I see a problem: closures can have arbitrary internal state (i.e. the values captured in a closure) other than Locals. However the very first system is the one cached in the SystemMap and the one which gets repeatedly called, meaning the state of new systems gets ignored.

I haven't tested this, but I suspect that this code:

let mut world = World::new();
let make_sys = |n| move || println!("{n}");
let _ = world.run_system_singleton(make_sys(0));
let _ = world.run_system_singleton(make_sys(1));

would print 0 0 instead of 0 1 due the make_sys(0) being cached and called instead of the make_sys(1).

Preventing this method from being called with closures like it was before won't completly fix the issue since the closure could be piped/mapped, in which case it would not be distinguishable from other systems (and also you could manually implement a system as if it was a closure). Requiring std::mem::size_of::<T>() == 0 should work, but it may also rule out legit usecases.

[alice-i-cecile]

@Trashtalk217, review please? <3

[alice-i-cecile]

Very close to my original API and implementation :) I think this is a reasonable set of trade-offs to present to users, but we need to make sure the docs are very clear about the distinction.

Requiring std::mem::size_of::() == 0 should work, but it may also rule out legit usecases

I'd be fine with a info! level warning for this?

[hxYuki]

Currently the method will give a info! warning for closure with captures.

[alice-i-cecile]

Feedback at this point is mostly docs related.

IMO we should:

1. Cover this in the one-shot systems example.
2. Clean up the language on all of the docs for clarity.
3. Move the compare/contrast and limitations for all one-shot systems to module level docs, probably under system_registry.rs.

I would also like to see a fair number of tests, covering various type system edge cases.

[SkiFire13]

Also don't forget to run cargo fmt --all or CI will get angry

[Trashtalk217]

I'm skeptical whether or not this is a good addition. While it's easiest to call a system simply by name, it introduces some shortcomings and that leads us to the rather peculiar situation where we have three run_system methods that all behave slightly differently and have different shortcomings.

I'm afraid that this is confusing to users, and when we add input/output (as in #10380), there should probably also be a run_system_singleton_with_input and overall, I don't like that API very much; where you have 6 or so slightly different methods that look the same but are in some subtle way slightly different.

Also, and this is something actually actionable, can you double-check if you can nest run_system_singleton? As I look at the code, I'm pretty sure that'll break something (maybe spawn two SystemMap resources?).

[hxYuki]

Also, and this is something actually actionable, can you double-check if you can nest run_system_singleton? As I look at the code, I'm pretty sure that'll break something (maybe spawn two SystemMap resources?).

I've tested with this:

fn count(mut commands: Commands, counter: ResMut<Counter>) {
    println!("{}", counter.0);
    let _ = commands.run_system_singleton(count_up);
}
fn count_up(mut counter: ResMut<Counter>) {
    println!("updated");
    counter.0 += 1;
}
let mut world = World::default();
world.insert_resource(Counter(0));
let _ = world.run_system_singleton(count);
let _ = world.run_system_singleton(count);
let _ = world.run_system_singleton(count);

// It prints:
// Creating system map
// 0
// updated
// 1
// updated
// 2
// updated

It seems that nothing goes wrong (Not sure if this is enough).

[hxYuki]

@alice-i-cecile, I wrote more details on World::run_system_singleton. No sure how much should it be on Commands::run_system_singleton.

[janhohenheim]

Is this still needed once #14920 lands? I feel like the linked PR would solve anything that this API could help with.

[alice-i-cecile]

Agreed, closing.