Struct Opaque 

pub struct Opaque;

Marker occupying the Params position in step and handler traits to indicate that a closure manages its own resource access via world.resource::<T>() rather than through Param resolution.

Opaque is not a Param. It exists solely so the compiler can distinguish three disjoint impl tiers without coherence conflicts:

Params type	Function shape	Resolution
()	FnMut(E)	No resources needed
(P0,) … (P0..P7,)	fn(Res<A>, ResMut<B>, E)	Build-time Param::init, dispatch-time Param::fetch
Opaque	FnMut(&mut World, E)	None — caller owns all access

Because &mut World does not implement Param, the Opaque impls are always disjoint from the arity-based impls — the compiler infers Params unambiguously from the closure/function signature.

When to use

Prefer named functions with Param parameters — they resolve to a direct pointer dereference per resource (single deref, no HashMap lookup). Use Opaque closures as an escape hatch when:

• You need conditional resource access (different resources depending on runtime state).
• You need access to a resource whose type isn’t known at build time.
• You’re prototyping and want to defer the named-function refactor.

Example

// Named function — preferred, hot path:
pipeline.guard(check_risk, &reg)    // fn(Res<Config>, &Order) -> bool

// Arity-0 closure — no World access:
pipeline.guard(|o: &Order| o.price > 100.0, &reg)

// Opaque closure — escape hatch, HashMap lookups:
pipeline.guard(|w: &mut World, o: &Order| {
    let cfg = w.resource::<Config>();
    o.price > cfg.threshold
}, &reg)

Trait Implementations

impl<C, Out, F: FnMut(&mut C, &mut World) -> Out + 'static> IntoCtxProducer<C, Out, Opaque> for F

type Step = CtxOpaqueProducer<F>

The concrete resolved producer type.

fn into_ctx_producer(self, _registry: &Registry) -> Self::Step

Resolve Param state from the registry and produce a step.

impl<C, In, Out, F: FnMut(&mut C, &mut World, &In) -> Out + 'static> IntoCtxRefStep<C, In, Out, Opaque> for F

type Step = CtxOpaqueRefStep<F>

The concrete resolved step type.

fn into_ctx_ref_step(self, _registry: &Registry) -> Self::Step

Resolve Param state from the registry and produce a step.

impl<C, In, Out, F: FnMut(&mut C, &mut World, In) -> Out + 'static> IntoCtxStep<C, In, Out, Opaque> for F

type Step = CtxOpaqueStep<F>

The concrete resolved step type.

fn into_ctx_step(self, _registry: &Registry) -> Self::Step

Resolve Param state from the registry and produce a step.

impl<E, F: FnMut(&mut World, E) + Send + 'static> IntoHandler<E, Opaque> for F

type Handler = OpaqueHandler<F>

The concrete handler type produced.

fn into_handler(self, _registry: &Registry) -> Self::Handler

Convert this function into a handler, resolving parameters from the registry.

impl<Out, F: FnMut(&mut World) -> Out + 'static> IntoProducer<Out, Opaque> for F

type Step = OpaqueProducer<F>

The concrete resolved producer type.

fn into_producer(self, _registry: &Registry) -> Self::Step

Resolve Param state from the registry and produce a step.

impl<Acc, In, Out, F: FnMut(&mut World, &mut Acc, &In) -> Out + 'static> IntoRefScanStep<Acc, In, Out, Opaque> for F

type Step = OpaqueRefScanStep<F>

The concrete resolved ref-scan step type.

fn into_ref_scan_step(self, _registry: &Registry) -> Self::Step

Resolve Param state from the registry and produce a ref-scan step.

impl<In, Out, F: FnMut(&mut World, &In) -> Out + 'static> IntoRefStep<In, Out, Opaque> for F

type Step = OpaqueRefStep<F>

The concrete resolved step type.

fn into_ref_step(self, _registry: &Registry) -> Self::Step

Resolve Param state from the registry and produce a step.

impl<Acc, In, Out, F: FnMut(&mut World, &mut Acc, In) -> Out + 'static> IntoScanStep<Acc, In, Out, Opaque> for F

type Step = OpaqueScanStep<F>

The concrete resolved scan step type.

fn into_scan_step(self, _registry: &Registry) -> Self::Step

Resolve Param state from the registry and produce a scan step.

impl<In, Out, F: FnMut(&mut World, In) -> Out + 'static> IntoStep<In, Out, Opaque> for F

type Step = OpaqueStep<F>

The concrete resolved step type.

fn into_step(self, _registry: &Registry) -> Self::Step

Resolve Param state from the registry and produce a step.