Struct Store 

pub struct Store<S, A: Action, E = NoEffect> { /* private fields */ }

Centralized state store with Redux-like reducer pattern

The store holds the application state and provides a single point for state mutations through the dispatch method.

Type Parameters

• S - The application state type
• A - The action type (must implement Action)

Example

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

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

impl Action for MyAction {
    fn name(&self) -> &'static str {
        match self {
            MyAction::Increment => "Increment",
            MyAction::Decrement => "Decrement",
        }
    }
}

#[derive(Default)]
struct AppState { counter: i32 }

fn reducer(state: &mut AppState, action: MyAction) -> ReducerResult {
    match action {
        MyAction::Increment => { state.counter += 1; ReducerResult::changed() }
        MyAction::Decrement => { state.counter -= 1; ReducerResult::changed() }
    }
}

let mut store = Store::new(AppState::default(), reducer);
let result = store.dispatch(MyAction::Increment);
assert!(result.changed);
assert_eq!(store.state().counter, 1);

Implementations

impl<S, A: Action, E> Store<S, A, E>

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

Create a new store with initial state and reducer

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

Dispatch an action to the store

The reducer will be called with the current state and action. Returns the reducer result.

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 this sparingly - prefer dispatching actions for state changes. This is useful for initializing state or for cases where the action pattern doesn’t fit well.

Trait Implementations

impl<S, A: Action, E> RuntimeStore<S, A, E> for Store<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.