Struct EffectStoreWithMiddleware 

pub struct EffectStoreWithMiddleware<S, A, E, M>
where
    A: Action,
    M: Middleware<S, A>,
{ /* private fields */ }

An effect store with middleware support.

Wraps an EffectStore and calls middleware hooks before and after each dispatch. The middleware receives action references and the state change indicator, but not the effects.

Example

use tui_dispatch::{ReducerResult, EffectStoreWithMiddleware};
use tui_dispatch::debug::ActionLoggerMiddleware;

let middleware = ActionLoggerMiddleware::with_default_log();
let mut store = EffectStoreWithMiddleware::new(
    State::default(),
    reducer,
    middleware,
);

let result = store.dispatch(Action::Something);
// Middleware logged the action
// result.effects contains any effects to process

Implementations

impl<S, A, E, M> EffectStoreWithMiddleware<S, A, E, M>

where A: Action, M: Middleware<S, A>,

pub fn new(state: S, reducer: EffectReducer<S, A, E>, middleware: M) -> Self

Create a new effect store with middleware.

pub fn with_dispatch_limits(self, limits: DispatchLimits) -> Self

Override middleware dispatch limits.

pub fn dispatch_limits(&self) -> DispatchLimits

Current middleware dispatch limits.

pub fn state(&self) -> &S

Get a reference to the current state.

pub fn state_mut(&mut self) -> &mut S

Get a mutable reference to the state.

pub fn middleware(&self) -> &M

Get a reference to the middleware.

pub fn middleware_mut(&mut self) -> &mut M

Get a mutable reference to the middleware.

pub fn dispatch(&mut self, action: A) -> ReducerResult<E>

Dispatch an action through middleware and store.

This wraps Self::try_dispatch and panics if dispatch limits are exceeded. Use try_dispatch to handle overflow as a typed error.

pub fn try_dispatch( &mut self, action: A, ) -> Result<ReducerResult<E>, DispatchError>

Dispatch an action through middleware and store.

The action passes through middleware.before() (which can cancel it), then the reducer, then middleware.after() (which can inject follow-up actions). Injected actions go through the full pipeline in depth-first order; their effects are merged into the returned result.

Returns DispatchError if configured depth or action budget limits are exceeded.

This operation is not transactional: if overflow happens in an injected chain, earlier actions in the chain may have already mutated state.

Action budget accounting includes attempted dispatches that are later cancelled by Middleware::before.

Trait Implementations

impl<S, A: Action, E, M: Middleware<S, A>> EffectStoreLike<S, A, E> for EffectStoreWithMiddleware<S, A, E, M>

fn dispatch(&mut self, action: A) -> ReducerResult<E>

Dispatch an action and return state changes plus effects.

fn try_dispatch(&mut self, action: A) -> Result<ReducerResult<E>, DispatchError>

Dispatch an action and return state changes plus effects.

fn state(&self) -> &S

Get the current state.