Trait IntoSystem 

pub trait IntoSystem<Marker> {
    type System: System;

    // Required method
    fn into_system(self) -> Self::System;
}

Implemented for any function whose parameters are all SystemParams — this is what lets a plain fn my_system(time: Read<Time>) be passed directly to add_system.

Required Associated Types

type System: System

Required Methods

fn into_system(self) -> Self::System

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl<T, A, B, C, D, E, F, G, H, I, J, K, L> IntoSystem<(A, B, C, D, E, F, G, H, I, J, K, L)> for T

where T: FnMut(A, B, C, D, E, F, G, H, I, J, K, L) + for<'a> FnMut(A::Item<'a>, B::Item<'a>, C::Item<'a>, D::Item<'a>, E::Item<'a>, F::Item<'a>, G::Item<'a>, H::Item<'a>, I::Item<'a>, J::Item<'a>, K::Item<'a>, L::Item<'a>) + 'static, A: SystemParam + 'static, B: SystemParam + 'static, C: SystemParam + 'static, D: SystemParam + 'static, E: SystemParam + 'static, F: SystemParam + 'static, G: SystemParam + 'static, H: SystemParam + 'static, I: SystemParam + 'static, J: SystemParam + 'static, K: SystemParam + 'static, L: SystemParam + 'static,

type System = FunctionSystem<T, (A, B, C, D, E, F, G, H, I, J, K, L), (<A as SystemParam>::State, <B as SystemParam>::State, <C as SystemParam>::State, <D as SystemParam>::State, <E as SystemParam>::State, <F as SystemParam>::State, <G as SystemParam>::State, <H as SystemParam>::State, <I as SystemParam>::State, <J as SystemParam>::State, <K as SystemParam>::State, <L as SystemParam>::State)>

impl<T, A, B, C, D, E, F, G, H, I, J, K> IntoSystem<(A, B, C, D, E, F, G, H, I, J, K)> for T

where T: FnMut(A, B, C, D, E, F, G, H, I, J, K) + for<'a> FnMut(A::Item<'a>, B::Item<'a>, C::Item<'a>, D::Item<'a>, E::Item<'a>, F::Item<'a>, G::Item<'a>, H::Item<'a>, I::Item<'a>, J::Item<'a>, K::Item<'a>) + 'static, A: SystemParam + 'static, B: SystemParam + 'static, C: SystemParam + 'static, D: SystemParam + 'static, E: SystemParam + 'static, F: SystemParam + 'static, G: SystemParam + 'static, H: SystemParam + 'static, I: SystemParam + 'static, J: SystemParam + 'static, K: SystemParam + 'static,

type System = FunctionSystem<T, (A, B, C, D, E, F, G, H, I, J, K), (<A as SystemParam>::State, <B as SystemParam>::State, <C as SystemParam>::State, <D as SystemParam>::State, <E as SystemParam>::State, <F as SystemParam>::State, <G as SystemParam>::State, <H as SystemParam>::State, <I as SystemParam>::State, <J as SystemParam>::State, <K as SystemParam>::State)>

impl<T, A, B, C, D, E, F, G, H, I, J> IntoSystem<(A, B, C, D, E, F, G, H, I, J)> for T

where T: FnMut(A, B, C, D, E, F, G, H, I, J) + for<'a> FnMut(A::Item<'a>, B::Item<'a>, C::Item<'a>, D::Item<'a>, E::Item<'a>, F::Item<'a>, G::Item<'a>, H::Item<'a>, I::Item<'a>, J::Item<'a>) + 'static, A: SystemParam + 'static, B: SystemParam + 'static, C: SystemParam + 'static, D: SystemParam + 'static, E: SystemParam + 'static, F: SystemParam + 'static, G: SystemParam + 'static, H: SystemParam + 'static, I: SystemParam + 'static, J: SystemParam + 'static,

type System = FunctionSystem<T, (A, B, C, D, E, F, G, H, I, J), (<A as SystemParam>::State, <B as SystemParam>::State, <C as SystemParam>::State, <D as SystemParam>::State, <E as SystemParam>::State, <F as SystemParam>::State, <G as SystemParam>::State, <H as SystemParam>::State, <I as SystemParam>::State, <J as SystemParam>::State)>

impl<T, A, B, C, D, E, F, G, H, I> IntoSystem<(A, B, C, D, E, F, G, H, I)> for T

where T: FnMut(A, B, C, D, E, F, G, H, I) + for<'a> FnMut(A::Item<'a>, B::Item<'a>, C::Item<'a>, D::Item<'a>, E::Item<'a>, F::Item<'a>, G::Item<'a>, H::Item<'a>, I::Item<'a>) + 'static, A: SystemParam + 'static, B: SystemParam + 'static, C: SystemParam + 'static, D: SystemParam + 'static, E: SystemParam + 'static, F: SystemParam + 'static, G: SystemParam + 'static, H: SystemParam + 'static, I: SystemParam + 'static,

type System = FunctionSystem<T, (A, B, C, D, E, F, G, H, I), (<A as SystemParam>::State, <B as SystemParam>::State, <C as SystemParam>::State, <D as SystemParam>::State, <E as SystemParam>::State, <F as SystemParam>::State, <G as SystemParam>::State, <H as SystemParam>::State, <I as SystemParam>::State)>

