Struct NoEvent 

pub struct NoEvent<F>(/* private fields */);

Wrapper that marks a function as taking no event parameter.

Used in the F position of Callback and Step to add Handler<()> / StepCall<()> impls that don’t pass () to the user function. Same coherence trick as [CtxFree]: NoEvent<F> is a plain struct and never satisfies FnMut, so the new impls are provably disjoint from the existing ones.

For arity-0 functions (fn() with no parameters), the compiler can distinguish FnMut() from FnMut(()) and picks the no-event impl automatically. For arities 1+, wrap the function with no_event() to disambiguate from the event-taking impls:

// Arity 0 — works directly:
fn standalone() { }
let h = standalone.into_handler(reg);

// Arities 1+ — wrap with no_event():
fn tick(mut counter: ResMut<Counter>) { counter.0 += 1; }
let h = no_event(tick).into_handler(reg);

Trait Implementations

impl<C: Send + 'static, F: Send + 'static, P0: Param + 'static> IntoCallback<C, (), (P0,)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(&mut C, P0) + FnMut(&mut C, P0::Item<'a>),

type Callback = Callback<C, NoEvent<F>, (P0,)>

The concrete Callback type produced.

fn into_callback(self, ctx: C, registry: &Registry) -> Self::Callback

Convert this function + context into a Callback.

impl<C: Send + 'static, F: Send + 'static, P0: Param + 'static, P1: Param + 'static> IntoCallback<C, (), (P0, P1)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(&mut C, P0, P1) + FnMut(&mut C, P0::Item<'a>, P1::Item<'a>),

type Callback = Callback<C, NoEvent<F>, (P0, P1)>

The concrete Callback type produced.

fn into_callback(self, ctx: C, registry: &Registry) -> Self::Callback

Convert this function + context into a Callback.

impl<C: Send + 'static, F: Send + 'static, P0: Param + 'static, P1: Param + 'static, P2: Param + 'static> IntoCallback<C, (), (P0, P1, P2)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(&mut C, P0, P1, P2) + FnMut(&mut C, P0::Item<'a>, P1::Item<'a>, P2::Item<'a>),

type Callback = Callback<C, NoEvent<F>, (P0, P1, P2)>

The concrete Callback type produced.

fn into_callback(self, ctx: C, registry: &Registry) -> Self::Callback

Convert this function + context into a Callback.

impl<C: Send + 'static, F: Send + 'static, P0: Param + 'static, P1: Param + 'static, P2: Param + 'static, P3: Param + 'static> IntoCallback<C, (), (P0, P1, P2, P3)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(&mut C, P0, P1, P2, P3) + FnMut(&mut C, P0::Item<'a>, P1::Item<'a>, P2::Item<'a>, P3::Item<'a>),

type Callback = Callback<C, NoEvent<F>, (P0, P1, P2, P3)>

The concrete Callback type produced.

fn into_callback(self, ctx: C, registry: &Registry) -> Self::Callback

Convert this function + context into a Callback.

impl<C: Send + 'static, F: Send + 'static, P0: Param + 'static, P1: Param + 'static, P2: Param + 'static, P3: Param + 'static, P4: Param + 'static> IntoCallback<C, (), (P0, P1, P2, P3, P4)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(&mut C, P0, P1, P2, P3, P4) + FnMut(&mut C, P0::Item<'a>, P1::Item<'a>, P2::Item<'a>, P3::Item<'a>, P4::Item<'a>),

type Callback = Callback<C, NoEvent<F>, (P0, P1, P2, P3, P4)>

The concrete Callback type produced.

fn into_callback(self, ctx: C, registry: &Registry) -> Self::Callback

Convert this function + context into a Callback.

impl<C: Send + 'static, F: Send + 'static, P0: Param + 'static, P1: Param + 'static, P2: Param + 'static, P3: Param + 'static, P4: Param + 'static, P5: Param + 'static> IntoCallback<C, (), (P0, P1, P2, P3, P4, P5)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(&mut C, P0, P1, P2, P3, P4, P5) + FnMut(&mut C, P0::Item<'a>, P1::Item<'a>, P2::Item<'a>, P3::Item<'a>, P4::Item<'a>, P5::Item<'a>),

