[−][src]Trait reactor_rs::mono::Mono

pub trait Mono<T, E>: Publisher<Item = T, Error = E> {
    fn block(self) -> Result<Option<Self::Item>, Self::Error>
    where
        Self::Item: 'static + Send,
        Self::Error: 'static + Send,
        Self: Sized,
    { ... }

    fn do_on_error<F>(
        self, 
        f: F
    ) -> MonoDoOnError<Self::Item, Self::Error, Self, F>
    where
        F: 'static + Send + Fn(&Self::Error),
        Self: Sized,
    { ... }

    fn do_on_success<F>(self, f: F) -> Foreach<Self, Self::Item, F, Self::Error>
    where
        F: 'static + Send + Fn(&Self::Item),
        Self: Sized,
    { ... }

    fn do_on_complete<F>(
        self, 
        f: F
    ) -> MonoDoOnComplete<Self::Item, Self::Error, Self, F>
    where
        Self: Sized,
        F: 'static + Send + Fn(),
    { ... }

    fn map<A, F>(
        self, 
        transform: F
    ) -> MonoTransform<Self, Self::Item, A, F, Self::Error>
    where
        F: 'static + Send + Fn(Self::Item) -> A,
        Self: Sized,
    { ... }

    fn flatmap<A, M, F>(
        self, 
        mapper: F
    ) -> MonoFlatMap<Self::Item, A, Self::Error, Self, M, F>
    where
        Self: 'static + Send + Sized,
        Self::Item: 'static + Send,
        Self::Error: 'static + Send,
        A: 'static + Send,
        M: 'static + Send + Mono<A, Self::Error>,
        F: 'static + Send + Fn(Self::Item) -> M,
    { ... }

    fn do_finally<F>(
        self, 
        action: F
    ) -> MonoDoFinally<Self::Item, Self::Error, Self, F>
    where
        Self: Sized,
        F: 'static + Send + Fn(),
    { ... }

    fn filter<F>(
        self, 
        predicate: F
    ) -> MonoFilter<Self, Self::Item, F, Self::Error>
    where
        Self: Sized,
        F: 'static + Send + Fn(&Self::Item) -> bool,
    { ... }

    fn subscribe_on<C>(
        self, 
        scheduler: C
    ) -> MonoScheduleOn<Self::Item, Self::Error, Self, C>
    where
        Self: 'static + Send + Sized,
        C: Scheduler<Item = Self::Item, Error = Self::Error>,
    { ... }
}

Provided methods

fn block(self) -> Result<Option<Self::Item>, Self::Error> where
    Self::Item: 'static + Send,
    Self::Error: 'static + Send,
    Self: Sized, 

fn do_on_error<F>(self, f: F) -> MonoDoOnError<Self::Item, Self::Error, Self, F> where
    F: 'static + Send + Fn(&Self::Error),
    Self: Sized, 

fn do_on_success<F>(self, f: F) -> Foreach<Self, Self::Item, F, Self::Error> where
    F: 'static + Send + Fn(&Self::Item),
    Self: Sized, 

fn do_on_complete<F>(
    self,
    f: F
) -> MonoDoOnComplete<Self::Item, Self::Error, Self, F> where
    Self: Sized,
    F: 'static + Send + Fn(), 

fn map<A, F>(
    self,
    transform: F
) -> MonoTransform<Self, Self::Item, A, F, Self::Error> where
    F: 'static + Send + Fn(Self::Item) -> A,
    Self: Sized, 

fn flatmap<A, M, F>(
    self,
    mapper: F
) -> MonoFlatMap<Self::Item, A, Self::Error, Self, M, F> where
    Self: 'static + Send + Sized,
    Self::Item: 'static + Send,
    Self::Error: 'static + Send,
    A: 'static + Send,
    M: 'static + Send + Mono<A, Self::Error>,
    F: 'static + Send + Fn(Self::Item) -> M, 

fn do_finally<F>(
    self,
    action: F
) -> MonoDoFinally<Self::Item, Self::Error, Self, F> where
    Self: Sized,
    F: 'static + Send + Fn(), 

fn filter<F>(self, predicate: F) -> MonoFilter<Self, Self::Item, F, Self::Error> where
    Self: Sized,
    F: 'static + Send + Fn(&Self::Item) -> bool, 

fn subscribe_on<C>(
    self,
    scheduler: C
) -> MonoScheduleOn<Self::Item, Self::Error, Self, C> where
    Self: 'static + Send + Sized,
    C: Scheduler<Item = Self::Item, Error = Self::Error>, 

Loading content...

Implementors

impl<E> Mono<(), E> for MonoError<E>[src]

impl<M, T, F, E> Mono<T, E> for MonoFilter<M, T, F, E> where
    M: Mono<T, E> + Sized,
    F: 'static + Send + Fn(&T) -> bool, [src]

impl<M, T1, T2, F, E> Mono<T2, E> for MonoTransform<M, T1, T2, F, E> where
    T1: Send,
    T2: Send,
    M: Mono<T1, E> + Sized,
    F: 'static + Send + Fn(T1) -> T2, [src]

impl<T, E> Mono<T, E> for MonoJust<T, E> where
    T: Clone, [src]

impl<T, E, M, C> Mono<T, E> for MonoScheduleOn<T, E, M, C> where
    M: 'static + Send + Mono<T, E> + Sized,
    C: Scheduler<Item = T, Error = E> + Sized, [src]

impl<T, E, M, F> Mono<T, E> for MonoDoFinally<T, E, M, F> where
    M: Mono<T, E>,
    F: 'static + Send + Fn(), [src]

impl<T, E, M, F> Mono<T, E> for MonoDoOnComplete<T, E, M, F> where
    M: Mono<T, E>,
    F: 'static + Send + Fn(), [src]

impl<T, E, M, F> Mono<T, E> for MonoDoOnError<T, E, M, F> where
    M: Mono<T, E> + Sized,
    F: 'static + Send + Fn(&E), [src]

impl<T, G> Mono<T, ()> for MonoCreateSuccess<T, G> where
    G: Fn() -> T, [src]

impl<T, G, E> Mono<T, E> for MonoCreate<T, G, E> where
    G: Fn() -> Result<T, E>, [src]

impl<T1, T2, E, M1, M2, F> Mono<T2, E> for MonoFlatMap<T1, T2, E, M1, M2, F> where
    T1: 'static + Send,
    T2: 'static + Send,
    E: 'static + Send,
    M1: 'static + Send + Mono<T1, E>,
    M2: 'static + Send + Mono<T2, E>,
    F: 'static + Send + Fn(T1) -> M2, [src]

impl<Z, T, F, E> Mono<T, E> for Foreach<Z, T, F, E> where
    Z: Mono<T, E> + Sized,
    F: 'static + Send + Fn(&T), [src]

Loading content...