Trait RxObserver 

pub trait RxObserver: ObserverInput {
    // Required methods
    fn next(&mut self, next: Self::In);
    fn error(&mut self, error: Self::InError);
    fn complete(&mut self);
}

RxObserver

Signals & Channels

An RxObserver has three signal channels:

• next: carries value signals (Self::In)
• error: carries the terminal error signal (Self::InError)
• complete: carries the terminal success signal

Exactly one of error or complete may occur, and it may occur at most once.

It’s also possible that an observer observes no terminal signals if its subscription was cancelled before it could. Some infinitely producing observables (like interval) do not complete at all.

Example

#[derive(RxObserver)]
#[rx_in(i32)]
#[rx_in_error(String)]
struct Print;

// Implemented by the derive
// impl ObserverInput for Print {
//     type In = i32;
//     type InError = String;
// }

impl RxObserver for Print {
    fn next(&mut self, next: Self::In) {
        println!("next: {next}");
    }
    fn error(&mut self, error: Self::InError) {
        eprintln!("error: {error}");
    }
    fn complete(&mut self) {
        println!("complete");
    }
}

Required Methods

fn next(&mut self, next: Self::In)

Signals the next value.

fn error(&mut self, error: Self::InError)

Signals an error of upstream, no more next or complete calls are expected after this!

fn complete(&mut self)

Signals the completion of upstream, no more next or error calls are expected after this!

Implementations on Foreign Types

impl<Destination> RxObserver for Arc<Mutex<Destination>>

where Destination: RxObserver + SubscriptionLike + ?Sized,

fn next(&mut self, next: <Arc<Mutex<Destination>> as ObserverInput>::In)

fn error(&mut self, error: <Arc<Mutex<Destination>> as ObserverInput>::InError)

fn complete(&mut self)

impl<Destination> RxObserver for Arc<RwLock<Destination>>

where Destination: RxObserver + SubscriptionLike + ?Sized,

fn next(&mut self, next: <Arc<RwLock<Destination>> as ObserverInput>::In)

fn error(&mut self, error: <Arc<RwLock<Destination>> as ObserverInput>::InError)

fn complete(&mut self)

impl<Destination> RxObserver for Weak<Mutex<Destination>>

where Destination: RxObserver + SubscriptionLike + ?Sized,

fn next(&mut self, next: <Weak<Mutex<Destination>> as ObserverInput>::In)

fn error(&mut self, error: <Weak<Mutex<Destination>> as ObserverInput>::InError)

fn complete(&mut self)

impl<Destination> RxObserver for DematerializeSubscriber<Destination>

where Destination: Subscriber,

fn next( &mut self, notification: <DematerializeSubscriber<Destination> as ObserverInput>::In, )

fn error( &mut self, _error: <DematerializeSubscriber<Destination> as ObserverInput>::InError, )

fn complete(&mut self)

impl<Destination> RxObserver for EndWithSubscriber<Destination>

where Destination: Subscriber,

fn next(&mut self, next: <EndWithSubscriber<Destination> as ObserverInput>::In)

fn error( &mut self, error: <EndWithSubscriber<Destination> as ObserverInput>::InError, )

fn complete(&mut self)

impl<Destination> RxObserver for ErrorBoundarySubscriber<Destination>

where Destination: Subscriber<InError = Infallible>,

fn next( &mut self, next: <ErrorBoundarySubscriber<Destination> as ObserverInput>::In, )

fn error( &mut self, _error: <ErrorBoundarySubscriber<Destination> as ObserverInput>::InError, )

fn complete(&mut self)

impl<Destination> RxObserver for IdentitySubscriber<Destination>

where Destination: Subscriber,

fn next(&mut self, next: <IdentitySubscriber<Destination> as ObserverInput>::In)

fn error( &mut self, error: <IdentitySubscriber<Destination> as ObserverInput>::InError, )

fn complete(&mut self)

impl<Destination> RxObserver for LiftOptionSubscriber<Destination>

where Destination: Subscriber,

fn next( &mut self, next: <LiftOptionSubscriber<Destination> as ObserverInput>::In, )

fn error( &mut self, error: <LiftOptionSubscriber<Destination> as ObserverInput>::InError, )

