Struct EffectStore 

pub struct EffectStore<S, A, E> { /* private fields */ }

A store that supports effect-emitting reducers.

Similar to Store, but the reducer returns DispatchResult<E> instead of bool, allowing it to declare side effects alongside state changes.

Example

use tui_dispatch::{DispatchResult, EffectStore};

enum Effect { Log(String) }
struct State { count: i32 }
enum Action { Increment }

fn reducer(state: &mut State, action: Action) -> DispatchResult<Effect> {
    match action {
        Action::Increment => {
            state.count += 1;
            DispatchResult::changed_with(Effect::Log(format!("count is {}", state.count)))
        }
    }
}

let mut store = EffectStore::new(State { count: 0 }, reducer);
let result = store.dispatch(Action::Increment);
assert!(result.changed);
assert_eq!(result.effects.len(), 1);

Implementations

impl<S, A, E> EffectStore<S, A, E>

where A: Action,

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

Create a new effect store with the given initial state and reducer.

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.

Use sparingly - prefer dispatching actions for state changes. This is mainly useful for initialization.

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

Dispatch an action to the store.

The reducer is called with the current state and action, returning whether state changed and any effects to process.