impl<T, A, B, C, D, E, F, G, H> IntoSystem<(A, B, C, D, E, F, G, H)> for T

where T: FnMut(A, B, C, D, E, F, G, H) + for<'a> FnMut(A::Item<'a>, B::Item<'a>, C::Item<'a>, D::Item<'a>, E::Item<'a>, F::Item<'a>, G::Item<'a>, H::Item<'a>) + 'static, A: SystemParam + 'static, B: SystemParam + 'static, C: SystemParam + 'static, D: SystemParam + 'static, E: SystemParam + 'static, F: SystemParam + 'static, G: SystemParam + 'static, H: SystemParam + 'static,

type System = FunctionSystem<T, (A, B, C, D, E, F, G, H), (<A as SystemParam>::State, <B as SystemParam>::State, <C as SystemParam>::State, <D as SystemParam>::State, <E as SystemParam>::State, <F as SystemParam>::State, <G as SystemParam>::State, <H as SystemParam>::State)>

impl<T, A, B, C, D, E, F, G> IntoSystem<(A, B, C, D, E, F, G)> for T

where T: FnMut(A, B, C, D, E, F, G) + for<'a> FnMut(A::Item<'a>, B::Item<'a>, C::Item<'a>, D::Item<'a>, E::Item<'a>, F::Item<'a>, G::Item<'a>) + 'static, A: SystemParam + 'static, B: SystemParam + 'static, C: SystemParam + 'static, D: SystemParam + 'static, E: SystemParam + 'static, F: SystemParam + 'static, G: SystemParam + 'static,

type System = FunctionSystem<T, (A, B, C, D, E, F, G), (<A as SystemParam>::State, <B as SystemParam>::State, <C as SystemParam>::State, <D as SystemParam>::State, <E as SystemParam>::State, <F as SystemParam>::State, <G as SystemParam>::State)>

impl<T, A, B, C, D, E, F> IntoSystem<(A, B, C, D, E, F)> for T

where T: FnMut(A, B, C, D, E, F) + for<'a> FnMut(A::Item<'a>, B::Item<'a>, C::Item<'a>, D::Item<'a>, E::Item<'a>, F::Item<'a>) + 'static, A: SystemParam + 'static, B: SystemParam + 'static, C: SystemParam + 'static, D: SystemParam + 'static, E: SystemParam + 'static, F: SystemParam + 'static,

type System = FunctionSystem<T, (A, B, C, D, E, F), (<A as SystemParam>::State, <B as SystemParam>::State, <C as SystemParam>::State, <D as SystemParam>::State, <E as SystemParam>::State, <F as SystemParam>::State)>

impl<T, A, B, C, D, E> IntoSystem<(A, B, C, D, E)> for T

where T: FnMut(A, B, C, D, E) + for<'a> FnMut(A::Item<'a>, B::Item<'a>, C::Item<'a>, D::Item<'a>, E::Item<'a>) + 'static, A: SystemParam + 'static, B: SystemParam + 'static, C: SystemParam + 'static, D: SystemParam + 'static, E: SystemParam + 'static,

type System = FunctionSystem<T, (A, B, C, D, E), (<A as SystemParam>::State, <B as SystemParam>::State, <C as SystemParam>::State, <D as SystemParam>::State, <E as SystemParam>::State)>

impl<T, A, B, C, D> IntoSystem<(A, B, C, D)> for T

where T: FnMut(A, B, C, D) + for<'a> FnMut(A::Item<'a>, B::Item<'a>, C::Item<'a>, D::Item<'a>) + 'static, A: SystemParam + 'static, B: SystemParam + 'static, C: SystemParam + 'static, D: SystemParam + 'static,

type System = FunctionSystem<T, (A, B, C, D), (<A as SystemParam>::State, <B as SystemParam>::State, <C as SystemParam>::State, <D as SystemParam>::State)>

impl<T, A, B, C> IntoSystem<(A, B, C)> for T

where T: FnMut(A, B, C) + for<'a> FnMut(A::Item<'a>, B::Item<'a>, C::Item<'a>) + 'static, A: SystemParam + 'static, B: SystemParam + 'static, C: SystemParam + 'static,

type System = FunctionSystem<T, (A, B, C), (<A as SystemParam>::State, <B as SystemParam>::State, <C as SystemParam>::State)>

impl<T, A, B> IntoSystem<(A, B)> for T

where T: FnMut(A, B) + for<'a> FnMut(A::Item<'a>, B::Item<'a>) + 'static, A: SystemParam + 'static, B: SystemParam + 'static,

type System = FunctionSystem<T, (A, B), (<A as SystemParam>::State, <B as SystemParam>::State)>

impl<T, A> IntoSystem<(A,)> for T

where T: FnMut(A) + for<'a> FnMut(A::Item<'a>) + 'static, A: SystemParam + 'static,

type System = FunctionSystem<T, (A,), (<A as SystemParam>::State,)>

impl<T> IntoSystem<()> for T

where T: FnMut() + for<'a> FnMut() + 'static,

type System = FunctionSystem<T, ()>