fn complete(&mut self)

impl<Destination> RxObserver for MapNeverBothSubscriber<Destination>

where Destination: Subscriber,

fn next( &mut self, _next: <MapNeverBothSubscriber<Destination> as ObserverInput>::In, )

fn error( &mut self, _error: <MapNeverBothSubscriber<Destination> as ObserverInput>::InError, )

fn complete(&mut self)

impl<Destination> RxObserver for MapNeverErrorSubscriber<Destination>

where Destination: Subscriber,

fn next( &mut self, next: <MapNeverErrorSubscriber<Destination> as ObserverInput>::In, )

fn error( &mut self, _error: <MapNeverErrorSubscriber<Destination> as ObserverInput>::InError, )

fn complete(&mut self)

impl<Destination> RxObserver for MapNeverNextSubscriber<Destination>

where Destination: Subscriber,

fn next( &mut self, _next: <MapNeverNextSubscriber<Destination> as ObserverInput>::In, )

fn error( &mut self, error: <MapNeverNextSubscriber<Destination> as ObserverInput>::InError, )

fn complete(&mut self)

impl<Destination> RxObserver for SkipSubscriber<Destination>

where Destination: Subscriber,

fn next(&mut self, next: <SkipSubscriber<Destination> as ObserverInput>::In)

fn error( &mut self, error: <SkipSubscriber<Destination> as ObserverInput>::InError, )

fn complete(&mut self)

impl<Destination> RxObserver for TakeSubscriber<Destination>

where Destination: Subscriber,

fn next(&mut self, next: <TakeSubscriber<Destination> as ObserverInput>::In)

fn error( &mut self, error: <TakeSubscriber<Destination> as ObserverInput>::InError, )

fn complete(&mut self)

impl<Destination, O1, O2> RxObserver for CombineChangesSubscriber<Destination, O1, O2>

where Destination: Subscriber<In = (Change<<O1 as ObservableOutput>::Out>, Change<<O2 as ObservableOutput>::Out>)>, O1: 'static + Observable, <O1 as ObservableOutput>::Out: Clone, <O1 as ObservableOutput>::OutError: Into<<Destination as ObserverInput>::InError>, O2: 'static + Observable, <O2 as ObservableOutput>::Out: Clone, <O2 as ObservableOutput>::OutError: Into<<Destination as ObserverInput>::InError>,

fn next( &mut self, next: <CombineChangesSubscriber<Destination, O1, O2> as ObserverInput>::In, )

fn error( &mut self, _error: <CombineChangesSubscriber<Destination, O1, O2> as ObserverInput>::InError, )

fn complete(&mut self)

impl<Destination, O1, O2> RxObserver for CombineLatestSubscriber<Destination, O1, O2>

where Destination: Subscriber<In = (<O1 as ObservableOutput>::Out, <O2 as ObservableOutput>::Out)>, O1: 'static + Observable, <O1 as ObservableOutput>::Out: Clone, <O1 as ObservableOutput>::OutError: Into<<Destination as ObserverInput>::InError>, O2: 'static + Observable, <O2 as ObservableOutput>::Out: Clone, <O2 as ObservableOutput>::OutError: Into<<Destination as ObserverInput>::InError>,

fn next( &mut self, next: <CombineLatestSubscriber<Destination, O1, O2> as ObserverInput>::In, )

fn error( &mut self, _error: <CombineLatestSubscriber<Destination, O1, O2> as ObserverInput>::InError, )

fn complete(&mut self)

impl<Destination, O1, O2> RxObserver for JoinSubscriber<Destination, O1, O2>

where Destination: Subscriber<In = (<O1 as ObservableOutput>::Out, <O2 as ObservableOutput>::Out)>, O1: 'static + Observable, <O1 as ObservableOutput>::Out: Clone, <O1 as ObservableOutput>::OutError: Into<<Destination as ObserverInput>::InError>, O2: 'static + Observable, <O2 as ObservableOutput>::Out: Clone, <O2 as ObservableOutput>::OutError: Into<<Destination as ObserverInput>::InError>,

fn next( &mut self, next: <JoinSubscriber<Destination, O1, O2> as ObserverInput>::In, )

fn error( &mut self, _error: <JoinSubscriber<Destination, O1, O2> as ObserverInput>::InError, )

