Struct Fail 

pub struct Fail<R, E> { /* private fields */ }

Trait Implementations

impl<R: Clone, E: Clone> Clone for Fail<R, E>

fn clone(&self) -> Fail<R, E>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<R: Debug, E: Debug> Debug for Fail<R, E>

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

Formats the value using the given formatter.

impl<T, S, E, R> Reactor<T, S> for Fail<R, E>

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

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

The output type of successful responses from the reactor.

type Error = E

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, E: Copy> Copy for Fail<R, E>