Struct Store 

pub struct Store<S, A: Action> { /* 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

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

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

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

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

Implementations

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

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

Create a new store with initial state and reducer

pub fn dispatch(&mut self, action: A) -> bool

Dispatch an action to the store

The reducer will be called with the current state and action. Returns true if the state changed and a re-render is needed.

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> DispatchStore<S, A> for Store<S, A>

fn dispatch(&mut self, action: A) -> bool

Dispatch an action and return whether the state changed.

fn state(&self) -> &S

Get the current state.