Struct redux_rs::Store

pub struct Store<State, Action> { /* fields omitted */ }

A container holding a state and providing the possibility to dispatch actions.

A store is defined by the state is holds and the actions it can dispatch.

Methods

impl<State, Action> Store<State, Action>

pub fn new(reducer: Reducer<State, Action>, initial_state: State) -> Self

Creates a new store.

Example

type State = i8;

enum Action {
    Increment,
    Decrement
}

fn reducer(state: &State, action: &Action) -> State {
    match action {
        Action::Increment => state + 1,
        Action::Decrement => state - 1
    }
}

let mut store = Store::new(reducer, 0);

pub fn state(&self) -> &State

Returns the current state.

Example

println!("Current state: {}", store.state());

pub fn dispatch(&mut self, action: Action)

Dispatches an action which is handles by the reducer, after the store got passed through the middleware. This can modify the state within the store.

Example

enum Action {
    DoSomething,
    DoSomethingElse
}

// ...

store.dispatch(Action::DoSomething);
println!("Current state: {}", store.state());

pub fn subscribe(&mut self, callback: Subscription<State>)

Subscribes a callback to any change of the state.

Subscriptions will be called, whenever an action is dispatched.

See Subscription.

Example

use redux_rs::{Store, Subscription};

let mut store = Store::new(reducer, initial_state);

let listener: Subscription<State> = |state: &State| {
    println!("Something changed! New value: {}", state);
};

store.subscribe(listener);

pub fn add_middleware(&mut self, middleware: Middleware<State, Action>)

Adds a custom middleware to the store.

Middleware provides the possibility to intercept actions dispatched before they reach the reducer.

See Middleware.

pub fn replace_reducer(&mut self, reducer: Reducer<State, Action>)

Replaces the currently used reducer.

Example

store.dispatch(Action::SomeAction);

store.replace_reducer(|state: &State, action: &Action| {
    State::something_else()
});

store.dispatch(Action::SomeAction);