Trait bevy_ecs::IntoForEachSystem

pub trait IntoForEachSystem<CommandBuffer, R, C> {
    fn system(self) -> Box<dyn System>;
}

Converts Self into a For-Each system

Required methods

fn system(self) -> Box<dyn System>

Loading content...

Implementors

impl<Func, A> IntoForEachSystem<(Commands,), (), (A,)> for Func where
    Func: FnMut(Commands, A) + FnMut(Commands, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery, 

fn system(self) -> Box<dyn System>

impl<Func, A> IntoForEachSystem<(), (), (A,)> for Func where
    Func: FnMut(A) + FnMut(<<A as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery, 

fn system(self) -> Box<dyn System>

impl<Func, A, B> IntoForEachSystem<(Commands,), (), (A, B)> for Func where
    Func: FnMut(Commands, A, B) + FnMut(Commands, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery, 

fn system(self) -> Box<dyn System>

impl<Func, A, B> IntoForEachSystem<(), (), (A, B)> for Func where
    Func: FnMut(A, B) + FnMut(<<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery, 

fn system(self) -> Box<dyn System>

impl<Func, A, B, C> IntoForEachSystem<(Commands,), (), (A, B, C)> for Func where
    Func: FnMut(Commands, A, B, C) + FnMut(Commands, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery, 

fn system(self) -> Box<dyn System>

impl<Func, A, B, C> IntoForEachSystem<(), (), (A, B, C)> for Func where
    Func: FnMut(A, B, C) + FnMut(<<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery, 

fn system(self) -> Box<dyn System>

impl<Func, A, B, C, D> IntoForEachSystem<(Commands,), (), (A, B, C, D)> for Func where
    Func: FnMut(Commands, A, B, C, D) + FnMut(Commands, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery, 

fn system(self) -> Box<dyn System>

impl<Func, A, B, C, D> IntoForEachSystem<(), (), (A, B, C, D)> for Func where
    Func: FnMut(A, B, C, D) + FnMut(<<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery, 

fn system(self) -> Box<dyn System>

impl<Func, A, B, C, D, E> IntoForEachSystem<(Commands,), (), (A, B, C, D, E)> for Func where
    Func: FnMut(Commands, A, B, C, D, E) + FnMut(Commands, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery, 

fn system(self) -> Box<dyn System>

impl<Func, A, B, C, D, E> IntoForEachSystem<(), (), (A, B, C, D, E)> for Func where
    Func: FnMut(A, B, C, D, E) + FnMut(<<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery, 

fn system(self) -> Box<dyn System>

impl<Func, A, B, C, D, E, F> IntoForEachSystem<(Commands,), (), (A, B, C, D, E, F)> for Func where
    Func: FnMut(Commands, A, B, C, D, E, F) + FnMut(Commands, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery, 

fn system(self) -> Box<dyn System>

impl<Func, A, B, C, D, E, F> IntoForEachSystem<(), (), (A, B, C, D, E, F)> for Func where
    Func: FnMut(A, B, C, D, E, F) + FnMut(<<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery, 

fn system(self) -> Box<dyn System>

impl<Func, A, B, C, D, E, F, G> IntoForEachSystem<(Commands,), (), (A, B, C, D, E, F, G)> for Func where
    Func: FnMut(Commands, A, B, C, D, E, F, G) + FnMut(Commands, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item, <<G as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    G: HecsQuery, 

fn system(self) -> Box<dyn System>

impl<Func, A, B, C, D, E, F, G> IntoForEachSystem<(), (), (A, B, C, D, E, F, G)> for Func where
    Func: FnMut(A, B, C, D, E, F, G) + FnMut(<<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item, <<G as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    G: HecsQuery, 

fn system(self) -> Box<dyn System>

impl<Func, A, B, C, D, E, F, G, H> IntoForEachSystem<(Commands,), (), (A, B, C, D, E, F, G, H)> for Func where
    Func: FnMut(Commands, A, B, C, D, E, F, G, H) + FnMut(Commands, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item, <<G as HecsQuery>::Fetch as Fetch<'_>>::Item, <<H as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    G: HecsQuery,
    H: HecsQuery, 

fn system(self) -> Box<dyn System>

impl<Func, A, B, C, D, E, F, G, H> IntoForEachSystem<(), (), (A, B, C, D, E, F, G, H)> for Func where
    Func: FnMut(A, B, C, D, E, F, G, H) + FnMut(<<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item, <<G as HecsQuery>::Fetch as Fetch<'_>>::Item, <<H as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    G: HecsQuery,
    H: HecsQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, A> IntoForEachSystem<(Commands,), (Ra,), (A,)> for Func where
    Func: FnMut(Commands, Ra, A) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    Ra: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, A> IntoForEachSystem<(), (Ra,), (A,)> for Func where
    Func: FnMut(Ra, A) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    Ra: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, A, B> IntoForEachSystem<(Commands,), (Ra,), (A, B)> for Func where
    Func: FnMut(Commands, Ra, A, B) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    Ra: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, A, B> IntoForEachSystem<(), (Ra,), (A, B)> for Func where
    Func: FnMut(Ra, A, B) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    Ra: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, A, B, C> IntoForEachSystem<(Commands,), (Ra,), (A, B, C)> for Func where
    Func: FnMut(Commands, Ra, A, B, C) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    Ra: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, A, B, C> IntoForEachSystem<(), (Ra,), (A, B, C)> for Func where
    Func: FnMut(Ra, A, B, C) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    Ra: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, A, B, C, D> IntoForEachSystem<(Commands,), (Ra,), (A, B, C, D)> for Func where
    Func: FnMut(Commands, Ra, A, B, C, D) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    Ra: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, A, B, C, D> IntoForEachSystem<(), (Ra,), (A, B, C, D)> for Func where
    Func: FnMut(Ra, A, B, C, D) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    Ra: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, A, B, C, D, E> IntoForEachSystem<(Commands,), (Ra,), (A, B, C, D, E)> for Func where
    Func: FnMut(Commands, Ra, A, B, C, D, E) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    Ra: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, A, B, C, D, E> IntoForEachSystem<(), (Ra,), (A, B, C, D, E)> for Func where
    Func: FnMut(Ra, A, B, C, D, E) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    Ra: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, A, B, C, D, E, F> IntoForEachSystem<(Commands,), (Ra,), (A, B, C, D, E, F)> for Func where
    Func: FnMut(Commands, Ra, A, B, C, D, E, F) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    Ra: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, A, B, C, D, E, F> IntoForEachSystem<(), (Ra,), (A, B, C, D, E, F)> for Func where
    Func: FnMut(Ra, A, B, C, D, E, F) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    Ra: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, A, B, C, D, E, F, G> IntoForEachSystem<(Commands,), (Ra,), (A, B, C, D, E, F, G)> for Func where
    Func: FnMut(Commands, Ra, A, B, C, D, E, F, G) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item, <<G as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    G: HecsQuery,
    Ra: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, A, B, C, D, E, F, G> IntoForEachSystem<(), (Ra,), (A, B, C, D, E, F, G)> for Func where
    Func: FnMut(Ra, A, B, C, D, E, F, G) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item, <<G as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    G: HecsQuery,
    Ra: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, A, B, C, D, E, F, G, H> IntoForEachSystem<(Commands,), (Ra,), (A, B, C, D, E, F, G, H)> for Func where
    Func: FnMut(Commands, Ra, A, B, C, D, E, F, G, H) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item, <<G as HecsQuery>::Fetch as Fetch<'_>>::Item, <<H as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    G: HecsQuery,
    H: HecsQuery,
    Ra: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, A, B, C, D, E, F, G, H> IntoForEachSystem<(), (Ra,), (A, B, C, D, E, F, G, H)> for Func where
    Func: FnMut(Ra, A, B, C, D, E, F, G, H) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item, <<G as HecsQuery>::Fetch as Fetch<'_>>::Item, <<H as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    G: HecsQuery,
    H: HecsQuery,
    Ra: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, A> IntoForEachSystem<(Commands,), (Ra, Rb), (A,)> for Func where
    Func: FnMut(Commands, Ra, Rb, A) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, A> IntoForEachSystem<(), (Ra, Rb), (A,)> for Func where
    Func: FnMut(Ra, Rb, A) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, A, B> IntoForEachSystem<(Commands,), (Ra, Rb), (A, B)> for Func where
    Func: FnMut(Commands, Ra, Rb, A, B) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, A, B> IntoForEachSystem<(), (Ra, Rb), (A, B)> for Func where
    Func: FnMut(Ra, Rb, A, B) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, A, B, C> IntoForEachSystem<(Commands,), (Ra, Rb), (A, B, C)> for Func where
    Func: FnMut(Commands, Ra, Rb, A, B, C) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, A, B, C> IntoForEachSystem<(), (Ra, Rb), (A, B, C)> for Func where
    Func: FnMut(Ra, Rb, A, B, C) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, A, B, C, D> IntoForEachSystem<(Commands,), (Ra, Rb), (A, B, C, D)> for Func where
    Func: FnMut(Commands, Ra, Rb, A, B, C, D) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, A, B, C, D> IntoForEachSystem<(), (Ra, Rb), (A, B, C, D)> for Func where
    Func: FnMut(Ra, Rb, A, B, C, D) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, A, B, C, D, E> IntoForEachSystem<(Commands,), (Ra, Rb), (A, B, C, D, E)> for Func where
    Func: FnMut(Commands, Ra, Rb, A, B, C, D, E) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, A, B, C, D, E> IntoForEachSystem<(), (Ra, Rb), (A, B, C, D, E)> for Func where
    Func: FnMut(Ra, Rb, A, B, C, D, E) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, A, B, C, D, E, F> IntoForEachSystem<(Commands,), (Ra, Rb), (A, B, C, D, E, F)> for Func where
    Func: FnMut(Commands, Ra, Rb, A, B, C, D, E, F) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, A, B, C, D, E, F> IntoForEachSystem<(), (Ra, Rb), (A, B, C, D, E, F)> for Func where
    Func: FnMut(Ra, Rb, A, B, C, D, E, F) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, A, B, C, D, E, F, G> IntoForEachSystem<(Commands,), (Ra, Rb), (A, B, C, D, E, F, G)> for Func where
    Func: FnMut(Commands, Ra, Rb, A, B, C, D, E, F, G) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item, <<G as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    G: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, A, B, C, D, E, F, G> IntoForEachSystem<(), (Ra, Rb), (A, B, C, D, E, F, G)> for Func where
    Func: FnMut(Ra, Rb, A, B, C, D, E, F, G) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item, <<G as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    G: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, A, B, C, D, E, F, G, H> IntoForEachSystem<(Commands,), (Ra, Rb), (A, B, C, D, E, F, G, H)> for Func where
    Func: FnMut(Commands, Ra, Rb, A, B, C, D, E, F, G, H) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item, <<G as HecsQuery>::Fetch as Fetch<'_>>::Item, <<H as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    G: HecsQuery,
    H: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, A, B, C, D, E, F, G, H> IntoForEachSystem<(), (Ra, Rb), (A, B, C, D, E, F, G, H)> for Func where
    Func: FnMut(Ra, Rb, A, B, C, D, E, F, G, H) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item, <<G as HecsQuery>::Fetch as Fetch<'_>>::Item, <<H as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    G: HecsQuery,
    H: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, A> IntoForEachSystem<(Commands,), (Ra, Rb, Rc), (A,)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, A) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, A> IntoForEachSystem<(), (Ra, Rb, Rc), (A,)> for Func where
    Func: FnMut(Ra, Rb, Rc, A) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, A, B> IntoForEachSystem<(Commands,), (Ra, Rb, Rc), (A, B)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, A, B) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, A, B> IntoForEachSystem<(), (Ra, Rb, Rc), (A, B)> for Func where
    Func: FnMut(Ra, Rb, Rc, A, B) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, A, B, C> IntoForEachSystem<(Commands,), (Ra, Rb, Rc), (A, B, C)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, A, B, C) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, A, B, C> IntoForEachSystem<(), (Ra, Rb, Rc), (A, B, C)> for Func where
    Func: FnMut(Ra, Rb, Rc, A, B, C) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, A, B, C, D> IntoForEachSystem<(Commands,), (Ra, Rb, Rc), (A, B, C, D)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, A, B, C, D) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, A, B, C, D> IntoForEachSystem<(), (Ra, Rb, Rc), (A, B, C, D)> for Func where
    Func: FnMut(Ra, Rb, Rc, A, B, C, D) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, A, B, C, D, E> IntoForEachSystem<(Commands,), (Ra, Rb, Rc), (A, B, C, D, E)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, A, B, C, D, E) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, A, B, C, D, E> IntoForEachSystem<(), (Ra, Rb, Rc), (A, B, C, D, E)> for Func where
    Func: FnMut(Ra, Rb, Rc, A, B, C, D, E) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, A, B, C, D, E, F> IntoForEachSystem<(Commands,), (Ra, Rb, Rc), (A, B, C, D, E, F)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, A, B, C, D, E, F) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, A, B, C, D, E, F> IntoForEachSystem<(), (Ra, Rb, Rc), (A, B, C, D, E, F)> for Func where
    Func: FnMut(Ra, Rb, Rc, A, B, C, D, E, F) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, A, B, C, D, E, F, G> IntoForEachSystem<(Commands,), (Ra, Rb, Rc), (A, B, C, D, E, F, G)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, A, B, C, D, E, F, G) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item, <<G as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    G: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, A, B, C, D, E, F, G> IntoForEachSystem<(), (Ra, Rb, Rc), (A, B, C, D, E, F, G)> for Func where
    Func: FnMut(Ra, Rb, Rc, A, B, C, D, E, F, G) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item, <<G as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    G: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, A, B, C, D, E, F, G, H> IntoForEachSystem<(Commands,), (Ra, Rb, Rc), (A, B, C, D, E, F, G, H)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, A, B, C, D, E, F, G, H) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item, <<G as HecsQuery>::Fetch as Fetch<'_>>::Item, <<H as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    G: HecsQuery,
    H: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, A, B, C, D, E, F, G, H> IntoForEachSystem<(), (Ra, Rb, Rc), (A, B, C, D, E, F, G, H)> for Func where
    Func: FnMut(Ra, Rb, Rc, A, B, C, D, E, F, G, H) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item, <<G as HecsQuery>::Fetch as Fetch<'_>>::Item, <<H as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    G: HecsQuery,
    H: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, A> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd), (A,)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, A) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, A> IntoForEachSystem<(), (Ra, Rb, Rc, Rd), (A,)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, A) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, A, B> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd), (A, B)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, A, B) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, A, B> IntoForEachSystem<(), (Ra, Rb, Rc, Rd), (A, B)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, A, B) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, A, B, C> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd), (A, B, C)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, A, B, C) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, A, B, C> IntoForEachSystem<(), (Ra, Rb, Rc, Rd), (A, B, C)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, A, B, C) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, A, B, C, D> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd), (A, B, C, D)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, A, B, C, D) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, A, B, C, D> IntoForEachSystem<(), (Ra, Rb, Rc, Rd), (A, B, C, D)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, A, B, C, D) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, A, B, C, D, E> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd), (A, B, C, D, E)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, A, B, C, D, E) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, A, B, C, D, E> IntoForEachSystem<(), (Ra, Rb, Rc, Rd), (A, B, C, D, E)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, A, B, C, D, E) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, A, B, C, D, E, F> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd), (A, B, C, D, E, F)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, A, B, C, D, E, F) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, A, B, C, D, E, F> IntoForEachSystem<(), (Ra, Rb, Rc, Rd), (A, B, C, D, E, F)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, A, B, C, D, E, F) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, A, B, C, D, E, F, G> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd), (A, B, C, D, E, F, G)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, A, B, C, D, E, F, G) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item, <<G as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    G: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, A, B, C, D, E, F, G> IntoForEachSystem<(), (Ra, Rb, Rc, Rd), (A, B, C, D, E, F, G)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, A, B, C, D, E, F, G) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item, <<G as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    G: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, A, B, C, D, E, F, G, H> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd), (A, B, C, D, E, F, G, H)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, A, B, C, D, E, F, G, H) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item, <<G as HecsQuery>::Fetch as Fetch<'_>>::Item, <<H as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    G: HecsQuery,
    H: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, A, B, C, D, E, F, G, H> IntoForEachSystem<(), (Ra, Rb, Rc, Rd), (A, B, C, D, E, F, G, H)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, A, B, C, D, E, F, G, H) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item, <<G as HecsQuery>::Fetch as Fetch<'_>>::Item, <<H as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    G: HecsQuery,
    H: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, A> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re), (A,)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, A) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, A> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re), (A,)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, A) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, A, B> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re), (A, B)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, A, B) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, A, B> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re), (A, B)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, A, B) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, A, B, C> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re), (A, B, C)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, A, B, C) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, A, B, C> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re), (A, B, C)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, A, B, C) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, A, B, C, D> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re), (A, B, C, D)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, A, B, C, D) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, A, B, C, D> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re), (A, B, C, D)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, A, B, C, D) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, A, B, C, D, E> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re), (A, B, C, D, E)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, A, B, C, D, E) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, A, B, C, D, E> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re), (A, B, C, D, E)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, A, B, C, D, E) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, A, B, C, D, E, F> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re), (A, B, C, D, E, F)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, A, B, C, D, E, F) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, A, B, C, D, E, F> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re), (A, B, C, D, E, F)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, A, B, C, D, E, F) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, A, B, C, D, E, F, G> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re), (A, B, C, D, E, F, G)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, A, B, C, D, E, F, G) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item, <<G as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    G: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, A, B, C, D, E, F, G> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re), (A, B, C, D, E, F, G)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, A, B, C, D, E, F, G) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item, <<G as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    G: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, A, B, C, D, E, F, G, H> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re), (A, B, C, D, E, F, G, H)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, A, B, C, D, E, F, G, H) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item, <<G as HecsQuery>::Fetch as Fetch<'_>>::Item, <<H as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    G: HecsQuery,
    H: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, A, B, C, D, E, F, G, H> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re), (A, B, C, D, E, F, G, H)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, A, B, C, D, E, F, G, H) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item, <<G as HecsQuery>::Fetch as Fetch<'_>>::Item, <<H as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    G: HecsQuery,
    H: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, A> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf), (A,)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, A) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, A> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf), (A,)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, A) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, A, B> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf), (A, B)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, A, B) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, A, B> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf), (A, B)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, A, B) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, A, B, C> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf), (A, B, C)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, A, B, C) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, A, B, C> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf), (A, B, C)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, A, B, C) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, A, B, C, D> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf), (A, B, C, D)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, A, B, C, D) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, A, B, C, D> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf), (A, B, C, D)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, A, B, C, D) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, A, B, C, D, E> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf), (A, B, C, D, E)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, A, B, C, D, E) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, A, B, C, D, E> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf), (A, B, C, D, E)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, A, B, C, D, E) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, A, B, C, D, E, F> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf), (A, B, C, D, E, F)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, A, B, C, D, E, F) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, A, B, C, D, E, F> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf), (A, B, C, D, E, F)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, A, B, C, D, E, F) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, A, B, C, D, E, F, G> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf), (A, B, C, D, E, F, G)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, A, B, C, D, E, F, G) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item, <<G as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    G: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, A, B, C, D, E, F, G> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf), (A, B, C, D, E, F, G)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, A, B, C, D, E, F, G) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item, <<G as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    G: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, A, B, C, D, E, F, G, H> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf), (A, B, C, D, E, F, G, H)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, A, B, C, D, E, F, G, H) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item, <<G as HecsQuery>::Fetch as Fetch<'_>>::Item, <<H as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    G: HecsQuery,
    H: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, A, B, C, D, E, F, G, H> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf), (A, B, C, D, E, F, G, H)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, A, B, C, D, E, F, G, H) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item, <<G as HecsQuery>::Fetch as Fetch<'_>>::Item, <<H as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    G: HecsQuery,
    H: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, A> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg), (A,)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, A) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, A> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg), (A,)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, A) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, A, B> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg), (A, B)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, A, B) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, A, B> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg), (A, B)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, A, B) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, A, B, C> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg), (A, B, C)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, A, B, C) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, A, B, C> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg), (A, B, C)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, A, B, C) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, A, B, C, D> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg), (A, B, C, D)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, A, B, C, D) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, A, B, C, D> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg), (A, B, C, D)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, A, B, C, D) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, A, B, C, D, E> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg), (A, B, C, D, E)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, A, B, C, D, E) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, A, B, C, D, E> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg), (A, B, C, D, E)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, A, B, C, D, E) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, A, B, C, D, E, F> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg), (A, B, C, D, E, F)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, A, B, C, D, E, F) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, A, B, C, D, E, F> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg), (A, B, C, D, E, F)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, A, B, C, D, E, F) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, A, B, C, D, E, F, G> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg), (A, B, C, D, E, F, G)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, A, B, C, D, E, F, G) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item, <<G as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    G: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, A, B, C, D, E, F, G> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg), (A, B, C, D, E, F, G)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, A, B, C, D, E, F, G) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item, <<G as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    G: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, A, B, C, D, E, F, G, H> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg), (A, B, C, D, E, F, G, H)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, A, B, C, D, E, F, G, H) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item, <<G as HecsQuery>::Fetch as Fetch<'_>>::Item, <<H as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    G: HecsQuery,
    H: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, A, B, C, D, E, F, G, H> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg), (A, B, C, D, E, F, G, H)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, A, B, C, D, E, F, G, H) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item, <<G as HecsQuery>::Fetch as Fetch<'_>>::Item, <<H as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    G: HecsQuery,
    H: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh), (A,)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh), (A,)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A, B> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh), (A, B)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A, B) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A, B> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh), (A, B)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A, B) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A, B, C> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh), (A, B, C)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A, B, C) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A, B, C> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh), (A, B, C)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A, B, C) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A, B, C, D> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh), (A, B, C, D)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A, B, C, D) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A, B, C, D> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh), (A, B, C, D)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A, B, C, D) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A, B, C, D, E> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh), (A, B, C, D, E)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A, B, C, D, E) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A, B, C, D, E> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh), (A, B, C, D, E)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A, B, C, D, E) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A, B, C, D, E, F> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh), (A, B, C, D, E, F)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A, B, C, D, E, F) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A, B, C, D, E, F> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh), (A, B, C, D, E, F)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A, B, C, D, E, F) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A, B, C, D, E, F, G> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh), (A, B, C, D, E, F, G)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A, B, C, D, E, F, G) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item, <<G as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    G: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A, B, C, D, E, F, G> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh), (A, B, C, D, E, F, G)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A, B, C, D, E, F, G) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item, <<G as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    G: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A, B, C, D, E, F, G, H> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh), (A, B, C, D, E, F, G, H)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A, B, C, D, E, F, G, H) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item, <<G as HecsQuery>::Fetch as Fetch<'_>>::Item, <<H as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    G: HecsQuery,
    H: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A, B, C, D, E, F, G, H> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh), (A, B, C, D, E, F, G, H)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A, B, C, D, E, F, G, H) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item, <<G as HecsQuery>::Fetch as Fetch<'_>>::Item, <<H as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    G: HecsQuery,
    H: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, A> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri), (A,)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, A) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery,
    Ri: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, A> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri), (A,)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, A) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery,
    Ri: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, A, B> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri), (A, B)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, A, B) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery,
    Ri: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, A, B> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri), (A, B)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, A, B) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery,
    Ri: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, A, B, C> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri), (A, B, C)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, A, B, C) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery,
    Ri: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, A, B, C> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri), (A, B, C)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, A, B, C) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery,
    Ri: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, A, B, C, D> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri), (A, B, C, D)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, A, B, C, D) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery,
    Ri: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, A, B, C, D> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri), (A, B, C, D)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, A, B, C, D) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery,
    Ri: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, A, B, C, D, E> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri), (A, B, C, D, E)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, A, B, C, D, E) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery,
    Ri: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, A, B, C, D, E> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri), (A, B, C, D, E)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, A, B, C, D, E) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery,
    Ri: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, A, B, C, D, E, F> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri), (A, B, C, D, E, F)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, A, B, C, D, E, F) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery,
    Ri: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, A, B, C, D, E, F> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri), (A, B, C, D, E, F)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, A, B, C, D, E, F) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery,
    Ri: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, A, B, C, D, E, F, G> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri), (A, B, C, D, E, F, G)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, A, B, C, D, E, F, G) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item, <<G as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    G: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery,
    Ri: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, A, B, C, D, E, F, G> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri), (A, B, C, D, E, F, G)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, A, B, C, D, E, F, G) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item, <<G as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    G: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery,
    Ri: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, A, B, C, D, E, F, G, H> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri), (A, B, C, D, E, F, G, H)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, A, B, C, D, E, F, G, H) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item, <<G as HecsQuery>::Fetch as Fetch<'_>>::Item, <<H as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    G: HecsQuery,
    H: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery,
    Ri: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, A, B, C, D, E, F, G, H> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri), (A, B, C, D, E, F, G, H)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, A, B, C, D, E, F, G, H) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item, <<G as HecsQuery>::Fetch as Fetch<'_>>::Item, <<H as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    G: HecsQuery,
    H: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery,
    Ri: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, A> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj), (A,)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, A) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rj as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery,
    Ri: ResourceQuery,
    Rj: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, A> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj), (A,)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, A) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rj as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery,
    Ri: ResourceQuery,
    Rj: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, A, B> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj), (A, B)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, A, B) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rj as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery,
    Ri: ResourceQuery,
    Rj: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, A, B> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj), (A, B)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, A, B) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rj as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery,
    Ri: ResourceQuery,
    Rj: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, A, B, C> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj), (A, B, C)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, A, B, C) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rj as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery,
    Ri: ResourceQuery,
    Rj: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, A, B, C> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj), (A, B, C)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, A, B, C) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rj as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery,
    Ri: ResourceQuery,
    Rj: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, A, B, C, D> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj), (A, B, C, D)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, A, B, C, D) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rj as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery,
    Ri: ResourceQuery,
    Rj: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, A, B, C, D> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj), (A, B, C, D)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, A, B, C, D) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rj as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery,
    Ri: ResourceQuery,
    Rj: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, A, B, C, D, E> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj), (A, B, C, D, E)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, A, B, C, D, E) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rj as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery,
    Ri: ResourceQuery,
    Rj: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, A, B, C, D, E> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj), (A, B, C, D, E)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, A, B, C, D, E) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rj as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery,
    Ri: ResourceQuery,
    Rj: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, A, B, C, D, E, F> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj), (A, B, C, D, E, F)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, A, B, C, D, E, F) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rj as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery,
    Ri: ResourceQuery,
    Rj: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, A, B, C, D, E, F> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj), (A, B, C, D, E, F)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, A, B, C, D, E, F) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rj as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery,
    Ri: ResourceQuery,
    Rj: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, A, B, C, D, E, F, G> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj), (A, B, C, D, E, F, G)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, A, B, C, D, E, F, G) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rj as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item, <<G as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    G: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery,
    Ri: ResourceQuery,
    Rj: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, A, B, C, D, E, F, G> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj), (A, B, C, D, E, F, G)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, A, B, C, D, E, F, G) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rj as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item, <<G as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    G: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery,
    Ri: ResourceQuery,
    Rj: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, A, B, C, D, E, F, G, H> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj), (A, B, C, D, E, F, G, H)> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, A, B, C, D, E, F, G, H) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rj as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item, <<G as HecsQuery>::Fetch as Fetch<'_>>::Item, <<H as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    G: HecsQuery,
    H: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery,
    Ri: ResourceQuery,
    Rj: ResourceQuery, 

fn system(self) -> Box<dyn System>

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, A, B, C, D, E, F, G, H> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj), (A, B, C, D, E, F, G, H)> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri, Rj, A, B, C, D, E, F, G, H) + FnMut(<<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rj as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as HecsQuery>::Fetch as Fetch<'_>>::Item, <<B as HecsQuery>::Fetch as Fetch<'_>>::Item, <<C as HecsQuery>::Fetch as Fetch<'_>>::Item, <<D as HecsQuery>::Fetch as Fetch<'_>>::Item, <<E as HecsQuery>::Fetch as Fetch<'_>>::Item, <<F as HecsQuery>::Fetch as Fetch<'_>>::Item, <<G as HecsQuery>::Fetch as Fetch<'_>>::Item, <<H as HecsQuery>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    A: HecsQuery,
    B: HecsQuery,
    C: HecsQuery,
    D: HecsQuery,
    E: HecsQuery,
    F: HecsQuery,
    G: HecsQuery,
    H: HecsQuery,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery,
    Ri: ResourceQuery,
    Rj: ResourceQuery, 

fn system(self) -> Box<dyn System>

Loading content...