Allow non-static references as system Input in systems that are ran directly

[ItsDoot]

What problem does this solve or what need does it fill?

Directly ran systems (i.e. one-shot systems) currently effectively require a 'static bound on the System::In associated type, preventing one from passing (non-'static) references as input to a system via System::run:

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

Line 63 in 365cf31

fn run(&mut self, input: Self::In, world: &mut World) -> Self::Out {

Being able to pass non-'static references to one-shot systems would likely allow us to create full systems as egui widgets, an extension of #5522's rudimentary WidgetSystem into full-featured (exclusive) Systems, for example.

Given that System::In is only ever used as a function argument, it should be possible to implement this in a way that doesn't lose trait objects? I did some experimental implementing of this recently by turning it into a GAT, but ran into the trait object issue and haven't attempted since.

What solution would you like?

For systems that are ran directly (one-shot systems), allow passing non-'static references as system input.

What alternative(s) have you considered?

Clone objects that need to be passed in. This doesn't work for all cases, though.

[ItsDoot]

Here's a sample showing that 'static is required:

use bevy::{ecs::system::BoxedSystem, prelude::*};

pub struct Callback<In, Out> {
    initialized: bool,
    system: BoxedSystem<In, Out>,
}

impl<In: 'static, Out: 'static> Callback<In, Out> {
    pub fn new<M>(system: impl IntoSystem<In, Out, M>) -> Self {
        Self {
            initialized: false,
            system: Box::new(IntoSystem::into_system(system)),
        }
    }

    pub fn is_initialized(&self) -> bool {
        self.initialized
    }

    pub fn run(&mut self, world: &mut World, input: In) -> Out {
        if !self.initialized {
            self.system.initialize(world);
        }

        let output = self.system.run(input, world);
        self.system.apply_deferred(world);

        output
    }
}

Try removing the 'static bounds on the impl block.

[ItsDoot]

Dang, seems like we're blocked by rust-lang/rust#81823 for now, if the solution requires GATs.

[SkiFire13]

GATs may not be needed if we move the In associated type to a generic of System, kinda like how it's done for the Fn* traits. This way you would be able to have a for<'a> System<&'a Foo, Out = &'a Bar> which would be callable with non 'static inputs and even get non-'static outputs that borrow from the input. A downside of this is that some things may not be able to take advantage of it (e.g. System::register_system, though I don't see how it would work with GATs either).

Edit: quickly tried this and found a big problem: SystemParamFunction needs to contain the In parameter in order to avoid conflicting implementations, but in turn this makes it non-'static if the input is not 'static. This doesn't seem solvable unless the input is also abstracted in a way similar to how SystemParams are, which I guess is going to be very unergonomic.