type Callback = Callback<C, NoEvent<F>, (P0, P1, P2, P3, P4, P5)>

The concrete Callback type produced.

fn into_callback(self, ctx: C, registry: &Registry) -> Self::Callback

Convert this function + context into a Callback.

impl<C: Send + 'static, F: Send + 'static, P0: Param + 'static, P1: Param + 'static, P2: Param + 'static, P3: Param + 'static, P4: Param + 'static, P5: Param + 'static, P6: Param + 'static> IntoCallback<C, (), (P0, P1, P2, P3, P4, P5, P6)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(&mut C, P0, P1, P2, P3, P4, P5, P6) + FnMut(&mut C, P0::Item<'a>, P1::Item<'a>, P2::Item<'a>, P3::Item<'a>, P4::Item<'a>, P5::Item<'a>, P6::Item<'a>),

type Callback = Callback<C, NoEvent<F>, (P0, P1, P2, P3, P4, P5, P6)>

The concrete Callback type produced.

fn into_callback(self, ctx: C, registry: &Registry) -> Self::Callback

Convert this function + context into a Callback.

impl<C: Send + 'static, F: Send + 'static, P0: Param + 'static, P1: Param + 'static, P2: Param + 'static, P3: Param + 'static, P4: Param + 'static, P5: Param + 'static, P6: Param + 'static, P7: Param + 'static> IntoCallback<C, (), (P0, P1, P2, P3, P4, P5, P6, P7)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(&mut C, P0, P1, P2, P3, P4, P5, P6, P7) + FnMut(&mut C, P0::Item<'a>, P1::Item<'a>, P2::Item<'a>, P3::Item<'a>, P4::Item<'a>, P5::Item<'a>, P6::Item<'a>, P7::Item<'a>),

type Callback = Callback<C, NoEvent<F>, (P0, P1, P2, P3, P4, P5, P6, P7)>

The concrete Callback type produced.

fn into_callback(self, ctx: C, registry: &Registry) -> Self::Callback

Convert this function + context into a Callback.

impl<C: Send + 'static, F: FnMut(&mut C) + Send + 'static> IntoCallback<C, (), NoEvent<F>> for F

type Callback = Callback<C, NoEvent<F>, ()>

The concrete Callback type produced.

fn into_callback(self, ctx: C, registry: &Registry) -> Self::Callback

Convert this function + context into a Callback.