fn complete(&mut self)

impl<Destination, O1, O2> RxObserver for ZipSubscriber<Destination, O1, O2>

where Destination: Subscriber<In = (<O1 as ObservableOutput>::Out, <O2 as ObservableOutput>::Out)>, O1: 'static + Observable, <O1 as ObservableOutput>::Out: Clone, <O1 as ObservableOutput>::OutError: Into<<Destination as ObserverInput>::InError>, O2: 'static + Observable, <O2 as ObservableOutput>::Out: Clone, <O2 as ObservableOutput>::OutError: Into<<Destination as ObserverInput>::InError>,

fn next( &mut self, next: <ZipSubscriber<Destination, O1, O2> as ObserverInput>::In, )

fn error( &mut self, _error: <ZipSubscriber<Destination, O1, O2> as ObserverInput>::InError, )

fn complete(&mut self)

impl<Destination, S> RxObserver for DebounceTimeSubscriber<Destination, S>

where Destination: 'static + Subscriber, S: 'static + Scheduler + Send + Sync,

fn next( &mut self, next: <DebounceTimeSubscriber<Destination, S> as ObserverInput>::In, )

fn error( &mut self, error: <DebounceTimeSubscriber<Destination, S> as ObserverInput>::InError, )

fn complete(&mut self)

impl<Destination, S> RxObserver for DelaySubscriber<Destination, S>

where Destination: 'static + Subscriber, S: 'static + Scheduler + Send + Sync,

fn next(&mut self, next: <DelaySubscriber<Destination, S> as ObserverInput>::In)

fn error( &mut self, error: <DelaySubscriber<Destination, S> as ObserverInput>::InError, )

fn complete(&mut self)

impl<Destination, S> RxObserver for ObserveOnSubscriber<Destination, S>

where Destination: 'static + Subscriber, S: 'static + Scheduler + Send + Sync,

fn next( &mut self, next: <ObserveOnSubscriber<Destination, S> as ObserverInput>::In, )

fn error( &mut self, error: <ObserveOnSubscriber<Destination, S> as ObserverInput>::InError, )

fn complete(&mut self)

impl<Destination, S> RxObserver for ThrottleTimeSubscriber<Destination, S>

where Destination: 'static + Subscriber, S: 'static + Scheduler + Send + Sync,

fn next( &mut self, next: <ThrottleTimeSubscriber<Destination, S> as ObserverInput>::In, )

fn error( &mut self, error: <ThrottleTimeSubscriber<Destination, S> as ObserverInput>::InError, )

fn complete(&mut self)

impl<Filter, Destination> RxObserver for FilterSubscriber<Filter, Destination>

where Filter: for<'a> Fn(&'a <Destination as ObserverInput>::In, usize) -> bool + Send + Sync, Destination: Subscriber,

fn next( &mut self, next: <FilterSubscriber<Filter, Destination> as ObserverInput>::In, )

fn error( &mut self, error: <FilterSubscriber<Filter, Destination> as ObserverInput>::InError, )

fn complete(&mut self)

impl<In, Destination> RxObserver for BufferCountSubscriber<In, Destination>

where In: Signal, Destination: Subscriber<In = Vec<In>>,

fn next( &mut self, next: <BufferCountSubscriber<In, Destination> as ObserverInput>::In, )

fn error( &mut self, error: <BufferCountSubscriber<In, Destination> as ObserverInput>::InError, )

fn complete(&mut self)

impl<In, Destination> RxObserver for EnumerateSubscriber<In, Destination>

where In: Signal, Destination: Subscriber<In = (In, usize)>,

fn next( &mut self, next: <EnumerateSubscriber<In, Destination> as ObserverInput>::In, )

fn error( &mut self, error: <EnumerateSubscriber<In, Destination> as ObserverInput>::InError, )

fn complete(&mut self)

impl<In, Destination> RxObserver for IsEmptySubscriber<In, Destination>

where In: Signal, Destination: Subscriber<In = bool>,

fn next( &mut self, _next: <IsEmptySubscriber<In, Destination> as ObserverInput>::In, )

fn error( &mut self, error: <IsEmptySubscriber<In, Destination> as ObserverInput>::InError, )

