[][src]Trait bevy::prelude::IntoQuerySystem

pub trait IntoQuerySystem<Commands, R, Q> {
    fn system(self) -> Box<dyn System + 'static>;
}

Converts Self into a Query System

Required methods

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

Loading content...

Implementors

impl<Func> IntoQuerySystem<(Commands,), (), ()> for Func where
    Func: FnMut(Commands) + Send + Sync + 'static, 
[src]

impl<Func> IntoQuerySystem<(), (), ()> for Func where
    Func: FnMut() + Send + Sync + 'static, 
[src]

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

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

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

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

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

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

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

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

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

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

impl<Func, A, B, C, D, E, F> IntoQuerySystem<(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, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + Send + Sync + 'static, 
[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<Func, Ra, Rb, Rc, Rd> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd), ()> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd) + 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) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery
[src]

impl<Func, Ra, Rb, Rc, Rd> IntoQuerySystem<(), (Ra, Rb, Rc, Rd), ()> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd) + 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) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery
[src]

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

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

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

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

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

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

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

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

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

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

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

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

impl<Func, Ra, Rb, Rc, Rd, Re> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re), ()> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re) + 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) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery
[src]

impl<Func, Ra, Rb, Rc, Rd, Re> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re), ()> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re) + 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) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery
[src]

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

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

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

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

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

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

impl<Func, Ra, Rb, Rc, Rd, Re, Rf> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf), ()> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf) + 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) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery
[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re, Rf), ()> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf) + 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) + 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> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf), (A,)> for Func where
    A: Query,
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Query<'_, 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, Query<'_, A>) + 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> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re, Rf), (A,)> for Func where
    A: Query,
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Query<'_, 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, Query<'_, A>) + 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> IntoQuerySystem<(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, Query<'_, A>, Query<'_, 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, Query<'_, A>, Query<'_, B>) + 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> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re, Rf), (A, B)> for Func where
    A: Query,
    B: Query,
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Query<'_, A>, Query<'_, 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, Query<'_, A>, Query<'_, B>) + 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> IntoQuerySystem<(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, Query<'_, A>, Query<'_, B>, Query<'_, 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, Query<'_, A>, Query<'_, B>, Query<'_, C>) + 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> IntoQuerySystem<(), (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, Query<'_, A>, Query<'_, B>, Query<'_, 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, Query<'_, A>, Query<'_, B>, Query<'_, C>) + 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> IntoQuerySystem<(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, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, 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, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + 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> IntoQuerySystem<(), (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, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, 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, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + 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> IntoQuerySystem<(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, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, 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, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + 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> IntoQuerySystem<(), (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, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, 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, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + 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> IntoQuerySystem<(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, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, 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, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + 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> IntoQuerySystem<(), (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, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, 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, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery
[src]

impl<Func, Ra, Rb, Rc, Rd, Re, Rf, Rg> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg), ()> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg) + 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) + 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> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg), ()> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg) + 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) + 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> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg), (A,)> for Func where
    A: Query,
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Query<'_, 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, Query<'_, A>) + 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> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg), (A,)> for Func where
    A: Query,
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Query<'_, 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, Query<'_, A>) + 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> IntoQuerySystem<(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, Query<'_, A>, Query<'_, 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, Query<'_, A>, Query<'_, B>) + 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> IntoQuerySystem<(), (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, Query<'_, A>, Query<'_, 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, Query<'_, A>, Query<'_, B>) + 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> IntoQuerySystem<(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, Query<'_, A>, Query<'_, B>, Query<'_, 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, Query<'_, A>, Query<'_, B>, Query<'_, C>) + 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> IntoQuerySystem<(), (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, Query<'_, A>, Query<'_, B>, Query<'_, 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, Query<'_, A>, Query<'_, B>, Query<'_, C>) + 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> IntoQuerySystem<(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, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, 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, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + 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> IntoQuerySystem<(), (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, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, 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, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + 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> IntoQuerySystem<(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, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, 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, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + 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> IntoQuerySystem<(), (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, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, 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, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + 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> IntoQuerySystem<(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, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, 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, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + 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> IntoQuerySystem<(), (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, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, 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, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + 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, Rh> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh), ()> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh) + 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) + 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> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh), ()> for Func where
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh) + 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) + 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> IntoQuerySystem<(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, Query<'_, 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, Query<'_, A>) + 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> IntoQuerySystem<(), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh), (A,)> for Func where
    A: Query,
    Func: FnMut(Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Query<'_, 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, Query<'_, A>) + 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> IntoQuerySystem<(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, Query<'_, A>, Query<'_, 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, Query<'_, A>, Query<'_, B>) + 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> IntoQuerySystem<(), (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, Query<'_, A>, Query<'_, 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, Query<'_, A>, Query<'_, B>) + 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> IntoQuerySystem<(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, Query<'_, A>, Query<'_, B>, Query<'_, 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, Query<'_, A>, Query<'_, B>, Query<'_, C>) + 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> IntoQuerySystem<(), (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, Query<'_, A>, Query<'_, B>, Query<'_, 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, Query<'_, A>, Query<'_, B>, Query<'_, C>) + 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> IntoQuerySystem<(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, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, 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, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + 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> IntoQuerySystem<(), (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, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, 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, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>) + 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> IntoQuerySystem<(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, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, 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, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + 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> IntoQuerySystem<(), (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, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, 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, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>) + 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> IntoQuerySystem<(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, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, 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, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + 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> IntoQuerySystem<(), (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, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, 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, Query<'_, A>, Query<'_, B>, Query<'_, C>, Query<'_, D>, Query<'_, E>, Query<'_, F>) + 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, Ri> IntoQuerySystem<(Commands,), (Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri), ()> for Func where
    Func: FnMut(Commands, Ra, Rb, Rc, Rd, Re, Rf, Rg, Rh, Ri) + FnMut(Commands, <<Ra as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rb as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rc as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rd as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Re as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rf as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rg as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Rh as ResourceQuery>::Fetch as FetchResource<'_>>::Item, <<Ri as ResourceQuery>::Fetch as FetchResource<'_>>::Item) + Send + Sync + 'static,
    Ra: ResourceQuery,
    Rb: ResourceQuery,
    Rc: ResourceQuery,
    Rd: ResourceQuery,
    Re: ResourceQuery,
    Rf: ResourceQuery,
    Rg: ResourceQuery,
    Rh: ResourceQuery,
    Ri: ResourceQuery
[src]

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

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

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

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