Trait SystemParam 

pub trait SystemParam {
    type Item<'a>;
    type State: Default + 'static;

    // Required method
    fn fetch<'a>(
        state: &'a mut Self::State,
        world: &'a World,
        resources: &'a Resources,
    ) -> Self::Item<'a>;

    // Provided method
    fn requires() -> Vec<RequiredResource> { ... }
}

Trait implemented for each valid system parameter type.

The macro-generated [impl_system!] blanket implementations use this to fetch each parameter from the world and resources before calling the system function. State is per-system storage owned by the FunctionSystem itself (as opposed to Item, which only lives for the duration of one call) — this is what lets Local persist between runs.

Required Associated Types

type Item<'a>

type State: Default + 'static

Required Methods

fn fetch<'a>( state: &'a mut Self::State, world: &'a World, resources: &'a Resources, ) -> Self::Item<'a>

Provided Methods

fn requires() -> Vec<RequiredResource>

Resource types this parameter unconditionally needs present to avoid panicking. Used by App to validate — before running a non-convergent stage’s systems — that every hard requirement is already satisfied, failing fast with a clear message instead of panicking deep inside whichever system happens to run first.

Empty by default; only hard requirements (bare Res/ResMut) contribute an entry. Option<Res<T>>/Option<ResMut<T>> tolerate absence and deliberately opt out of this check.

Dyn Compatibility

This trait is not dyn compatible.

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

Implementations on Foreign Types

impl SystemParam for &'static World

type Item<'a> = &'a World

type State = ()

fn fetch<'a>( _state: &'a mut Self::State, world: &'a World, _resources: &'a Resources, ) -> Self::Item<'a>

impl<T> SystemParam for Option<AsyncEventWriter<'static, T>>

where T: Send + Sync + 'static,

Soft-access variant of AsyncEventWriter<T>: None instead of panicking while T isn’t registered via add_async_event (or BackgroundTasksPlugin isn’t installed yet). Useful for systems that only opportunistically spawn background work and shouldn’t hard-fail while the app is still assembling its plugins.

type Item<'a> = Option<AsyncEventWriter<'a, T>>

type State = ()

fn fetch<'a>( _state: &'a mut Self::State, world: &'a World, resources: &'a Resources, ) -> Self::Item<'a>

impl<T> SystemParam for Option<EventReader<'static, T>>

where T: Send + Sync + 'static,

Soft-access variant of EventReader<T>: None instead of panicking while T isn’t registered (via App::add_event), so a system that should just skip when an event type it optionally consumes hasn’t been set up yet doesn’t have to hard-depend on it. The read cursor still persists correctly across ticks once the event type does appear later — it lives in the same per-system State slot either way.

type Item<'a> = Option<EventReader<'a, T>>

type State = usize

fn fetch<'a>( state: &'a mut Self::State, world: &'a World, resources: &'a Resources, ) -> Self::Item<'a>

impl<T> SystemParam for Option<EventWriter<'static, T>>

where T: Send + Sync + 'static,

Soft-access variant of EventWriter<T>: None instead of panicking while T isn’t registered (via App::add_event).

type Item<'a> = Option<EventWriter<'a, T>>

type State = ()

fn fetch<'a>( _state: &'a mut Self::State, world: &'a World, resources: &'a Resources, ) -> Self::Item<'a>

impl<T> SystemParam for Option<Res<'static, T>>

where T: 'static + Sync + Send,

type Item<'a> = Option<Res<'a, T>>

type State = ()

fn fetch<'a>( _state: &'a mut Self::State, world: &'a World, resource: &'a Resources, ) -> Self::Item<'a>

impl<T> SystemParam for Option<ResMut<'static, T>>

where T: 'static + Sync + Send,

type Item<'a> = Option<ResMut<'a, T>>

type State = ()

fn fetch<'a>( _state: &'a mut Self::State, world: &'a World, resource: &'a Resources, ) -> Self::Item<'a>

Implementors

impl SystemParam for &'static Resources

type Item<'a> = &'a Resources

type State = ()

impl SystemParam for Commands<'static>

type Item<'a> = Commands<'a>

type State = ()

impl<Q> SystemParam for Query<'static, Q>

where Q: Query + 'static,

type Item<'a> = Query<'a, Q>

type State = ()

impl<T> SystemParam for AsyncEventWriter<'static, T>

where T: Send + Sync + 'static,

type Item<'a> = AsyncEventWriter<'a, T>

type State = ()

impl<T> SystemParam for EventReader<'static, T>

where T: Send + Sync + 'static,

type Item<'a> = EventReader<'a, T>

type State = usize

impl<T> SystemParam for EventWriter<'static, T>

where T: Send + Sync + 'static,

type Item<'a> = EventWriter<'a, T>

type State = ()

impl<T> SystemParam for Local<'static, T>

where T: Default + Send + Sync + 'static,

type Item<'a> = Local<'a, T>

type State = T

impl<T> SystemParam for Res<'static, T>

where T: 'static + Sync + Send,

type Item<'a> = Res<'a, T>

type State = ()

impl<T> SystemParam for ResMut<'static, T>

where T: 'static + Sync + Send,

type Item<'a> = ResMut<'a, T>

type State = ()