fn complete(&mut self)

impl<In, Destination> RxObserver for PairwiseSubscriber<In, Destination>

where In: Signal + Clone, Destination: Subscriber<In = [In; 2]>,

fn next( &mut self, next: <PairwiseSubscriber<In, Destination> as ObserverInput>::In, )

fn error( &mut self, error: <PairwiseSubscriber<In, Destination> as ObserverInput>::InError, )

fn complete(&mut self)

impl<In, ErrorDestination> RxObserver for WithLatestFromInnerDestination<In, ErrorDestination>

where In: Signal, ErrorDestination: 'static + Subscriber,

fn next( &mut self, next: <WithLatestFromInnerDestination<In, ErrorDestination> as ObserverInput>::In, )

fn error( &mut self, error: <WithLatestFromInnerDestination<In, ErrorDestination> as ObserverInput>::InError, )

fn complete(&mut self)

impl<In, InError, Destination> RxObserver for CountSubscriber<In, InError, Destination>

where In: Signal, InError: Signal, Destination: Subscriber<In = usize, InError = InError>,

fn next( &mut self, _next: <CountSubscriber<In, InError, Destination> as ObserverInput>::In, )

fn error( &mut self, error: <CountSubscriber<In, InError, Destination> as ObserverInput>::InError, )

fn complete(&mut self)

impl<In, InError, Destination> RxObserver for ElementAtSubscriber<In, InError, Destination>

where In: Signal, InError: Signal, Destination: Subscriber<In = In, InError = ElementAtOperatorError<InError>>,

fn next( &mut self, next: <ElementAtSubscriber<In, InError, Destination> as ObserverInput>::In, )

fn error( &mut self, error: <ElementAtSubscriber<In, InError, Destination> as ObserverInput>::InError, )

fn complete(&mut self)

impl<In, InError, Destination> RxObserver for IntoResultSubscriber<In, InError, Destination>

where In: Signal, InError: Signal, Destination: Subscriber<In = Result<In, InError>>,

fn next( &mut self, next: <IntoResultSubscriber<In, InError, Destination> as ObserverInput>::In, )

fn error( &mut self, error: <IntoResultSubscriber<In, InError, Destination> as ObserverInput>::InError, )

fn complete(&mut self)

impl<In, InError, Destination> RxObserver for MaterializeSubscriber<In, InError, Destination>

where In: Signal, InError: Signal, Destination: Subscriber<In = ObserverNotification<In, InError>, InError = Infallible>,

fn next( &mut self, next: <MaterializeSubscriber<In, InError, Destination> as ObserverInput>::In, )

fn error( &mut self, error: <MaterializeSubscriber<In, InError, Destination> as ObserverInput>::InError, )

fn complete(&mut self)

impl<In, InError, ErrorMapper, OutError, Destination> RxObserver for MapErrorSubscriber<In, InError, ErrorMapper, OutError, Destination>

where In: Signal, InError: Signal, ErrorMapper: FnOnce(InError) -> OutError + Send + Sync, OutError: Signal, Destination: Subscriber<In = In, InError = OutError>,

fn next( &mut self, next: <MapErrorSubscriber<In, InError, ErrorMapper, OutError, Destination> as ObserverInput>::In, )

fn error( &mut self, error: <MapErrorSubscriber<In, InError, ErrorMapper, OutError, Destination> as ObserverInput>::InError, )

fn complete(&mut self)

impl<In, InError, Fallback, Destination, S> RxObserver for FallbackWhenSilentSubscriber<In, InError, Fallback, Destination, S>

where In: Signal, InError: Signal, Fallback: 'static + Fn(<S as WithWorkInputOutput>::Tick, &mut <<S as WithWorkContextProvider>::WorkContextProvider as WorkContextProvider>::Item<'_>, usize) -> In + Send + Sync, Destination: Subscriber<In = In, InError = InError>, S: Scheduler,

fn next( &mut self, next: <FallbackWhenSilentSubscriber<In, InError, Fallback, Destination, S> as ObserverInput>::In, )

fn error( &mut self, error: <FallbackWhenSilentSubscriber<In, InError, Fallback, Destination, S> as ObserverInput>::InError, )

fn complete(&mut self)

