Struct EffectStore 

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

A store that supports effect-emitting reducers.

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

Example

use tui_dispatch_core::{Action, ReducerResult, EffectStore};

#[derive(Clone, Debug)]
enum MyAction { Increment }

impl Action for MyAction {
    fn name(&self) -> &'static str { "Increment" }
}

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

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

let mut store = EffectStore::new(State { count: 0 }, reducer);
let result = store.dispatch(MyAction::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) -> ReducerResult<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.

Trait Implementations

impl<S, A: Action, E> EffectStoreLike<S, A, E> for EffectStore<S, A, E>

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

Dispatch an action and return state changes plus effects.

fn state(&self) -> &S

Get the current state.

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

Dispatch an action and return state changes plus effects.