Who adds .system() to hello_world.system()?

[abitrolly]

I am reading https://bevyengine.org/learn/book/getting-started/ecs/#your-first-system which contains the following code.

use bevy::prelude::*;

fn hello_world() {
    println!("hello world!");
}

fn main() {
    App::build()
        .add_system(hello_world.system())
        .run();
}

I don't get where the system() method got attached to hello_world. As I am not a Rust programmer, the explanation that this is "trait extension method" doesn't tell me anything. It would be nice to expand where exactly that attachment happens.

[DJMcNab]

It's an implementation of the bevy_ecs::system::IntoSystem trait:

bevy/crates/bevy_ecs/src/system/into_system.rs

Lines 193 to 195 in 61ce3f7

	pub trait IntoSystem<Params, SystemType: System> {
	fn system(self) -> SystemType;
	}

The implementation specifically for hello_world is generated in this macro call.

bevy/crates/bevy_ecs/src/system/into_system.rs

Line 314 in 61ce3f7

impl_into_system!();

And the actual implementation is generated here, because that function does not have an Input parameter.

bevy/crates/bevy_ecs/src/system/into_system.rs

Line 217 in 61ce3f7

fn system(mut self) -> FuncSystem<Out> {

[abitrolly]

@DJMcNab does that mean that all functions in the file get the .system() method?

[DJMcNab]

Any function which implements the IntoSystem trait would. That would be any function where all of up to 16 parameters implement SystemParam, or the first parameter is In<SomeType>, and then has up to 16 parameters which implement SystemParam.
SystemParam is defined as:

bevy/crates/bevy_ecs/src/system/system_param.rs

Lines 8 to 10 in 61ce3f7

	pub trait SystemParam: Sized {
	type Fetch: for<'a> FetchSystemParam<'a>;
	}

The types which implement SystemParam are listed here https://docs.rs/bevy_ecs/0.4.0/bevy_ecs/trait.SystemParam.html#implementors, and it is also implemented on tuples where every member is SystemParam, again up to 16 elements.

[abitrolly]

Coming from Python I still don't get why it works. The definition for hello_world() doesn't include any params, so no SystemParam reference anywhere.

fn hello_world() {

When Rust decides that hello_world() implements this IntoSystem? Is it when Rust reads the text file and encounters hello_world()? Or maybe it decided later - when all files are read, then some macro processor goes through all global functions and monkey patches them?

[smokku]

Simplifying things a bit.

In Bevy there is a code like this:

impl IntoSystem for FnMut()
{
    fn system(mut self) -> FuncSystem {
        ...
    }
}

Which implements IntoSystem for a function without parameters (FnMut()).

When compiler sees hello_world.system() it does something like this:

1. Ok - the dot means I need to call a method.
2. What is the type of the thing left to dot (hello_world)? It is FnMut().
3. Do I have any trait in scope that defines what is the right of the dot (the system() method) on FnMut()? Yes - the IntoSystem trait.
4. Do I have an implementation of that trait available? Yes (see above).
5. Ok. Let's generate a call to that function passing it the thing on the left of dot.

This way hello_world function becomes mut self inside the system() function call, gets wrapped in a new FuncSystem and passed to .add_system().

That's basically it on the simplest level.
All the macro shenanigans is just so we do not have to write impl IntoSystem for FnMut( .... for every possible set of parameters we want to support. There is a macro that generates all these.

[DJMcNab]

The way this gets resolved, is that the compiler takes the reference to hello_world, which is a function point, having type fn()->(). It then looks for any traits implemented for fn()->(), which includes IntoSystem, because fn()->() meets all of the bounds for the impl of IntoSystem<(), FuncSystem<()>>.

This is the implementation:

bevy/crates/bevy_ecs/src/system/into_system.rs

Line 217 in 61ce3f7

fn system(mut self) -> FuncSystem<Out> {

which is in the expansion of:

bevy/crates/bevy_ecs/src/system/into_system.rs

Line 314 in 61ce3f7

impl_into_system!();

The expanded impl is:

impl<Func, Out> IntoSystem<(), FuncSystem<Out>> for Func
    where Func: FnMut()->() + FnMut()->Out + Send + Sync + 'static, Out: 'static {
    fn system(mut self)->FuncSystem<Out> {...}
}

It then calls the system function from that implementation, with self as the function pointer value hello_world

[TarekAS]

• Every function in Rust is a variable, it has a name, type, and a value.
• The name of the variable is the function name, the type is the function signature, and the value is the code block. We don't care about the code block.
• We can implement traits (i.e. interfaces) for any type, including function signatures.
• IntoSystem is a trait that is generic over all function signatures. Which means that fn hello_world() is eligible to implement it.
• To implement the trait, you must implement a .system() method on the function. As @smokku shows above.
• Because we don't care about the code block of the function, the .system() logic we need to implement is identical for all functions that have the same function signature (i.e. type).
• Therefore, we can automate this process. This is done for your by Bevy through the impl_into_system!(); macro, which generates the .system() implementation for your function signature at compile time.
• .system() is a method that returns your function wrapped up in a FuncSystem type, which is required as input to .add_system.

Obviously I'm simplifying things a bit (and I'm a Rust newbie myself), but hopefully it makes things more understandable.

[abitrolly]

There are more details than fits in my head, but that's already enough to move on. Thanks for replies! :D

[abitrolly]

I would mark #1137 (reply in thread) as an answer, but GitHub doesn't allow me to do so.

[DJMcNab]

@smokku if you make a top level answer that's a clone of that link, then that can be marked as answer

[smokku]

Like so?
#1137 (comment)

[DJMcNab]

Yeah, exactly

[smokku]

Simplifying things a bit.

In Bevy there is a code like this:

impl IntoSystem for FnMut()
{
    fn system(mut self) -> FuncSystem {
        ...
    }
}

Which implements IntoSystem for a function without parameters (FnMut()).

When compiler sees hello_world.system() it does something like this:

1. Ok - the dot means I need to call a method.
2. What is the type of the thing left to dot (hello_world)? It is FnMut().
3. Do I have any trait in scope that defines what is the right of the dot (the system() method) on FnMut()? Yes - the IntoSystem trait.
4. Do I have an implementation of that trait available? Yes (see above).
5. Ok. Let's generate a call to that function passing it the thing on the left of dot.

This way hello_world function becomes mut self inside the system() function call, gets wrapped in a new FuncSystem and passed to .add_system().

That's basically it on the simplest level.
All the macro shenanigans is just so we do not have to write impl IntoSystem for FnMut( .... for every possible set of parameters we want to support. There is a macro that generates all these.