impl<In, InError, HigherOrderSubscriber, ErrorMapper, Destination> RxObserver for HigherOrderAllSubscriber<In, InError, HigherOrderSubscriber, ErrorMapper, Destination>

where In: Signal + Observable, InError: Signal, HigherOrderSubscriber: HigherOrderSubscriberProvider, ErrorMapper: 'static + FnOnce(InError) -> <In as ObservableOutput>::OutError + Send + Sync, Destination: 'static + Subscriber<In = <In as ObservableOutput>::Out, InError = <In as ObservableOutput>::OutError>,

fn error( &mut self, error: <HigherOrderAllSubscriber<In, InError, HigherOrderSubscriber, ErrorMapper, Destination> as ObserverInput>::InError, )

For upstream errors

fn next( &mut self, next: <HigherOrderAllSubscriber<In, InError, HigherOrderSubscriber, ErrorMapper, Destination> as ObserverInput>::In, )

fn complete(&mut self)

impl<In, InError, InnerObservable, ErrorMapper, Destination> RxObserver for CatchSubscriber<In, InError, InnerObservable, ErrorMapper, Destination>

where In: Signal, InError: Signal, InnerObservable: Observable<Out = In> + Signal, ErrorMapper: 'static + FnOnce(InError) -> InnerObservable + Send + Sync, Destination: 'static + Subscriber<In = In, InError = <InnerObservable as ObservableOutput>::OutError>,

fn next( &mut self, next: <CatchSubscriber<In, InError, InnerObservable, ErrorMapper, Destination> as ObserverInput>::In, )

fn error( &mut self, error: <CatchSubscriber<In, InError, InnerObservable, ErrorMapper, Destination> as ObserverInput>::InError, )

fn complete(&mut self)

impl<In, InError, Mapper, InnerObservable, HigherOrderSubscriber, ErrorMapper, Destination> RxObserver for HigherOrderMapSubscriber<In, InError, Mapper, InnerObservable, HigherOrderSubscriber, ErrorMapper, Destination>

where In: Signal, InError: Signal, Mapper: FnMut(In) -> InnerObservable, InnerObservable: Observable + Signal, HigherOrderSubscriber: HigherOrderSubscriberProvider, ErrorMapper: 'static + FnOnce(InError) -> <InnerObservable as ObservableOutput>::OutError + Send + Sync, Destination: 'static + Subscriber<In = <InnerObservable as ObservableOutput>::Out, InError = <InnerObservable as ObservableOutput>::OutError>,

fn error( &mut self, error: <HigherOrderMapSubscriber<In, InError, Mapper, InnerObservable, HigherOrderSubscriber, ErrorMapper, Destination> as ObserverInput>::InError, )

For upstream errors

fn next( &mut self, next: <HigherOrderMapSubscriber<In, InError, Mapper, InnerObservable, HigherOrderSubscriber, ErrorMapper, Destination> as ObserverInput>::In, )

fn complete(&mut self)

impl<In, InError, Mapper, Out, Destination> RxObserver for MapSubscriber<In, InError, Mapper, Out, Destination>

where In: Signal, InError: Signal, Mapper: Fn(In) -> Out + Send + Sync, Out: Signal, Destination: Subscriber<In = Out, InError = InError>,

fn next( &mut self, next: <MapSubscriber<In, InError, Mapper, Out, Destination> as ObserverInput>::In, )

fn error( &mut self, error: <MapSubscriber<In, InError, Mapper, Out, Destination> as ObserverInput>::InError, )

fn complete(&mut self)

impl<In, InError, OnNext, Destination> RxObserver for TapNextSubscriber<In, InError, OnNext, Destination>

where OnNext: 'static + FnMut(&In) + Send + Sync, Destination: Subscriber<In = In, InError = InError>, In: Signal, InError: Signal,

fn next( &mut self, next: <TapNextSubscriber<In, InError, OnNext, Destination> as ObserverInput>::In, )

fn error( &mut self, error: <TapNextSubscriber<In, InError, OnNext, Destination> as ObserverInput>::InError, )

fn complete(&mut self)

impl<In, InError, Out, OutError, Destination> RxObserver for MapIntoSubscriber<In, InError, Out, OutError, Destination>

