Struct Effect

pub struct Effect<Action: Send + 'static> {
    pub value: EffectValue<Action>,
}

Fields

value: EffectValue<Action>

Implementations

impl<Action> Effect<Action>

where Action: Send + 'static,

pub fn map<F, MappedAction>(self, map: F) -> Effect<MappedAction>

where MappedAction: Send + 'static, F: Fn(Action) -> MappedAction + Send + Sync + 'static,

pub fn run<T, Fut>(job: T) -> Self

where Fut: Future<Output = ()> + Send + 'static, T: FnOnce(AnyActionSender<Action>) -> Fut + Send + 'static,

Wraps an asynchronous unit of work that can emit actions any number of times in an effect.

For example, if you had an async stream in a dependency client:

struct EventsClient<F: Fn() -> Stream<Item = Event> {
  events: F,
}

Then you could attach to it in a run effect and sending each action of the stream back into the system:

match action {
    Action::StartButtonTapped => {
        Effect::run(async move |send| {
            let events_client = EventsClient::new().events();
            while let Some(event) = events_client.next().await {
                send.send(Action::Event(event));
            }
        })
    }
}

pub fn none() -> Self

An effect that does nothing and completes immediately. Useful for situations where you must return an effect, but you don’t need to do anything.

pub fn quit() -> Self

Effect that stops the reducer engine and drops observation stream, usually to gracefully exit the application.

pub fn send(action: Action) -> Self

Initializes an effect that immediately emits the action passed in.