Struct reducer::Async

pub struct Async<D: Dispatcher<A>, A> { /* fields omitted */ }

An asynchronous adapter for dispatchers (requires async).

Once Async is spawned actions may be dispatched on it through its AsyncHandle.

Async requires all actions to be of the same type A. An effective way to fulfill this requirement, is to use an enum to represent actions.

Example

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

// The state of your app.
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,
        }
    }
}

// The user interface.
struct Display;

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

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

    // Spin up a thread-pool.
    let mut executor = ThreadPoolBuilder::new().create()?;

    // Process incoming actions on a background thread.
    let mut dispatcher = store.spawn(&mut executor).unwrap();

    dispatcher.dispatch(Action::Add(5)); // displays "5"
    dispatcher.dispatch(Action::Mul(3)); // displays "15"
    dispatcher.dispatch(Action::Sub(1)); // displays "14"
    dispatcher.dispatch(Action::Div(7)); // displays "2"

    // Allow the background thread to catch up.
    std::thread::sleep(std::time::Duration::from_millis(500));

    Ok(())
}

Methods

impl<D: Dispatcher<A>, A> Async<D, A>

pub fn new(inner: D) -> Self

Constructs Async given any dispatcher.

impl<D, A> Async<D, A> where
    D: Dispatcher<A> + Send + 'static,
    D::Output: Send + 'static,
    A: Send + 'static, 

pub fn spawn(
    self,
    executor: &mut impl SpawnExt
) -> Result<AsyncHandle<D, A>, SpawnError>

Spawns Async onto an Executor and returns an AsyncHandle that may be used to dispatch actions.

The spawned Async will live as long as the handle (or one of its clones) lives.

Trait Implementations

impl<D: Eq + Dispatcher<A>, A: Eq> Eq for Async<D, A>

impl<D: Clone + Dispatcher<A>, A: Clone> Clone for Async<D, A>

fn clone(&self) -> Async<D, A>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<D: Copy + Dispatcher<A>, A: Copy> Copy for Async<D, A>

impl<D: PartialEq + Dispatcher<A>, A: PartialEq> PartialEq<Async<D, A>> for Async<D, A>

fn eq(&self, other: &Async<D, A>) -> bool

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

fn ne(&self, other: &Async<D, A>) -> bool

This method tests for !=.

impl<D: Default + Dispatcher<A>, A: Default> Default for Async<D, A>

fn default() -> Async<D, A>

Returns the "default value" for a type.

impl<D, A> From<D> for Async<D, A> where
    D: Dispatcher<A>, 

fn from(dispatcher: D) -> Self

Performs the conversion.

impl<D, A> DerefMut for Async<D, A> where
    D: Dispatcher<A>, 

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<D, A> Deref for Async<D, A> where
    D: Dispatcher<A>, 

type Target = D

The resulting type after dereferencing.

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

Dereferences the value.

impl<D: Hash + Dispatcher<A>, A: Hash> Hash for Async<D, A>

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

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<D: Debug + Dispatcher<A>, A: Debug> Debug for Async<D, A>

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

Formats the value using the given formatter.