where In: Signal + Into<Out>, InError: Signal + Into<OutError>, Out: Signal, OutError: Signal, Destination: Subscriber<In = Out, InError = OutError>,

fn next( &mut self, next: <MapIntoSubscriber<In, InError, Out, OutError, Destination> as ObserverInput>::In, )

fn error( &mut self, error: <MapIntoSubscriber<In, InError, Out, OutError, Destination> as ObserverInput>::InError, )

fn complete(&mut self)

impl<In, InError, P, Destination> RxObserver for FindIndexSubscriber<In, InError, P, Destination>

where In: Signal, InError: Signal, P: Fn(&In) -> bool, Destination: Subscriber<In = usize, InError = FindIndexOperatorError<InError>>,

fn next( &mut self, next: <FindIndexSubscriber<In, InError, P, Destination> as ObserverInput>::In, )

fn error( &mut self, error: <FindIndexSubscriber<In, InError, P, Destination> as ObserverInput>::InError, )

fn complete(&mut self)

impl<In, InError, Reducer, Out, Destination> RxObserver for ReduceSubscriber<In, InError, Reducer, Out, Destination>

where In: Signal, InError: Signal, Reducer: Fn(&Out, In) -> Out + Send + Sync, Out: Signal + Clone, Destination: Subscriber<In = Out, InError = InError>,

fn next( &mut self, next: <ReduceSubscriber<In, InError, Reducer, Out, Destination> as ObserverInput>::In, )

fn error( &mut self, error: <ReduceSubscriber<In, InError, Reducer, Out, Destination> as ObserverInput>::InError, )

fn complete(&mut self)

impl<In, InError, Reducer, Out, Destination> RxObserver for ScanSubscriber<In, InError, Reducer, Out, Destination>

where In: Signal, InError: Signal, Reducer: Fn(&Out, In) -> Out + Send + Sync, Out: Signal + Clone, Destination: Subscriber<In = Out, InError = InError>,

fn next( &mut self, next: <ScanSubscriber<In, InError, Reducer, Out, Destination> as ObserverInput>::In, )

fn error( &mut self, error: <ScanSubscriber<In, InError, Reducer, Out, Destination> as ObserverInput>::InError, )

fn complete(&mut self)

impl<In, InError, S> RxObserver for Box<S>

where In: Signal, InError: Signal, S: Subscriber<In = In, InError = InError> + Send + Sync + ?Sized,

fn next(&mut self, next: <Box<S> as ObserverInput>::In)

fn error(&mut self, error: <Box<S> as ObserverInput>::InError)

fn complete(&mut self)

impl<In, InnerObservable, Destination> RxObserver for WithLatestFromSubscriber<In, InnerObservable, Destination>

where In: Signal, InnerObservable: Observable, <InnerObservable as ObservableOutput>::Out: Clone, Destination: Subscriber<In = (In, <InnerObservable as ObservableOutput>::Out), InError = <InnerObservable as ObservableOutput>::OutError>,

fn next( &mut self, next: <WithLatestFromSubscriber<In, InnerObservable, Destination> as ObserverInput>::In, )

fn error( &mut self, error: <WithLatestFromSubscriber<In, InnerObservable, Destination> as ObserverInput>::InError, )

fn complete(&mut self)

impl<InError, Destination> RxObserver for FirstSubscriber<InError, Destination>

where InError: Signal, Destination: Subscriber<InError = FirstOperatorError<InError>>,

fn next( &mut self, next: <FirstSubscriber<InError, Destination> as ObserverInput>::In, )

fn error( &mut self, error: <FirstSubscriber<InError, Destination> as ObserverInput>::InError, )

fn complete(&mut self)

impl<InError, Destination, S> RxObserver for AdsrSubscriber<InError, Destination, S>

where InError: Signal, Destination: Subscriber<In = AdsrSignal, InError = InError>, S: Scheduler,

fn next( &mut self, next: <AdsrSubscriber<InError, Destination, S> as ObserverInput>::In, )

fn error( &mut self, error: <AdsrSubscriber<InError, Destination, S> as ObserverInput>::InError, )

fn complete(&mut self)

impl<InError, P, Destination> RxObserver for FindSubscriber<InError, P, Destination>

