Enum Effect 

pub enum Effect<M> {
    None,
    Task {
        id: EffectId,
        run: TaskFn<M>,
    },
    RegisteredTask {
        id: EffectId,
    },
    EnvTask {
        id: EffectId,
        run: EnvTaskFn<M>,
    },
    RegisteredEnvTask {
        id: EffectId,
    },
    RegisteredRun {
        id: EffectId,
    },
    Batch(Vec<Effect<M>>),
    Cancellable {
        id: EffectId,
        cancel_in_flight: bool,
        inner: Box<Effect<M>>,
    },
    Debounce {
        id: EffectId,
        duration: Duration,
        inner: Box<Effect<M>>,
    },
    Throttle {
        id: EffectId,
        duration: Duration,
        latest: bool,
        inner: Box<Effect<M>>,
    },
    Provide {
        env: Environment,
        inner: Box<Effect<M>>,
    },
    Retry {
        attempts: u32,
        inner: Box<Effect<M>>,
    },
    Timeout {
        duration: Duration,
        inner: Box<Effect<M>>,
    },
    Sequence(Vec<Effect<M>>),
    Race(Vec<Effect<M>>),
    Catch {
        inner: Box<Effect<M>>,
        recover: fn(EffectError) -> Effect<M>,
    },
    Cancel {
        id: EffectId,
    },
}

Pure effect descriptions — interpreted only in runtime.rs.

• Effect::merge / Effect::batch — run children concurrently (UDF merge).
• Effect::concatenate / Effect::sequence — run children in order (UDF concatenate).

Variants

None

Task

Fields

id: EffectId

run: TaskFn<M>

RegisteredTask

Fields

id: EffectId

EnvTask

Fields

id: EffectId

run: EnvTaskFn<M>

RegisteredEnvTask

Fields

id: EffectId

RegisteredRun

Fields

id: EffectId

Batch(Vec<Effect<M>>)

Cancellable

Fields

id: EffectId

cancel_in_flight: bool

inner: Box<Effect<M>>

Debounce

Fields

id: EffectId

duration: Duration

inner: Box<Effect<M>>

Throttle

Fields

id: EffectId

duration: Duration

latest: bool

inner: Box<Effect<M>>

Provide

Fields

env: Environment

inner: Box<Effect<M>>

Retry

Fields

attempts: u32

inner: Box<Effect<M>>

Timeout

Fields

duration: Duration

inner: Box<Effect<M>>

Sequence(Vec<Effect<M>>)

Race(Vec<Effect<M>>)

Catch

Fields

inner: Box<Effect<M>>

recover: fn(EffectError) -> Effect<M>

Cancel

Fields

id: EffectId

Implementations

impl<M> Effect<M>

pub fn none() -> Self

pub fn task(id: EffectId, run: TaskFn<M>) -> Self

pub fn from_fn<F>(run: F) -> Self

where M: Send + 'static, F: Fn() -> Pin<Box<dyn Future<Output = Result<M, EffectError>> + Send>> + Send + Sync + 'static,

pub fn env_task(id: EffectId, run: EnvTaskFn<M>) -> Self

pub fn from_env_fn<F>(run: F) -> Self

where M: Send + 'static, F: Fn(&Environment) -> Pin<Box<dyn Future<Output = Result<M, EffectError>> + Send>> + Send + Sync + 'static,

pub fn from_run<F>(run: F) -> Self

where M: Send + 'static, F: Fn(RunSender<M>) -> Pin<Box<dyn Future<Output = Result<(), EffectError>> + Send>> + Send + Sync + 'static,

pub fn task_try(id: EffectId, run: TaskFn<M>) -> Self

Single-shot async task (alias for Effect::task).

pub fn result_task<T, E>( run: TaskFn<Result<T, E>>, on_ok: fn(T) -> M, on_err: fn(E) -> M, ) -> Self

where T: Send + 'static, E: Send + 'static, M: Send + 'static,

Map a Result<T, E> leaf task into M via fn pointers (UDF TaskResult).

pub fn batch(effects: impl IntoIterator<Item = Effect<M>>) -> Self

pub fn merge(effects: impl IntoIterator<Item = Effect<M>>) -> Self

pub fn concatenate(effects: impl IntoIterator<Item = Effect<M>>) -> Self

pub fn map<N>(self, f: fn(M) -> N) -> Effect<N>

where M: Send + 'static, N: Send + 'static,

pub fn cancellable(id: EffectId, inner: Effect<M>) -> Self

pub fn cancellable_with( id: EffectId, cancel_in_flight: bool, inner: Effect<M>, ) -> Self

pub fn debounce(id: EffectId, duration: Duration, inner: Effect<M>) -> Self

pub fn throttle( id: EffectId, duration: Duration, latest: bool, inner: Effect<M>, ) -> Self

pub fn cancel(id: EffectId) -> Self

pub fn provide(env: Environment, inner: Effect<M>) -> Self

pub fn provide_dependency<D: Send + Sync + 'static>( value: D, inner: Effect<M>, ) -> Self

Scoped single-dependency override (UDF dependency override / withDependencies).

pub fn retry(attempts: u32, inner: Effect<M>) -> Self

pub fn timeout(duration: Duration, inner: Effect<M>) -> Self

pub fn sequence(effects: impl IntoIterator<Item = Effect<M>>) -> Self

pub fn race(effects: impl IntoIterator<Item = Effect<M>>) -> Self

pub fn catch(inner: Effect<M>, recover: fn(EffectError) -> Effect<M>) -> Self

Trait Implementations

impl<M> Clone for Effect<M>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<M> Debug for Effect<M>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<M> PartialEq for Effect<M>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.