impl<C, Out, F: 'static, P0: Param + 'static> IntoCtxStep<C, (), Out, (P0,)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(&mut C, P0) -> Out + FnMut(&mut C, P0::Item<'a>) -> Out,

type Step = CtxStep<NoEvent<F>, (P0,)>

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<C, Out, F: 'static, P0: Param + 'static, P1: Param + 'static> IntoCtxStep<C, (), Out, (P0, P1)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(&mut C, P0, P1) -> Out + FnMut(&mut C, P0::Item<'a>, P1::Item<'a>) -> Out,

type Step = CtxStep<NoEvent<F>, (P0, P1)>

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<C, Out, F: 'static, P0: Param + 'static, P1: Param + 'static, P2: Param + 'static> IntoCtxStep<C, (), Out, (P0, P1, P2)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(&mut C, P0, P1, P2) -> Out + FnMut(&mut C, P0::Item<'a>, P1::Item<'a>, P2::Item<'a>) -> Out,

type Step = CtxStep<NoEvent<F>, (P0, P1, P2)>

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<C, Out, F: 'static, P0: Param + 'static, P1: Param + 'static, P2: Param + 'static, P3: Param + 'static> IntoCtxStep<C, (), Out, (P0, P1, P2, P3)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(&mut C, P0, P1, P2, P3) -> Out + FnMut(&mut C, P0::Item<'a>, P1::Item<'a>, P2::Item<'a>, P3::Item<'a>) -> Out,

type Step = CtxStep<NoEvent<F>, (P0, P1, P2, P3)>

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<C, Out, F: 'static, P0: Param + 'static, P1: Param + 'static, P2: Param + 'static, P3: Param + 'static, P4: Param + 'static> IntoCtxStep<C, (), Out, (P0, P1, P2, P3, P4)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(&mut C, P0, P1, P2, P3, P4) -> Out + FnMut(&mut C, P0::Item<'a>, P1::Item<'a>, P2::Item<'a>, P3::Item<'a>, P4::Item<'a>) -> Out,

type Step = CtxStep<NoEvent<F>, (P0, P1, P2, P3, P4)>

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<C, Out, F: 'static, P0: Param + 'static, P1: Param + 'static, P2: Param + 'static, P3: Param + 'static, P4: Param + 'static, P5: Param + 'static> IntoCtxStep<C, (), Out, (P0, P1, P2, P3, P4, P5)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(&mut C, P0, P1, P2, P3, P4, P5) -> Out + FnMut(&mut C, P0::Item<'a>, P1::Item<'a>, P2::Item<'a>, P3::Item<'a>, P4::Item<'a>, P5::Item<'a>) -> Out,

type Step = CtxStep<NoEvent<F>, (P0, P1, P2, P3, P4, P5)>

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<C, Out, F: 'static, P0: Param + 'static, P1: Param + 'static, P2: Param + 'static, P3: Param + 'static, P4: Param + 'static, P5: Param + 'static, P6: Param + 'static> IntoCtxStep<C, (), Out, (P0, P1, P2, P3, P4, P5, P6)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(&mut C, P0, P1, P2, P3, P4, P5, P6) -> Out + FnMut(&mut C, P0::Item<'a>, P1::Item<'a>, P2::Item<'a>, P3::Item<'a>, P4::Item<'a>, P5::Item<'a>, P6::Item<'a>) -> Out,

type Step = CtxStep<NoEvent<F>, (P0, P1, P2, P3, P4, P5, P6)>

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<C, Out, F: 'static, P0: Param + 'static, P1: Param + 'static, P2: Param + 'static, P3: Param + 'static, P4: Param + 'static, P5: Param + 'static, P6: Param + 'static, P7: Param + 'static> IntoCtxStep<C, (), Out, (P0, P1, P2, P3, P4, P5, P6, P7)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(&mut C, P0, P1, P2, P3, P4, P5, P6, P7) -> Out + FnMut(&mut C, P0::Item<'a>, P1::Item<'a>, P2::Item<'a>, P3::Item<'a>, P4::Item<'a>, P5::Item<'a>, P6::Item<'a>, P7::Item<'a>) -> Out,

type Step = CtxStep<NoEvent<F>, (P0, P1, P2, P3, P4, P5, P6, P7)>

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<C, Out, F: FnMut(&mut C) -> Out + 'static> IntoCtxStep<C, (), Out, NoEvent<F>> for F

type Step = CtxStep<NoEvent<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<F: Send + 'static, P0: Param + 'static> IntoHandler<(), (P0,)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(P0) + FnMut(P0::Item<'a>),

type Handler = Callback<(), CtxFree<NoEvent<F>>, (P0,)>

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<F: Send + 'static, P0: Param + 'static, P1: Param + 'static> IntoHandler<(), (P0, P1)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(P0, P1) + FnMut(P0::Item<'a>, P1::Item<'a>),

type Handler = Callback<(), CtxFree<NoEvent<F>>, (P0, P1)>

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<F: Send + 'static, P0: Param + 'static, P1: Param + 'static, P2: Param + 'static> IntoHandler<(), (P0, P1, P2)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(P0, P1, P2) + FnMut(P0::Item<'a>, P1::Item<'a>, P2::Item<'a>),

type Handler = Callback<(), CtxFree<NoEvent<F>>, (P0, P1, P2)>

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<F: Send + 'static, P0: Param + 'static, P1: Param + 'static, P2: Param + 'static, P3: Param + 'static> IntoHandler<(), (P0, P1, P2, P3)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(P0, P1, P2, P3) + FnMut(P0::Item<'a>, P1::Item<'a>, P2::Item<'a>, P3::Item<'a>),

type Handler = Callback<(), CtxFree<NoEvent<F>>, (P0, P1, P2, P3)>

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<F: Send + 'static, P0: Param + 'static, P1: Param + 'static, P2: Param + 'static, P3: Param + 'static, P4: Param + 'static> IntoHandler<(), (P0, P1, P2, P3, P4)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(P0, P1, P2, P3, P4) + FnMut(P0::Item<'a>, P1::Item<'a>, P2::Item<'a>, P3::Item<'a>, P4::Item<'a>),

type Handler = Callback<(), CtxFree<NoEvent<F>>, (P0, P1, P2, P3, P4)>

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<F: Send + 'static, P0: Param + 'static, P1: Param + 'static, P2: Param + 'static, P3: Param + 'static, P4: Param + 'static, P5: Param + 'static> IntoHandler<(), (P0, P1, P2, P3, P4, P5)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(P0, P1, P2, P3, P4, P5) + FnMut(P0::Item<'a>, P1::Item<'a>, P2::Item<'a>, P3::Item<'a>, P4::Item<'a>, P5::Item<'a>),

type Handler = Callback<(), CtxFree<NoEvent<F>>, (P0, P1, P2, P3, P4, P5)>

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<F: Send + 'static, P0: Param + 'static, P1: Param + 'static, P2: Param + 'static, P3: Param + 'static, P4: Param + 'static, P5: Param + 'static, P6: Param + 'static> IntoHandler<(), (P0, P1, P2, P3, P4, P5, P6)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(P0, P1, P2, P3, P4, P5, P6) + FnMut(P0::Item<'a>, P1::Item<'a>, P2::Item<'a>, P3::Item<'a>, P4::Item<'a>, P5::Item<'a>, P6::Item<'a>),

type Handler = Callback<(), CtxFree<NoEvent<F>>, (P0, P1, P2, P3, P4, P5, P6)>

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<F: Send + 'static, P0: Param + 'static, P1: Param + 'static, P2: Param + 'static, P3: Param + 'static, P4: Param + 'static, P5: Param + 'static, P6: Param + 'static, P7: Param + 'static> IntoHandler<(), (P0, P1, P2, P3, P4, P5, P6, P7)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(P0, P1, P2, P3, P4, P5, P6, P7) + FnMut(P0::Item<'a>, P1::Item<'a>, P2::Item<'a>, P3::Item<'a>, P4::Item<'a>, P5::Item<'a>, P6::Item<'a>, P7::Item<'a>),

type Handler = Callback<(), CtxFree<NoEvent<F>>, (P0, P1, P2, P3, P4, P5, P6, P7)>

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<F: FnMut() + Send + 'static> IntoHandler<(), NoEvent<F>> for F

type Handler = Callback<(), CtxFree<NoEvent<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<Acc, Out, F: 'static, P0: Param + 'static> IntoRefScanStep<Acc, (), Out, (P0,)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(P0, &mut Acc) -> Out + FnMut(P0::Item<'a>, &mut Acc) -> Out,

type Step = Step<NoEvent<F>, (P0,)>

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<Acc, Out, F: 'static, P0: Param + 'static, P1: Param + 'static> IntoRefScanStep<Acc, (), Out, (P0, P1)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(P0, P1, &mut Acc) -> Out + FnMut(P0::Item<'a>, P1::Item<'a>, &mut Acc) -> Out,

type Step = Step<NoEvent<F>, (P0, P1)>

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<Acc, Out, F: 'static, P0: Param + 'static, P1: Param + 'static, P2: Param + 'static> IntoRefScanStep<Acc, (), Out, (P0, P1, P2)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(P0, P1, P2, &mut Acc) -> Out + FnMut(P0::Item<'a>, P1::Item<'a>, P2::Item<'a>, &mut Acc) -> Out,

type Step = Step<NoEvent<F>, (P0, P1, P2)>

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<Acc, Out, F: 'static, P0: Param + 'static, P1: Param + 'static, P2: Param + 'static, P3: Param + 'static> IntoRefScanStep<Acc, (), Out, (P0, P1, P2, P3)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(P0, P1, P2, P3, &mut Acc) -> Out + FnMut(P0::Item<'a>, P1::Item<'a>, P2::Item<'a>, P3::Item<'a>, &mut Acc) -> Out,

type Step = Step<NoEvent<F>, (P0, P1, P2, P3)>

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<Acc, Out, F: 'static, P0: Param + 'static, P1: Param + 'static, P2: Param + 'static, P3: Param + 'static, P4: Param + 'static> IntoRefScanStep<Acc, (), Out, (P0, P1, P2, P3, P4)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(P0, P1, P2, P3, P4, &mut Acc) -> Out + FnMut(P0::Item<'a>, P1::Item<'a>, P2::Item<'a>, P3::Item<'a>, P4::Item<'a>, &mut Acc) -> Out,

type Step = Step<NoEvent<F>, (P0, P1, P2, P3, P4)>

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<Acc, Out, F: 'static, P0: Param + 'static, P1: Param + 'static, P2: Param + 'static, P3: Param + 'static, P4: Param + 'static, P5: Param + 'static> IntoRefScanStep<Acc, (), Out, (P0, P1, P2, P3, P4, P5)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(P0, P1, P2, P3, P4, P5, &mut Acc) -> Out + FnMut(P0::Item<'a>, P1::Item<'a>, P2::Item<'a>, P3::Item<'a>, P4::Item<'a>, P5::Item<'a>, &mut Acc) -> Out,

type Step = Step<NoEvent<F>, (P0, P1, P2, P3, P4, P5)>

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<Acc, Out, F: 'static, P0: Param + 'static, P1: Param + 'static, P2: Param + 'static, P3: Param + 'static, P4: Param + 'static, P5: Param + 'static, P6: Param + 'static> IntoRefScanStep<Acc, (), Out, (P0, P1, P2, P3, P4, P5, P6)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(P0, P1, P2, P3, P4, P5, P6, &mut Acc) -> Out + FnMut(P0::Item<'a>, P1::Item<'a>, P2::Item<'a>, P3::Item<'a>, P4::Item<'a>, P5::Item<'a>, P6::Item<'a>, &mut Acc) -> Out,

type Step = Step<NoEvent<F>, (P0, P1, P2, P3, P4, P5, P6)>

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<Acc, Out, F: 'static, P0: Param + 'static, P1: Param + 'static, P2: Param + 'static, P3: Param + 'static, P4: Param + 'static, P5: Param + 'static, P6: Param + 'static, P7: Param + 'static> IntoRefScanStep<Acc, (), Out, (P0, P1, P2, P3, P4, P5, P6, P7)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(P0, P1, P2, P3, P4, P5, P6, P7, &mut Acc) -> Out + FnMut(P0::Item<'a>, P1::Item<'a>, P2::Item<'a>, P3::Item<'a>, P4::Item<'a>, P5::Item<'a>, P6::Item<'a>, P7::Item<'a>, &mut Acc) -> Out,

type Step = Step<NoEvent<F>, (P0, P1, P2, P3, P4, P5, P6, P7)>

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<Acc, Out, F: FnMut(&mut Acc) -> Out + 'static> IntoRefScanStep<Acc, (), Out, NoEvent<F>> for F

type Step = Step<NoEvent<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<Out, F: 'static, P0: Param + 'static> IntoRefStep<(), Out, (P0,)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(P0) -> Out + FnMut(P0::Item<'a>) -> Out,

type Step = Step<NoEvent<F>, (P0,)>

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<Out, F: 'static, P0: Param + 'static, P1: Param + 'static> IntoRefStep<(), Out, (P0, P1)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(P0, P1) -> Out + FnMut(P0::Item<'a>, P1::Item<'a>) -> Out,

type Step = Step<NoEvent<F>, (P0, P1)>

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<Out, F: 'static, P0: Param + 'static, P1: Param + 'static, P2: Param + 'static> IntoRefStep<(), Out, (P0, P1, P2)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(P0, P1, P2) -> Out + FnMut(P0::Item<'a>, P1::Item<'a>, P2::Item<'a>) -> Out,

type Step = Step<NoEvent<F>, (P0, P1, P2)>

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<Out, F: 'static, P0: Param + 'static, P1: Param + 'static, P2: Param + 'static, P3: Param + 'static> IntoRefStep<(), Out, (P0, P1, P2, P3)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(P0, P1, P2, P3) -> Out + FnMut(P0::Item<'a>, P1::Item<'a>, P2::Item<'a>, P3::Item<'a>) -> Out,

type Step = Step<NoEvent<F>, (P0, P1, P2, P3)>

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<Out, F: 'static, P0: Param + 'static, P1: Param + 'static, P2: Param + 'static, P3: Param + 'static, P4: Param + 'static> IntoRefStep<(), Out, (P0, P1, P2, P3, P4)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(P0, P1, P2, P3, P4) -> Out + FnMut(P0::Item<'a>, P1::Item<'a>, P2::Item<'a>, P3::Item<'a>, P4::Item<'a>) -> Out,

type Step = Step<NoEvent<F>, (P0, P1, P2, P3, P4)>

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<Out, F: 'static, P0: Param + 'static, P1: Param + 'static, P2: Param + 'static, P3: Param + 'static, P4: Param + 'static, P5: Param + 'static> IntoRefStep<(), Out, (P0, P1, P2, P3, P4, P5)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(P0, P1, P2, P3, P4, P5) -> Out + FnMut(P0::Item<'a>, P1::Item<'a>, P2::Item<'a>, P3::Item<'a>, P4::Item<'a>, P5::Item<'a>) -> Out,

type Step = Step<NoEvent<F>, (P0, P1, P2, P3, P4, P5)>

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<Out, F: 'static, P0: Param + 'static, P1: Param + 'static, P2: Param + 'static, P3: Param + 'static, P4: Param + 'static, P5: Param + 'static, P6: Param + 'static> IntoRefStep<(), Out, (P0, P1, P2, P3, P4, P5, P6)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(P0, P1, P2, P3, P4, P5, P6) -> Out + FnMut(P0::Item<'a>, P1::Item<'a>, P2::Item<'a>, P3::Item<'a>, P4::Item<'a>, P5::Item<'a>, P6::Item<'a>) -> Out,

type Step = Step<NoEvent<F>, (P0, P1, P2, P3, P4, P5, P6)>

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<Out, F: 'static, P0: Param + 'static, P1: Param + 'static, P2: Param + 'static, P3: Param + 'static, P4: Param + 'static, P5: Param + 'static, P6: Param + 'static, P7: Param + 'static> IntoRefStep<(), Out, (P0, P1, P2, P3, P4, P5, P6, P7)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(P0, P1, P2, P3, P4, P5, P6, P7) -> Out + FnMut(P0::Item<'a>, P1::Item<'a>, P2::Item<'a>, P3::Item<'a>, P4::Item<'a>, P5::Item<'a>, P6::Item<'a>, P7::Item<'a>) -> Out,

type Step = Step<NoEvent<F>, (P0, P1, P2, P3, P4, P5, P6, P7)>

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<Out, F: FnMut() -> Out + 'static> IntoRefStep<(), Out, NoEvent<F>> for F

type Step = Step<NoEvent<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, Out, F: 'static, P0: Param + 'static> IntoScanStep<Acc, (), Out, (P0,)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(P0, &mut Acc) -> Out + FnMut(P0::Item<'a>, &mut Acc) -> Out,

type Step = Step<NoEvent<F>, (P0,)>

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<Acc, Out, F: 'static, P0: Param + 'static, P1: Param + 'static> IntoScanStep<Acc, (), Out, (P0, P1)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(P0, P1, &mut Acc) -> Out + FnMut(P0::Item<'a>, P1::Item<'a>, &mut Acc) -> Out,

type Step = Step<NoEvent<F>, (P0, P1)>

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<Acc, Out, F: 'static, P0: Param + 'static, P1: Param + 'static, P2: Param + 'static> IntoScanStep<Acc, (), Out, (P0, P1, P2)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(P0, P1, P2, &mut Acc) -> Out + FnMut(P0::Item<'a>, P1::Item<'a>, P2::Item<'a>, &mut Acc) -> Out,

type Step = Step<NoEvent<F>, (P0, P1, P2)>

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<Acc, Out, F: 'static, P0: Param + 'static, P1: Param + 'static, P2: Param + 'static, P3: Param + 'static> IntoScanStep<Acc, (), Out, (P0, P1, P2, P3)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(P0, P1, P2, P3, &mut Acc) -> Out + FnMut(P0::Item<'a>, P1::Item<'a>, P2::Item<'a>, P3::Item<'a>, &mut Acc) -> Out,

type Step = Step<NoEvent<F>, (P0, P1, P2, P3)>

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<Acc, Out, F: 'static, P0: Param + 'static, P1: Param + 'static, P2: Param + 'static, P3: Param + 'static, P4: Param + 'static> IntoScanStep<Acc, (), Out, (P0, P1, P2, P3, P4)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(P0, P1, P2, P3, P4, &mut Acc) -> Out + FnMut(P0::Item<'a>, P1::Item<'a>, P2::Item<'a>, P3::Item<'a>, P4::Item<'a>, &mut Acc) -> Out,

type Step = Step<NoEvent<F>, (P0, P1, P2, P3, P4)>

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<Acc, Out, F: 'static, P0: Param + 'static, P1: Param + 'static, P2: Param + 'static, P3: Param + 'static, P4: Param + 'static, P5: Param + 'static> IntoScanStep<Acc, (), Out, (P0, P1, P2, P3, P4, P5)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(P0, P1, P2, P3, P4, P5, &mut Acc) -> Out + FnMut(P0::Item<'a>, P1::Item<'a>, P2::Item<'a>, P3::Item<'a>, P4::Item<'a>, P5::Item<'a>, &mut Acc) -> Out,

type Step = Step<NoEvent<F>, (P0, P1, P2, P3, P4, P5)>

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<Acc, Out, F: 'static, P0: Param + 'static, P1: Param + 'static, P2: Param + 'static, P3: Param + 'static, P4: Param + 'static, P5: Param + 'static, P6: Param + 'static> IntoScanStep<Acc, (), Out, (P0, P1, P2, P3, P4, P5, P6)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(P0, P1, P2, P3, P4, P5, P6, &mut Acc) -> Out + FnMut(P0::Item<'a>, P1::Item<'a>, P2::Item<'a>, P3::Item<'a>, P4::Item<'a>, P5::Item<'a>, P6::Item<'a>, &mut Acc) -> Out,

type Step = Step<NoEvent<F>, (P0, P1, P2, P3, P4, P5, P6)>

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<Acc, Out, F: 'static, P0: Param + 'static, P1: Param + 'static, P2: Param + 'static, P3: Param + 'static, P4: Param + 'static, P5: Param + 'static, P6: Param + 'static, P7: Param + 'static> IntoScanStep<Acc, (), Out, (P0, P1, P2, P3, P4, P5, P6, P7)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(P0, P1, P2, P3, P4, P5, P6, P7, &mut Acc) -> Out + FnMut(P0::Item<'a>, P1::Item<'a>, P2::Item<'a>, P3::Item<'a>, P4::Item<'a>, P5::Item<'a>, P6::Item<'a>, P7::Item<'a>, &mut Acc) -> Out,

type Step = Step<NoEvent<F>, (P0, P1, P2, P3, P4, P5, P6, P7)>

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<Acc, Out, F: FnMut(&mut Acc) -> Out + 'static> IntoScanStep<Acc, (), Out, NoEvent<F>> for F

type Step = Step<NoEvent<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<Out, F: 'static, P0: Param + 'static> IntoStep<(), Out, (P0,)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(P0) -> Out + FnMut(P0::Item<'a>) -> Out,

type Step = Step<NoEvent<F>, (P0,)>

The concrete resolved step type.

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

Resolve Param state from the registry and produce a step.

impl<Out, F: 'static, P0: Param + 'static, P1: Param + 'static> IntoStep<(), Out, (P0, P1)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(P0, P1) -> Out + FnMut(P0::Item<'a>, P1::Item<'a>) -> Out,

type Step = Step<NoEvent<F>, (P0, P1)>

The concrete resolved step type.

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

Resolve Param state from the registry and produce a step.

impl<Out, F: 'static, P0: Param + 'static, P1: Param + 'static, P2: Param + 'static> IntoStep<(), Out, (P0, P1, P2)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(P0, P1, P2) -> Out + FnMut(P0::Item<'a>, P1::Item<'a>, P2::Item<'a>) -> Out,

type Step = Step<NoEvent<F>, (P0, P1, P2)>

The concrete resolved step type.

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

Resolve Param state from the registry and produce a step.

impl<Out, F: 'static, P0: Param + 'static, P1: Param + 'static, P2: Param + 'static, P3: Param + 'static> IntoStep<(), Out, (P0, P1, P2, P3)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(P0, P1, P2, P3) -> Out + FnMut(P0::Item<'a>, P1::Item<'a>, P2::Item<'a>, P3::Item<'a>) -> Out,

type Step = Step<NoEvent<F>, (P0, P1, P2, P3)>

The concrete resolved step type.

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

Resolve Param state from the registry and produce a step.

impl<Out, F: 'static, P0: Param + 'static, P1: Param + 'static, P2: Param + 'static, P3: Param + 'static, P4: Param + 'static> IntoStep<(), Out, (P0, P1, P2, P3, P4)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(P0, P1, P2, P3, P4) -> Out + FnMut(P0::Item<'a>, P1::Item<'a>, P2::Item<'a>, P3::Item<'a>, P4::Item<'a>) -> Out,

type Step = Step<NoEvent<F>, (P0, P1, P2, P3, P4)>

The concrete resolved step type.

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

Resolve Param state from the registry and produce a step.

impl<Out, F: 'static, P0: Param + 'static, P1: Param + 'static, P2: Param + 'static, P3: Param + 'static, P4: Param + 'static, P5: Param + 'static> IntoStep<(), Out, (P0, P1, P2, P3, P4, P5)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(P0, P1, P2, P3, P4, P5) -> Out + FnMut(P0::Item<'a>, P1::Item<'a>, P2::Item<'a>, P3::Item<'a>, P4::Item<'a>, P5::Item<'a>) -> Out,

type Step = Step<NoEvent<F>, (P0, P1, P2, P3, P4, P5)>

The concrete resolved step type.

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

Resolve Param state from the registry and produce a step.

impl<Out, F: 'static, P0: Param + 'static, P1: Param + 'static, P2: Param + 'static, P3: Param + 'static, P4: Param + 'static, P5: Param + 'static, P6: Param + 'static> IntoStep<(), Out, (P0, P1, P2, P3, P4, P5, P6)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(P0, P1, P2, P3, P4, P5, P6) -> Out + FnMut(P0::Item<'a>, P1::Item<'a>, P2::Item<'a>, P3::Item<'a>, P4::Item<'a>, P5::Item<'a>, P6::Item<'a>) -> Out,

type Step = Step<NoEvent<F>, (P0, P1, P2, P3, P4, P5, P6)>

The concrete resolved step type.

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

Resolve Param state from the registry and produce a step.

impl<Out, F: 'static, P0: Param + 'static, P1: Param + 'static, P2: Param + 'static, P3: Param + 'static, P4: Param + 'static, P5: Param + 'static, P6: Param + 'static, P7: Param + 'static> IntoStep<(), Out, (P0, P1, P2, P3, P4, P5, P6, P7)> for NoEvent<F>

where for<'a> &'a mut F: FnMut(P0, P1, P2, P3, P4, P5, P6, P7) -> Out + FnMut(P0::Item<'a>, P1::Item<'a>, P2::Item<'a>, P3::Item<'a>, P4::Item<'a>, P5::Item<'a>, P6::Item<'a>, P7::Item<'a>) -> Out,

type Step = Step<NoEvent<F>, (P0, P1, P2, P3, P4, P5, P6, P7)>

The concrete resolved step type.

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

Resolve Param state from the registry and produce a step.

impl<Out, F: FnMut() -> Out + 'static> IntoStep<(), Out, NoEvent<F>> for F

type Step = Step<NoEvent<F>, ()>

The concrete resolved step type.

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

Resolve Param state from the registry and produce a step.