where InError: Signal, P: Fn(&<Destination as ObserverInput>::In) -> bool, Destination: Subscriber<InError = FindOperatorError<InError>>,

fn next( &mut self, next: <FindSubscriber<InError, P, Destination> as ObserverInput>::In, )

fn error( &mut self, error: <FindSubscriber<InError, P, Destination> as ObserverInput>::InError, )

fn complete(&mut self)

impl<Inner, Destination> RxObserver for CompositeSubscriber<Inner, Destination>

where Inner: Subscriber, Destination: RxObserver,

fn next( &mut self, next: <CompositeSubscriber<Inner, Destination> as ObserverInput>::In, )

fn error( &mut self, error: <CompositeSubscriber<Inner, Destination> as ObserverInput>::InError, )

fn complete(&mut self)

impl<InnerObservable, Destination> RxObserver for ConcurrentSubscriber<InnerObservable, Destination>

where InnerObservable: Observable<Out = <Destination as ObserverInput>::In, OutError = <Destination as ObserverInput>::InError> + Signal, Destination: 'static + Subscriber,

fn next( &mut self, next: <ConcurrentSubscriber<InnerObservable, Destination> as ObserverInput>::In, )

fn error( &mut self, error: <ConcurrentSubscriber<InnerObservable, Destination> as ObserverInput>::InError, )

fn complete(&mut self)

impl<InnerObservable, Destination> RxObserver for ExhaustSubscriber<InnerObservable, Destination>

where InnerObservable: Observable + Signal, Destination: 'static + Subscriber<In = <InnerObservable as ObservableOutput>::Out, InError = <InnerObservable as ObservableOutput>::OutError>,

fn next( &mut self, next: <ExhaustSubscriber<InnerObservable, Destination> as ObserverInput>::In, )

fn error( &mut self, error: <ExhaustSubscriber<InnerObservable, Destination> as ObserverInput>::InError, )

fn complete(&mut self)

impl<InnerObservable, Destination> RxObserver for SwitchSubscriber<InnerObservable, Destination>

where InnerObservable: Observable + Signal, Destination: 'static + Subscriber<In = <InnerObservable as ObservableOutput>::Out, InError = <InnerObservable as ObservableOutput>::OutError>,

fn next( &mut self, next: <SwitchSubscriber<InnerObservable, Destination> as ObserverInput>::In, )

fn error( &mut self, error: <SwitchSubscriber<InnerObservable, Destination> as ObserverInput>::InError, )

fn complete(&mut self)

impl<O> RxObserver for Option<O>

where O: RxObserver,

fn next(&mut self, next: <Option<O> as ObserverInput>::In)

fn error(&mut self, error: <Option<O> as ObserverInput>::InError)

fn complete(&mut self)

impl<OnNext, Destination> RxObserver for OnNextSubscriber<OnNext, Destination>

where OnNext: 'static + FnMut(&<Destination as ObserverInput>::In, &mut dyn Subscriber<In = <Destination as ObserverInput>::In, InError = <Destination as ObserverInput>::InError>) -> bool + Send + Sync, Destination: Subscriber,

fn next( &mut self, next: <OnNextSubscriber<OnNext, Destination> as ObserverInput>::In, )

fn error( &mut self, error: <OnNextSubscriber<OnNext, Destination> as ObserverInput>::InError, )

fn complete(&mut self)

impl<ResultIn, ResultInError, InError, Destination> RxObserver for LiftResultSubscriber<ResultIn, ResultInError, InError, Destination>

where ResultIn: Signal, ResultInError: Signal, InError: Signal, Destination: Subscriber<In = ResultIn, InError = ResultInError>,

fn next( &mut self, next: <LiftResultSubscriber<ResultIn, ResultInError, InError, Destination> as ObserverInput>::In, )

fn error( &mut self, _error: <LiftResultSubscriber<ResultIn, ResultInError, InError, Destination> as ObserverInput>::InError, )

fn complete(&mut self)

impl<State, OnComplete, OnUnsubscribe, Destination> RxObserver for HigherOrderInnerSubscriber<State, OnComplete, OnUnsubscribe, Destination>

