Struct OrChain 

pub struct OrChain<R>(/* private fields */);

A type that can convert a collection of Reactors into an ordered chain of Or combinators.

Trait Implementations

impl<R: Clone> Clone for OrChain<R>

fn clone(&self) -> OrChain<R>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<R: Debug> Debug for OrChain<R>

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

Formats the value using the given formatter.

impl<T, S, T1, T2, T3, T4, T5, T6, T7, T8> IntoReactor<T, S> for OrChain<(T1, T2, T3, T4, T5, T6, T7, T8)>

where T: Clone, T1: Reactor<T, S>, T2: Reactor<T, S, Response = T1::Response>, T1::Error: From<T2::Error> + From<T3::Error> + From<T4::Error> + From<T5::Error> + From<T6::Error> + From<T7::Error> + From<T8::Error>, T3: Reactor<T, S, Response = T1::Response>, T4: Reactor<T, S, Response = T1::Response>, T5: Reactor<T, S, Response = T1::Response>, T6: Reactor<T, S, Response = T1::Response>, T7: Reactor<T, S, Response = T1::Response>, T8: Reactor<T, S, Response = T1::Response>,

type Reactor = Or<Or<Or<Or<Or<Or<Or<T1, T2>, T3>, T4>, T5>, T6>, T7>, T8>

fn into_reactor(self) -> Self::Reactor

impl<T, S, T2, T3, T4, T5, T6, T7, T8> IntoReactor<T, S> for OrChain<(T2, T3, T4, T5, T6, T7, T8)>

where T: Clone, T2: Reactor<T, S>, T3: Reactor<T, S, Response = T2::Response>, T2::Error: From<T3::Error> + From<T4::Error> + From<T5::Error> + From<T6::Error> + From<T7::Error> + From<T8::Error>, T4: Reactor<T, S, Response = T2::Response>, T5: Reactor<T, S, Response = T2::Response>, T6: Reactor<T, S, Response = T2::Response>, T7: Reactor<T, S, Response = T2::Response>, T8: Reactor<T, S, Response = T2::Response>,

type Reactor = Or<Or<Or<Or<Or<Or<T2, T3>, T4>, T5>, T6>, T7>, T8>

fn into_reactor(self) -> Self::Reactor

impl<T, S, T3, T4, T5, T6, T7, T8> IntoReactor<T, S> for OrChain<(T3, T4, T5, T6, T7, T8)>

where T: Clone, T3: Reactor<T, S>, T4: Reactor<T, S, Response = T3::Response>, T3::Error: From<T4::Error> + From<T5::Error> + From<T6::Error> + From<T7::Error> + From<T8::Error>, T5: Reactor<T, S, Response = T3::Response>, T6: Reactor<T, S, Response = T3::Response>, T7: Reactor<T, S, Response = T3::Response>, T8: Reactor<T, S, Response = T3::Response>,

type Reactor = Or<Or<Or<Or<Or<T3, T4>, T5>, T6>, T7>, T8>

fn into_reactor(self) -> Self::Reactor

impl<T, S, T4, T5, T6, T7, T8> IntoReactor<T, S> for OrChain<(T4, T5, T6, T7, T8)>

where T: Clone, T4: Reactor<T, S>, T5: Reactor<T, S, Response = T4::Response>, T4::Error: From<T5::Error> + From<T6::Error> + From<T7::Error> + From<T8::Error>, T6: Reactor<T, S, Response = T4::Response>, T7: Reactor<T, S, Response = T4::Response>, T8: Reactor<T, S, Response = T4::Response>,

type Reactor = Or<Or<Or<Or<T4, T5>, T6>, T7>, T8>

fn into_reactor(self) -> Self::Reactor

impl<T, S, T5, T6, T7, T8> IntoReactor<T, S> for OrChain<(T5, T6, T7, T8)>

where T: Clone, T5: Reactor<T, S>, T6: Reactor<T, S, Response = T5::Response>, T5::Error: From<T6::Error> + From<T7::Error> + From<T8::Error>, T7: Reactor<T, S, Response = T5::Response>, T8: Reactor<T, S, Response = T5::Response>,

type Reactor = Or<Or<Or<T5, T6>, T7>, T8>

fn into_reactor(self) -> Self::Reactor

impl<T, S, T6, T7, T8> IntoReactor<T, S> for OrChain<(T6, T7, T8)>

where T: Clone, T6: Reactor<T, S>, T7: Reactor<T, S, Response = T6::Response>, T6::Error: From<T7::Error> + From<T8::Error>, T8: Reactor<T, S, Response = T6::Response>,

type Reactor = Or<Or<T6, T7>, T8>

fn into_reactor(self) -> Self::Reactor

impl<T, S, T7, T8> IntoReactor<T, S> for OrChain<(T7, T8)>

where T: Clone, T7: Reactor<T, S>, T8: Reactor<T, S, Response = T7::Response>, T7::Error: From<T8::Error>,

type Reactor = Or<T7, T8>

fn into_reactor(self) -> Self::Reactor

impl<T, S, R> IntoReactor<T, S> for OrChain<Vec<R>>

where T: Clone, R: Reactor<T, S>,

type Reactor = OrChain<Dynamic<Vec<R>>>

fn into_reactor(self) -> Self::Reactor

impl<T, S, R> Reactor<T, S> for OrChain<Dynamic<Vec<R>>>

where T: Clone, R: Reactor<T, S>,

type Response = <R as Reactor<T, S>>::Response

The output type of successful responses from the reactor.

type Error = <R as Reactor<T, S>>::Error

The error type of failed responses from the reactor.

fn react( &mut self, event: Timed<Event<T>>, context: Context<'_, S>, ) -> Result<Self::Response, Self::Error>

Reacts to a timed Event.

fn map_response<P, F>(self, f: F) -> MapResponse<Self, F>

where Self: Sized, F: FnMut(Self::Response) -> P,

fn map_error<E, F>(self, f: F) -> MapError<Self, F>

where Self: Sized, F: FnMut(Self::Error) -> E,

fn respond<P>(self, response: P) -> Respond<Self, P>

where Self: Sized, P: Clone,

Reacts with this reactor and then responds with the given response, regardless of this reactor’s output.

fn fail<E>(self, error: E) -> Fail<Self, E>

where Self: Sized, E: Clone,

Reacts with this reactor and then fails with the given error, regardless of this reactor’s output.

fn then<R>(self, reactor: R) -> Then<Self, R>

where Self: Sized, T: Clone, R: Reactor<T, S>,

Reacts with this reactor and then the given reactor (regardless of outputs).

fn and<R>(self, reactor: R) -> And<Self, R>

where Self: Sized, Self::Error: From<R::Error>, T: Clone, R: Reactor<T, S>,

Reacts with this reactor and then the given reactor if and only if this reactor returns Ok.

fn or<R>(self, reactor: R) -> Or<Self, R>

where Self: Sized, T: Clone, R: Reactor<T, S, Response = Self::Response>,

Reacts with this reactor and then the given reactor if and only if this reactor returns Err.

fn inspect<F>( self, f: F, ) -> impl Reactor<T, S, Response = Self::Response, Error = Self::Error>

where Self: Sized, T: Clone, F: FnMut(&Timed<Event<T>>, &Result<Self::Response, Self::Error>),

Constructs a Reactor that inspects the event and output of self with the given function.

impl<R: Copy> Copy for OrChain<R>