Struct reducer::Store

pub struct Store<S, R: Reactor<S>> { /* fields omitted */ }

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(())
}

Methods

impl<S, R: Reactor<S>> 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<A, S, R> Dispatcher<A> for Store<S, R> where
    S: Reducer<A>,
    R: Reactor<S>, 

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

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.

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Returns the "default value" for a type.

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

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

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

impl<S: Unpin, R: Reactor<S> + Unpin> Unpin for Store<S, R>

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

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

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

Formats the value using the given formatter.

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

View Store as a read-only owning smart pointer to the state.

type Target = S

The resulting type after dereferencing.

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

Grants read access to the current state.

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

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

Feeds this value into the given [Hasher].

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

Feeds a slice of this type into the given [Hasher].

impl<A, S, R, E> Sink<A> for Store<S, R> where
    S: Reducer<A> + Unpin + Clone,
    R: Reactor<S, Error = E> + Sink<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.