where State: HigherOrderSubscriberStateConditions, OnComplete: FnOnce(usize), OnUnsubscribe: FnOnce(usize), Destination: 'static + Subscriber,

fn next( &mut self, next: <HigherOrderInnerSubscriber<State, OnComplete, OnUnsubscribe, Destination> as ObserverInput>::In, )

fn error( &mut self, error: <HigherOrderInnerSubscriber<State, OnComplete, OnUnsubscribe, Destination> as ObserverInput>::InError, )

fn complete(&mut self)

impl<TapDestination, Destination> RxObserver for TapSubscriber<TapDestination, Destination>

where TapDestination: 'static + RxObserver<In = <Destination as ObserverInput>::In, InError = <Destination as ObserverInput>::InError> + Send + Sync, Destination: Subscriber, <Destination as ObserverInput>::In: Clone, <Destination as ObserverInput>::InError: Clone,

fn next( &mut self, next: <TapSubscriber<TapDestination, Destination> as ObserverInput>::In, )

fn error( &mut self, error: <TapSubscriber<TapDestination, Destination> as ObserverInput>::InError, )

fn complete(&mut self)

impl<VariantSelector, Destination, O1, O2> RxObserver for EitherSubscriber2<VariantSelector, Destination, O1, O2>

where VariantSelector: EitherNotificationSelector2<O1, O2>, Destination: Subscriber<In = EitherObservableNotification2<O1, O2>>, O1: Observable, <O1 as ObservableOutput>::OutError: Into<<Destination as ObserverInput>::InError>, O2: Observable, <O2 as ObservableOutput>::OutError: Into<<Destination as ObserverInput>::InError>,

fn next( &mut self, next: <EitherSubscriber2<VariantSelector, Destination, O1, O2> as ObserverInput>::In, )

fn error( &mut self, error: <EitherSubscriber2<VariantSelector, Destination, O1, O2> as ObserverInput>::InError, )

fn complete(&mut self)

Implementors

impl<Destination> RxObserver for ObserverSubscriber<Destination>

where Destination: RxObserver,

impl<Destination> RxObserver for SharedSubscriber<Destination>

where Destination: 'static + Subscriber + Send + Sync,

impl<In, InError> RxObserver for DynFnObserver<In, InError>

where In: Signal, InError: Signal,

impl<In, InError> RxObserver for NoopObserver<In, InError>

where In: Signal, InError: Signal,

impl<In, InError> RxObserver for PrintObserver<In, InError>

where In: Signal + Debug, InError: Signal + Debug,

impl<In, InError> RxObserver for ErasedSubscriber<In, InError>

where In: Signal, InError: Signal,

impl<In, InError> RxObserver for BehaviorSubject<In, InError>

where In: Signal + Clone, InError: Signal + Clone,

impl<In, InError> RxObserver for PublishSubject<In, InError>

where In: Signal + Clone, InError: Signal + Clone,

impl<In, InError, OnNext, OnError, OnComplete> RxObserver for FnObserver<In, InError, OnNext, OnError, OnComplete>

where In: Signal, InError: Signal, OnNext: 'static + FnMut(In) + Send + Sync, OnError: 'static + FnOnce(InError) + Send + Sync, OnComplete: 'static + FnOnce() + Send + Sync,

impl<In, InError, Reducer> RxObserver for AsyncSubject<In, InError, Reducer>

where Reducer: 'static + FnMut(In, In) -> In + Send + Sync, In: Signal + Clone, InError: Signal + Clone,

impl<InnerSubscriber, Destination> RxObserver for OptionSubscriber<InnerSubscriber, Destination>

where InnerSubscriber: Subscriber, Destination: Subscriber<In = <InnerSubscriber as ObserverInput>::In, InError = <InnerSubscriber as ObserverInput>::InError>, <InnerSubscriber as ObserverInput>::In: 'static, <InnerSubscriber as ObserverInput>::InError: 'static,

impl<Provenance, In, InError> RxObserver for ProvenanceSubject<Provenance, In, InError>

where Provenance: Signal + Clone + PartialEq, In: Signal + Clone, InError: Signal + Clone,

impl<const CAPACITY: usize, In, InError> RxObserver for ReplaySubject<CAPACITY, In, InError>

where In: Signal + Clone, InError: Signal + Clone,