Struct Store 

pub struct Store<S, R> { /* private fields */ }

A reactive state container.

The only way to mutate the internal state managed by Store is by dispatching actions on it. The associated Reactor is notified upon every state transition.

Example

use reducer::*;
use std::error::Error;
use std::io::{self, Write};

// The state of your app.
struct Calculator(i32);

// Actions the user can trigger.
struct Add(i32);
struct Sub(i32);
struct Mul(i32);
struct Div(i32);

impl Reducer<Add> for Calculator {
    fn reduce(&mut self, Add(x): Add) {
        self.0 += x;
    }
}

impl Reducer<Sub> for Calculator {
    fn reduce(&mut self, Sub(x): Sub) {
        self.0 -= x;
    }
}

impl Reducer<Mul> for Calculator {
    fn reduce(&mut self, Mul(x): Mul) {
        self.0 *= x;
    }
}

impl Reducer<Div> for Calculator {
    fn reduce(&mut self, Div(x): Div) {
        self.0 /= x;
    }
}

// The user interface.
struct Console;

impl Reactor<Calculator> for Console {
    type Error = io::Error;
    fn react(&mut self, state: &Calculator) -> io::Result<()> {
        io::stdout().write_fmt(format_args!("{}\n", state.0))
    }
}

fn main() -> Result<(), Box<dyn Error>> {
    let mut store = Store::new(Calculator(0), Console);

    store.dispatch(Add(5))?; // displays "5"
    store.dispatch(Mul(3))?; // displays "15"
    store.dispatch(Sub(1))?; // displays "14"
    store.dispatch(Div(7))?; // displays "2"

    Ok(())
}

Implementations

impl<S, R> Store<S, R>

pub fn into_task<A, E>( self, ) -> (impl Future<Output = Result<(), E>>, impl Dispatcher<A, Output = Result<(), DispatchError>> + Sink<A, Error = DispatchError> + Clone)

where Self: Sink<A, Error = E>,

Turns the Store into a task that can be spawned onto an executor (requires async).

Once spawned, the task will receive actions dispatched through a lightweight Dispatcher handle that can be cloned and sent to other threads.

The task completes

• successfully if the asynchronous Dispatcher (or the last of its clones) is dropped or closed.
• with an error if Store::dispatch fails.

Turning a Store into an asynchronous task requires all actions to be of the same type A; an effective way of fulfilling this requirement is to define actions as enum variants.

Example

use reducer::*;
use futures::prelude::*;
use std::error::Error;
use std::io::{self, Write};
use tokio::task::spawn;

// The state of your app.
#[derive(Clone)]
struct Calculator(i32);

// Actions the user can trigger.
enum Action {
    Add(i32),
    Sub(i32),
    Mul(i32),
    Div(i32),
}

impl Reducer<Action> for Calculator {
    fn reduce(&mut self, action: Action) {
        match action {
            Action::Add(x) => self.0 += x,
            Action::Sub(x) => self.0 -= x,
            Action::Mul(x) => self.0 *= x,
            Action::Div(x) => self.0 /= x,
        }
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    let store = Store::new(
        Calculator(0),
        AsyncReactor(sink::unfold((), |_, state: Calculator| async move {
            writeln!(&mut io::stdout(), "{}", state.0)
        })),
    );

    // Process incoming actions on a background task.
    let (task, mut dispatcher) = store.into_task();
    let handle = spawn(task);

    dispatcher.dispatch(Action::Add(5))?; // asynchronously prints "5" to stdout
    dispatcher.dispatch(Action::Mul(3))?; // asynchronously prints "15" to stdout
    dispatcher.dispatch(Action::Sub(1))?; // asynchronously prints "14" to stdout
    dispatcher.dispatch(Action::Div(7))?; // asynchronously prints "2" to stdout

    // Closing the asynchronous dispatcher signals to the background task that
    // it can terminate once all pending actions have been processed.
    dispatcher.close().await?;

    // Wait for the background task to terminate.
    handle.await??;

    Ok(())
}

impl<S, R> Store<S, R>

pub fn new(state: S, reactor: R) -> Self

Constructs the Store given the initial state and a Reactor.

pub fn subscribe(&mut self, reactor: impl Into<R>) -> R

Replaces the Reactor and returns the previous one.

Trait Implementations

impl<S: Clone, R: Clone> Clone for Store<S, R>

fn clone(&self) -> Store<S, R>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S: Debug, R: Debug> Debug for Store<S, R>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<S: Default, R: Default> Default for Store<S, R>

fn default() -> Store<S, R>

Returns the “default value” for a type.

impl<S, R> Deref for Store<S, R>

type Target = S

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<A, S, R> Dispatcher<A> for Store<S, R>

where S: Reducer<A>, R: Reactor<S>,

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

Updates the state via Reducer::reduce and notifies the Reactor, returning the result of calling Reactor::react with a reference to the new state.

type Output = Result<(), <R as Reactor<S>>::Error>

impl<S: Hash, R: Hash> Hash for Store<S, R>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<S: PartialEq, R: PartialEq> PartialEq for Store<S, R>

fn eq(&self, other: &Store<S, R>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<A, S, R, E> Sink<A> for Store<S, R>

where S: Reducer<A>, R: for<'s> Sink<&'s S, Error = E>,

View Store as a Sink of actions (requires async).

type Error = E

The type of value produced by the sink when an error occurs.

fn poll_ready( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Attempts to prepare the Sink to receive a value.

fn start_send(self: Pin<&mut Self>, action: A) -> Result<(), Self::Error>

Begin the process of sending a value to the sink. Each call to this function must be preceded by a successful call to poll_ready which returned Poll::Ready(Ok(())).

fn poll_flush( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Flush any remaining output from this sink.

fn poll_close( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Flush any remaining output and close this sink, if necessary.

impl<S: Copy, R: Copy> Copy for Store<S, R>

impl<S: Eq, R: Eq> Eq for Store<S, R>

impl<S, R> StructuralPartialEq for Store<S, R>

impl<'pin, S, R> Unpin for Store<S, R>

where PinnedFieldsOf<__Store<'pin, S, R>>: Unpin,