[][src]Trait bevy::prelude::IntoForEachSystem

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

Converts Self into a For-Each system

Required methods

fn system(self) -> Box<dyn System + 'static>

Loading content...

Implementors

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    Func: FnMut(Commands, Ra, A, B, C, D, E, F, G, H) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<A as Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item, <<F as Query>::Fetch as Fetch<'_>>::Item, <<G as Query>::Fetch as Fetch<'_>>::Item, <<H as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    G: Query,
    H: Query,
    Ra: ResourceQuery
[src]

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

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

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

impl<Func, Ra, Rb, A, B> IntoForEachSystem<(Commands,), (Ra, Rb), (A, B)> for Func where
    A: Query,
    B: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery
[src]

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

impl<Func, Ra, Rb, A, B, C> IntoForEachSystem<(Commands,), (Ra, Rb), (A, B, C)> for Func where
    A: Query,
    B: Query,
    C: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery
[src]

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

impl<Func, Ra, Rb, A, B, C, D> IntoForEachSystem<(Commands,), (Ra, Rb), (A, B, C, D)> for Func where
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery
[src]

impl<Func, Ra, Rb, A, B, C, D> IntoForEachSystem<(), (Ra, Rb), (A, B, C, D)> for Func where
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery
[src]

impl<Func, Ra, Rb, A, B, C, D, E> IntoForEachSystem<(Commands,), (Ra, Rb), (A, B, C, D, E)> for Func where
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery
[src]

impl<Func, Ra, Rb, A, B, C, D, E> IntoForEachSystem<(), (Ra, Rb), (A, B, C, D, E)> for Func where
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery
[src]

impl<Func, Ra, Rb, A, B, C, D, E, F> IntoForEachSystem<(Commands,), (Ra, Rb), (A, B, C, D, E, F)> for Func where
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item, <<F as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery
[src]

impl<Func, Ra, Rb, A, B, C, D, E, F> IntoForEachSystem<(), (Ra, Rb), (A, B, C, D, E, F)> for Func where
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item, <<F as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item, <<F as Query>::Fetch as Fetch<'_>>::Item, <<G as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    G: Query,
    Ra: ResourceQuery,
    Rb: ResourceQuery
[src]

impl<Func, Ra, Rb, A, B, C, D, E, F, G> IntoForEachSystem<(), (Ra, Rb), (A, B, C, D, E, F, G)> for Func where
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item, <<F as Query>::Fetch as Fetch<'_>>::Item, <<G as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    G: Query,
    Ra: ResourceQuery,
    Rb: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item, <<F as Query>::Fetch as Fetch<'_>>::Item, <<G as Query>::Fetch as Fetch<'_>>::Item, <<H as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    G: Query,
    H: Query,
    Ra: ResourceQuery,
    Rb: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item, <<F as Query>::Fetch as Fetch<'_>>::Item, <<G as Query>::Fetch as Fetch<'_>>::Item, <<H as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    G: Query,
    H: Query,
    Ra: ResourceQuery,
    Rb: ResourceQuery
[src]

impl<Func, Ra, Rb, Rc, A> IntoForEachSystem<(Commands,), (Ra, Rb, Rc), (A,)> for Func where
    A: Query,
    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 Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery
[src]

impl<Func, Ra, Rb, Rc, A> IntoForEachSystem<(), (Ra, Rb, Rc), (A,)> for Func where
    A: Query,
    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 Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery
[src]

impl<Func, Ra, Rb, Rc, A, B> IntoForEachSystem<(Commands,), (Ra, Rb, Rc), (A, B)> for Func where
    A: Query,
    B: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery
[src]

impl<Func, Ra, Rb, Rc, A, B> IntoForEachSystem<(), (Ra, Rb, Rc), (A, B)> for Func where
    A: Query,
    B: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery
[src]

impl<Func, Ra, Rb, Rc, A, B, C> IntoForEachSystem<(Commands,), (Ra, Rb, Rc), (A, B, C)> for Func where
    A: Query,
    B: Query,
    C: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery
[src]

impl<Func, Ra, Rb, Rc, A, B, C> IntoForEachSystem<(), (Ra, Rb, Rc), (A, B, C)> for Func where
    A: Query,
    B: Query,
    C: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery
[src]

impl<Func, Ra, Rb, Rc, A, B, C, D> IntoForEachSystem<(Commands,), (Ra, Rb, Rc), (A, B, C, D)> for Func where
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery
[src]

impl<Func, Ra, Rb, Rc, A, B, C, D> IntoForEachSystem<(), (Ra, Rb, Rc), (A, B, C, D)> for Func where
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery
[src]

impl<Func, Ra, Rb, Rc, A, B, C, D, E> IntoForEachSystem<(Commands,), (Ra, Rb, Rc), (A, B, C, D, E)> for Func where
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery
[src]

impl<Func, Ra, Rb, Rc, A, B, C, D, E> IntoForEachSystem<(), (Ra, Rb, Rc), (A, B, C, D, E)> for Func where
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item, <<F as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery
[src]

impl<Func, Ra, Rb, Rc, A, B, C, D, E, F> IntoForEachSystem<(), (Ra, Rb, Rc), (A, B, C, D, E, F)> for Func where
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item, <<F as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item, <<F as Query>::Fetch as Fetch<'_>>::Item, <<G as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    G: Query,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item, <<F as Query>::Fetch as Fetch<'_>>::Item, <<G as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    G: Query,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item, <<F as Query>::Fetch as Fetch<'_>>::Item, <<G as Query>::Fetch as Fetch<'_>>::Item, <<H as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    G: Query,
    H: Query,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item, <<F as Query>::Fetch as Fetch<'_>>::Item, <<G as Query>::Fetch as Fetch<'_>>::Item, <<H as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    G: Query,
    H: Query,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery
[src]

impl<Func, Ra, Rb, Rc, Rd, A> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd), (A,)> for Func where
    A: Query,
    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 Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery
[src]

impl<Func, Ra, Rb, Rc, Rd, A> IntoForEachSystem<(), (Ra, Rb, Rc, Rd), (A,)> for Func where
    A: Query,
    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 Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery
[src]

impl<Func, Ra, Rb, Rc, Rd, A, B> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd), (A, B)> for Func where
    A: Query,
    B: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery
[src]

impl<Func, Ra, Rb, Rc, Rd, A, B> IntoForEachSystem<(), (Ra, Rb, Rc, Rd), (A, B)> for Func where
    A: Query,
    B: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery
[src]

impl<Func, Ra, Rb, Rc, Rd, A, B, C> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd), (A, B, C)> for Func where
    A: Query,
    B: Query,
    C: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery
[src]

impl<Func, Ra, Rb, Rc, Rd, A, B, C> IntoForEachSystem<(), (Ra, Rb, Rc, Rd), (A, B, C)> for Func where
    A: Query,
    B: Query,
    C: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery
[src]

impl<Func, Ra, Rb, Rc, Rd, A, B, C, D> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd), (A, B, C, D)> for Func where
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery
[src]

impl<Func, Ra, Rb, Rc, Rd, A, B, C, D> IntoForEachSystem<(), (Ra, Rb, Rc, Rd), (A, B, C, D)> for Func where
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery
[src]

impl<Func, Ra, Rb, Rc, Rd, A, B, C, D, E> IntoForEachSystem<(), (Ra, Rb, Rc, Rd), (A, B, C, D, E)> for Func where
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item, <<F as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item, <<F as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item, <<F as Query>::Fetch as Fetch<'_>>::Item, <<G as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    G: Query,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item, <<F as Query>::Fetch as Fetch<'_>>::Item, <<G as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    G: Query,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item, <<F as Query>::Fetch as Fetch<'_>>::Item, <<G as Query>::Fetch as Fetch<'_>>::Item, <<H as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    G: Query,
    H: Query,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item, <<F as Query>::Fetch as Fetch<'_>>::Item, <<G as Query>::Fetch as Fetch<'_>>::Item, <<H as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    G: Query,
    H: Query,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery
[src]

impl<Func, Ra, Rb, Rc, Rd, Re, A> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re), (A,)> for Func where
    A: Query,
    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 Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery
[src]

impl<Func, Ra, Rb, Rc, Rd, Re, A> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re), (A,)> for Func where
    A: Query,
    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 Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery
[src]

impl<Func, Ra, Rb, Rc, Rd, Re, A, B> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re), (A, B)> for Func where
    A: Query,
    B: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery
[src]

impl<Func, Ra, Rb, Rc, Rd, Re, A, B> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re), (A, B)> for Func where
    A: Query,
    B: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery
[src]

impl<Func, Ra, Rb, Rc, Rd, Re, A, B, C> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re), (A, B, C)> for Func where
    A: Query,
    B: Query,
    C: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery
[src]

impl<Func, Ra, Rb, Rc, Rd, Re, A, B, C> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re), (A, B, C)> for Func where
    A: Query,
    B: Query,
    C: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery
[src]

impl<Func, Ra, Rb, Rc, Rd, Re, A, B, C, D> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re), (A, B, C, D)> for Func where
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item, <<F as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item, <<F as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item, <<F as Query>::Fetch as Fetch<'_>>::Item, <<G as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    G: Query,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item, <<F as Query>::Fetch as Fetch<'_>>::Item, <<G as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    G: Query,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item, <<F as Query>::Fetch as Fetch<'_>>::Item, <<G as Query>::Fetch as Fetch<'_>>::Item, <<H as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    G: Query,
    H: Query,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item, <<F as Query>::Fetch as Fetch<'_>>::Item, <<G as Query>::Fetch as Fetch<'_>>::Item, <<H as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    G: Query,
    H: Query,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery
[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, A> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf), (A,)> for Func where
    A: Query,
    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 Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery
[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, A> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf), (A,)> for Func where
    A: Query,
    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 Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery
[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, A, B> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf), (A, B)> for Func where
    A: Query,
    B: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery
[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, A, B> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf), (A, B)> for Func where
    A: Query,
    B: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery
[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, A, B, C> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf), (A, B, C)> for Func where
    A: Query,
    B: Query,
    C: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item, <<F as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item, <<F as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item, <<F as Query>::Fetch as Fetch<'_>>::Item, <<G as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    G: Query,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item, <<F as Query>::Fetch as Fetch<'_>>::Item, <<G as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    G: Query,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item, <<F as Query>::Fetch as Fetch<'_>>::Item, <<G as Query>::Fetch as Fetch<'_>>::Item, <<H as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    G: Query,
    H: Query,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item, <<F as Query>::Fetch as Fetch<'_>>::Item, <<G as Query>::Fetch as Fetch<'_>>::Item, <<H as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    G: Query,
    H: Query,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery
[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, A> IntoForEachSystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg), (A,)> for Func where
    A: Query,
    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 Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery
[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, A> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg), (A,)> for Func where
    A: Query,
    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 Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery
[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, A, B> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg), (A, B)> for Func where
    A: Query,
    B: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item, <<F as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item, <<F as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item, <<F as Query>::Fetch as Fetch<'_>>::Item, <<G as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    G: Query,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item, <<F as Query>::Fetch as Fetch<'_>>::Item, <<G as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    G: Query,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item, <<F as Query>::Fetch as Fetch<'_>>::Item, <<G as Query>::Fetch as Fetch<'_>>::Item, <<H as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    G: Query,
    H: Query,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item, <<F as Query>::Fetch as Fetch<'_>>::Item, <<G as Query>::Fetch as Fetch<'_>>::Item, <<H as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    G: Query,
    H: Query,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery
[src]

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
    A: Query,
    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 Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery
[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, A> IntoForEachSystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh), (A,)> for Func where
    A: Query,
    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 Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item, <<F as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item, <<F as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    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 Query>::Fetch as Fetch<'_>>::Item, <<B as Query>::Fetch as Fetch<'_>>::Item, <<C as Query>::Fetch as Fetch<'_>>::Item, <<D as Query>::Fetch as Fetch<'_>>::Item, <<E as Query>::Fetch as Fetch<'_>>::Item, <<F as Query>::Fetch as Fetch<'_>>::Item, <<G as Query>::Fetch as Fetch<'_>>::Item) + Send + Sync + 'static,
    G: Query,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery
[src]

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
    A: Query,
    B: Query,
    C: Query,
    D: Query,
    E: Query,
    F: Query,
    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</