Skip to main content

FallbackWhenSilentOperator

rx_core::operator

Struct FallbackWhenSilentOperator 

Source 
pub struct FallbackWhenSilentOperator<In, InError, Fallback, S>
where
    In: Signal,
    InError: Signal,
    Fallback: 'static + Fn(<S as WithWorkInputOutput>::Tick, &mut <<S as WithWorkContextProvider>::WorkContextProvider as WorkContextProvider>::Item<'_>, usize) -> In + Clone + Send + Sync,
    S: Scheduler,
{ /* private fields */ }
Expand description

The FallbackWhenSilentOperator calls into() to map incoming values to the expected output value, provided From is implemented on the downstream type. When In and Out, as well as InError and OutError, are the same types, it is equivalent to the identity operator and is a no-op.

Implementations§

Source§

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

Source

pub fn new( fallback: Fallback, scheduler: SchedulerHandle<S>, ) -> FallbackWhenSilentOperator<In, InError, Fallback, S>

Trait Implementations§

Source§

impl<In, InError, Fallback, S> ComposableOperator for FallbackWhenSilentOperator<In, InError, Fallback, S>
where In: Signal, InError: Signal, Fallback: 'static + Fn(<S as WithWorkInputOutput>::Tick, &mut <<S as WithWorkContextProvider>::WorkContextProvider as WorkContextProvider>::Item<'_>, usize) -> In + Clone + Send + Sync, S: 'static + Scheduler + Send,

Source§

type Subscriber<Destination: 'static + Subscriber<In = <FallbackWhenSilentOperator<In, InError, Fallback, S> as ObservableOutput>::Out, InError = <FallbackWhenSilentOperator<In, InError, Fallback, S> as ObservableOutput>::OutError> + Send + Sync> = FallbackWhenSilentSubscriber<In, InError, Fallback, Destination, S>

Source§

fn operator_subscribe<Destination>( &mut self, destination: Destination, ) -> <FallbackWhenSilentOperator<In, InError, Fallback, S> as ComposableOperator>::Subscriber<Destination>
where Destination: 'static + Subscriber<In = <FallbackWhenSilentOperator<In, InError, Fallback, S> as ObservableOutput>::Out, InError = <FallbackWhenSilentOperator<In, InError, Fallback, S> as ObservableOutput>::OutError> + Send + Sync,

Source§

impl<In, InError, Fallback, S> ObservableOutput for FallbackWhenSilentOperator<In, InError, Fallback, S>
where In: Signal, InError: Signal, Fallback: 'static + Fn(<S as WithWorkInputOutput>::Tick, &mut <<S as WithWorkContextProvider>::WorkContextProvider as WorkContextProvider>::Item<'_>, usize) -> In + Clone + Send + Sync, S: Scheduler,

Source§

type Out = In

Source§

type OutError = InError

Source§

impl<In, InError, Fallback, S> ObserverInput for FallbackWhenSilentOperator<In, InError, Fallback, S>
where In: Signal, InError: Signal, Fallback: 'static + Fn(<S as WithWorkInputOutput>::Tick, &mut <<S as WithWorkContextProvider>::WorkContextProvider as WorkContextProvider>::Item<'_>, usize) -> In + Clone + Send + Sync, S: Scheduler,

Source§

type In = In

Source§

type InError = InError

Source§

impl<In, InError, Fallback, S> WithPrimaryCategory for FallbackWhenSilentOperator<In, InError, Fallback, S>
where In: Signal, InError: Signal, Fallback: 'static + Fn(<S as WithWorkInputOutput>::Tick, &mut <<S as WithWorkContextProvider>::WorkContextProvider as WorkContextProvider>::Item<'_>, usize) -> In + Clone + Send + Sync, S: Scheduler,

Source§

type PrimaryCategory = PrimaryCategoryOperator

Auto Trait Implementations§

§

impl<In, InError, Fallback, S> Freeze for FallbackWhenSilentOperator<In, InError, Fallback, S>
where Fallback: Freeze,

§

impl<In, InError, Fallback, S> RefUnwindSafe for FallbackWhenSilentOperator<In, InError, Fallback, S>
where Fallback: RefUnwindSafe,

§

impl<In, InError, Fallback, S> Send for FallbackWhenSilentOperator<In, InError, Fallback, S>

§

impl<In, InError, Fallback, S> Sync for FallbackWhenSilentOperator<In, InError, Fallback, S>

§

impl<In, InError, Fallback, S> Unpin for FallbackWhenSilentOperator<In, InError, Fallback, S>
where Fallback: Unpin,

§

impl<In, InError, Fallback, S> UnwindSafe for FallbackWhenSilentOperator<In, InError, Fallback, S>
where Fallback: UnwindSafe,

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> Downcast for T
where T: Any,

Source§

fn into_any(self: Box<T>) -> Box<dyn Any>

Converts Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>, which can then be downcast into Box<dyn ConcreteType> where ConcreteType implements Trait.
Source§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Converts Rc<Trait> (where Trait: Downcast) to Rc<Any>, which can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
Source§

fn as_any(&self) -> &(dyn Any + 'static)

Converts &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.
Source§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Converts &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
Source§

impl<T> DowncastSend for T
where T: Any + Send,

Source§

fn into_any_send(self: Box<T>) -> Box<dyn Any + Send>

Converts Box<Trait> (where Trait: DowncastSend) to Box<dyn Any + Send>, which can then be downcast into Box<ConcreteType> where ConcreteType implements Trait.
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

impl<T> IntoResult<T> for T

Source§

fn into_result(self) -> Result<T, RunSystemError>

Converts this type into the system output type.
Source§

impl<'o, Op> Operator<'o> for Op
where Op: 'static + ComposableOperator,

Source§

type OutObservable<InObservable: 'o + Observable<Out = <Op as ObserverInput>::In, OutError = <Op as ObserverInput>::InError> + Send + Sync> = Pipe<InObservable, Op>

Source§

fn operate<InObservable>( self, source: InObservable, ) -> <Op as Operator<'o>>::OutObservable<InObservable>
where InObservable: 'o + Observable<Out = <Op as ObserverInput>::In, OutError = <Op as ObserverInput>::InError> + Send + Sync,

Source§

impl<Op> OperatorComposeExtension for Op
where Op: ComposableOperator,

Source§

fn compose_with<NextOp>( self, next_operator: NextOp, ) -> CompositeOperator<Self, NextOp>
where NextOp: ComposableOperator<In = Self::Out, InError = Self::OutError>,

Source§

impl<Op> OperatorComposeExtensionAdsr for Op
where Op: ComposableOperator<Out = AdsrTrigger>,

Source§

fn adsr<S>( self, options: AdsrOperatorOptions, scheduler: SchedulerHandle<S>, ) -> CompositeOperator<Self, AdsrOperator<Self::OutError, S>>
where S: 'static + Scheduler,

Source§

impl<Op> OperatorComposeExtensionBufferCount for Op
where Op: ComposableOperator,

Source§

fn buffer_count( self, buffer_size: usize, ) -> CompositeOperator<Self, BufferCountOperator<Self::Out, Self::OutError>>

Source§

impl<Op> OperatorComposeExtensionCatch for Op
where Op: ComposableOperator,

Source§

fn catch<NextInnerObservable, OnError>( self, on_error: OnError, ) -> CompositeOperator<Self, CatchOperator<Self::Out, Self::OutError, OnError, NextInnerObservable>>
where NextInnerObservable: Observable<Out = Self::Out> + Signal, OnError: 'static + FnOnce(Self::OutError) -> NextInnerObservable + Clone + Send + Sync,

Source§

impl<Op> OperatorComposeExtensionConcatAll for Op
where Op: ComposableOperator,

Source§

fn concat_all<ErrorMapper>( self, error_mapper: ErrorMapper, ) -> CompositeOperator<Self, ConcatAllOperator<Self::Out, Self::OutError, ErrorMapper>>
where ErrorMapper: 'static + Fn(Self::OutError) -> <Self::Out as ObservableOutput>::OutError + Clone + Send + Sync, Self::Out: Observable, Self::OutError: Into<<Self::Out as ObservableOutput>::OutError>,

Source§

impl<Op> OperatorComposeExtensionConcatMap for Op
where Op: ComposableOperator,

Source§

fn concat_map<NextInnerObservable, Mapper, ErrorMapper>( self, mapper: Mapper, error_mapper: ErrorMapper, ) -> CompositeOperator<Self, ConcatMapOperator<Self::Out, Self::OutError, Mapper, ErrorMapper, NextInnerObservable>>
where NextInnerObservable: Observable + Signal, Mapper: 'static + Fn(Self::Out) -> NextInnerObservable + Clone + Send + Sync, ErrorMapper: 'static + FnOnce(Self::OutError) -> <NextInnerObservable as ObservableOutput>::OutError + Clone + Send + Sync, Self::OutError: Into<<NextInnerObservable as ObservableOutput>::OutError>,

Source§

impl<Op> OperatorComposeExtensionCount for Op
where Op: ComposableOperator,

Source§

fn count( self, ) -> CompositeOperator<Self, CountOperator<Self::Out, Self::OutError>>

CountOperator Read more
Source§

impl<Op, T, S> OperatorComposeExtensionDebounceTime<T, S> for Op
where Op: ComposableOperator<Out = T>, T: Signal, S: 'static + Scheduler + Send + Sync,

Source§

fn debounce_time( self, duration: Duration, scheduler: SchedulerHandle<S>, ) -> CompositeOperator<Self, DebounceTimeOperator<T, Self::OutError, S>>

DebounceTimeOperator Read more
Source§

impl<Op, T, S> OperatorComposeExtensionDelay<T, S> for Op
where Op: ComposableOperator<Out = T>, T: Signal, S: 'static + Scheduler + Send + Sync,

Source§

fn delay( self, duration: Duration, scheduler: SchedulerHandle<S>, ) -> CompositeOperator<Self, DelayOperator<T, Self::OutError, S>>

DelayOperator Read more
Source§

impl<Op, In, InError> OperatorComposeExtensionDematerialize<In, InError> for Op
where Op: ComposableOperator<Out = ObserverNotification<In, InError>, OutError = Infallible>, In: Signal, InError: Signal,

Source§

fn dematerialize( self, ) -> CompositeOperator<Self, DematerializeOperator<In, InError>>

Source§

impl<Op> OperatorComposeExtensionElementAt for Op
where Op: ComposableOperator,

Source§

fn element_at( self, index: usize, ) -> CompositeOperator<Self, ElementAtOperator<Self::Out, Self::OutError>>

ElementAtOperator Read more
Source§

fn element_at_or_else<P>( self, index: usize, default_value: P, ) -> CompositeOperator<Self, ElementAtOperator<Self::Out, Self::OutError>>
where P: 'static + Provider<Provided = Self::Out> + Send + Sync,

ElementAtOperator Read more
Source§

impl<Op> OperatorComposeExtensionEndWith for Op
where Op: ComposableOperator,

Source§

fn end_with( self, end_with: Self::Out, ) -> CompositeOperator<Self, EndWithOperator<Self::Out, Self::OutError>>
where Self::Out: Clone,

Source§

impl<Op> OperatorComposeExtensionEnumerate for Op
where Op: ComposableOperator,

Source§

fn enumerate( self, ) -> CompositeOperator<Self, EnumerateOperator<Self::Out, Self::OutError>>

Source§

impl<Op> OperatorComposeExtensionErrorBoundary for Op
where Op: ComposableOperator<OutError = Infallible>,

Source§

fn error_boundary( self, ) -> CompositeOperator<Self, ErrorBoundaryOperator<Self::Out>>

Source§

impl<Op> OperatorComposeExtensionExhaustAll for Op
where Op: ComposableOperator,

Source§

fn exhaust_all<ErrorMapper>( self, error_mapper: ErrorMapper, ) -> CompositeOperator<Self, ExhaustAllOperator<Self::Out, Self::OutError, ErrorMapper>>
where ErrorMapper: 'static + Fn(Self::OutError) -> <Self::Out as ObservableOutput>::OutError + Clone + Send + Sync, Self::Out: Observable, Self::OutError: Into<<Self::Out as ObservableOutput>::OutError>,

Source§

impl<Op> OperatorComposeExtensionExhaustMap for Op
where Op: ComposableOperator,

Source§

fn exhaust_map<NextInnerObservable, Mapper, ErrorMapper>( self, mapper: Mapper, error_mapper: ErrorMapper, ) -> CompositeOperator<Self, ExhaustMapOperator<Self::Out, Self::OutError, Mapper, ErrorMapper, NextInnerObservable>>
where NextInnerObservable: Observable + Signal, Mapper: 'static + Fn(Self::Out) -> NextInnerObservable + Clone + Send + Sync, ErrorMapper: 'static + FnOnce(Self::OutError) -> <NextInnerObservable as ObservableOutput>::OutError + Clone + Send + Sync, Self::OutError: Into<<NextInnerObservable as ObservableOutput>::OutError>,

Source§

impl<Op> OperatorComposeExtensionFallbackWhenSilent for Op
where Op: ComposableOperator,

Source§

fn fallback_when_silent<Fallback, S>( self, fallback: Fallback, scheduler: SchedulerHandle<S>, ) -> CompositeOperator<Self, FallbackWhenSilentOperator<Self::Out, Self::OutError, Fallback, S>>
where Fallback: 'static + Fn(<S as WithWorkInputOutput>::Tick, &mut <<S as WithWorkContextProvider>::WorkContextProvider as WorkContextProvider>::Item<'_>, usize) -> Self::Out + Clone + Send + Sync, S: 'static + Scheduler + Send + Sync,

Source§

impl<Op> OperatorComposeExtensionFilter for Op
where Op: ComposableOperator,

Source§

fn filter<Filter>( self, filter: Filter, ) -> CompositeOperator<Self, FilterOperator<Self::Out, Self::OutError, Filter>>
where Filter: 'static + Fn(&Self::Out, usize) -> bool + Clone + Send + Sync,

Source§

impl<Op> OperatorComposeExtensionFilterMap for Op
where Op: ComposableOperator,

Source§

fn filter_map<NextOut, Mapper>( self, mapper: Mapper, ) -> CompositeOperator<Self, FilterMapOperator<Self::Out, Self::OutError, Mapper, NextOut>>
where NextOut: Signal, Mapper: 'static + Fn(Self::Out) -> Option<NextOut> + Clone + Send + Sync,

Source§

impl<Op> OperatorComposeExtensionFinalize for Op
where Op: ComposableOperator,

Source§

fn finalize<Callback>( self, callback: Callback, ) -> CompositeOperator<Self, FinalizeOperator<Self::Out, Self::OutError, Callback>>
where Callback: 'static + Clone + FnOnce() + Send + Sync,

Source§

impl<Op> OperatorComposeExtensionFind for Op
where Op: ComposableOperator,

Source§

fn find<Predicate>( self, predicate: Predicate, ) -> CompositeOperator<Self, FindOperator<Self::Out, Self::OutError, Predicate>>
where Predicate: 'static + Fn(&Self::Out) -> bool + Clone + Send + Sync,

Source§

impl<Op> OperatorComposeExtensionFindIndex for Op
where Op: ComposableOperator,

Source§

fn find_index<Predicate>( self, predicate: Predicate, ) -> CompositeOperator<Self, FindIndexOperator<Self::Out, Self::OutError, Predicate>>
where Predicate: 'static + Fn(&Self::Out) -> bool + Clone + Send + Sync,

Source§

impl<Op> OperatorComposeExtensionFirst for Op
where Op: ComposableOperator,

Source§

fn first( self, ) -> CompositeOperator<Self, FirstOperator<Self::Out, Self::OutError>>
where Self::Out: Clone,

Source§

impl<Op> OperatorComposeExtensionInto for Op
where Op: ComposableOperator,

Source§

fn map_into<NextOut, NextOutError>( self, ) -> CompositeOperator<Self, MapIntoOperator<Self::Out, Self::OutError, NextOut, NextOutError>>
where NextOut: Signal, NextOutError: Signal, Self::Out: Into<NextOut>, Self::OutError: Into<NextOutError>,

Source§

impl<Op> OperatorComposeExtensionIntoResult for Op
where Op: ComposableOperator,

Source§

fn into_result( self, ) -> CompositeOperator<Self, IntoResultOperator<Self::Out, Self::OutError>>

IntoResultOperator Read more
Source§

impl<Op> OperatorComposeExtensionIsEmpty for Op
where Op: ComposableOperator,

Source§

fn is_empty( self, ) -> CompositeOperator<Self, IsEmptyOperator<Self::Out, Self::OutError>>

IsEmptyOperator Read more
Source§

impl<Op, T> OperatorComposeExtensionLiftOption<T> for Op
where Op: ComposableOperator<Out = Option<T>>, T: Signal,

Source§

fn lift_option( self, ) -> CompositeOperator<Self, LiftOptionOperator<T, Self::OutError>>

Source§

impl<Op, ResultIn, ResultInError> OperatorComposeExtensionLiftResult<ResultIn, ResultInError> for Op
where Op: ComposableOperator<Out = Result<ResultIn, ResultInError>, OutError = Infallible>, ResultIn: Signal, ResultInError: Signal,

Source§

fn lift_result( self, ) -> CompositeOperator<Self, LiftResultOperator<ResultIn, ResultInError, Self::OutError>>

Source§

impl<Op> OperatorComposeExtensionMap for Op
where Op: ComposableOperator,

Source§

fn map<NextOut, Mapper>( self, mapper: Mapper, ) -> CompositeOperator<Self, MapOperator<Self::Out, Self::OutError, Mapper, NextOut>>
where NextOut: Signal, Mapper: 'static + Fn(Self::Out) -> NextOut + Clone + Send + Sync,

Source§

impl<Op> OperatorComposeExtensionMapError for Op
where Op: ComposableOperator,

Source§

fn map_error<NextOutError, ErrorMapper>( self, error_mapper: ErrorMapper, ) -> CompositeOperator<Self, MapErrorOperator<Self::Out, Self::OutError, ErrorMapper, NextOutError>>
where NextOutError: Signal, ErrorMapper: 'static + FnOnce(Self::OutError) -> NextOutError + Clone + Send + Sync,

Source§

impl<Op> OperatorComposeExtensionMapNeverBoth for Op
where Op: ComposableOperator<Out = Infallible, OutError = Infallible>,

Source§

fn map_never_both<NextOut, NextOutError>( self, ) -> CompositeOperator<Self, MapNeverBothOperator<NextOut, NextOutError>>
where NextOut: Signal, NextOutError: Signal,

Source§

impl<Op> OperatorComposeExtensionMapNeverError for Op
where Op: ComposableOperator<OutError = Infallible>,

Source§

fn map_never<NextOutError>( self, ) -> CompositeOperator<Self, MapNeverErrorOperator<Self::Out, NextOutError>>
where NextOutError: Signal,

Source§

impl<Op> OperatorComposeExtensionMapNeverNext for Op
where Op: ComposableOperator<Out = Infallible>,

Source§

fn map_never<NextOut>( self, ) -> CompositeOperator<Self, MapNeverNextOperator<NextOut, Self::OutError>>
where NextOut: Signal,

Source§

impl<Op> OperatorComposeExtensionMaterialize for Op
where Op: ComposableOperator,

Source§

fn materialize( self, ) -> CompositeOperator<Self, MaterializeOperator<Self::Out, Self::OutError>>

Source§

impl<Op> OperatorComposeExtensionMergeAll for Op
where Op: ComposableOperator,

Source§

fn merge_all<ErrorMapper>( self, concurrency_limit: usize, error_mapper: ErrorMapper, ) -> CompositeOperator<Self, MergeAllOperator<Self::Out, Self::OutError, ErrorMapper>>
where ErrorMapper: 'static + Fn(Self::OutError) -> <Self::Out as ObservableOutput>::OutError + Clone + Send + Sync, Self::Out: Observable, Self::OutError: Into<<Self::Out as ObservableOutput>::OutError>,

Source§

impl<Op> OperatorComposeExtensionMergeMap for Op
where Op: ComposableOperator,

Source§

fn merge_map<NextInnerObservable, Mapper, ErrorMapper>( self, mapper: Mapper, concurrency_limit: usize, error_mapper: ErrorMapper, ) -> CompositeOperator<Self, MergeMapOperator<Self::Out, Self::OutError, Mapper, ErrorMapper, NextInnerObservable>>
where NextInnerObservable: Observable + Signal, Mapper: 'static + Fn(Self::Out) -> NextInnerObservable + Clone + Send + Sync, ErrorMapper: 'static + FnOnce(Self::OutError) -> <NextInnerObservable as ObservableOutput>::OutError + Clone + Send + Sync, Self::OutError: Into<<NextInnerObservable as ObservableOutput>::OutError>,

Source§

impl<Op, T, S> OperatorComposeExtensionObserveOn<T, S> for Op
where Op: ComposableOperator<Out = T>, T: Signal, S: 'static + Scheduler + Send + Sync,

Source§

fn observe_on( self, scheduler: SchedulerHandle<S>, ) -> CompositeOperator<Self, ObserveOnOperator<T, Self::OutError, S>>

ObserveOnOperator Read more
Source§

impl<Op> OperatorComposeExtensionOnNext for Op
where Op: ComposableOperator,

Source§

fn on_next<OnNext>( self, on_next: OnNext, ) -> CompositeOperator<Self, OnNextOperator<OnNext, Self::Out, Self::OutError>>
where OnNext: 'static + FnMut(&Self::Out, &mut dyn Subscriber<In = Self::Out, InError = Self::OutError>) -> bool + Send + Sync + Clone,

Source§

impl<Op> OperatorComposeExtensionOnSubscribe for Op
where Op: ComposableOperator,

Source§

fn on_subscribe<OnSubscribe>( self, on_subscribe: OnSubscribe, ) -> CompositeOperator<Self, OnSubscribeOperator<OnSubscribe, Self::Out, Self::OutError>>
where OnSubscribe: 'static + FnMut(&mut dyn Subscriber<In = Self::Out, InError = Self::OutError>) + Send + Sync,

Source§

impl<Op> OperatorComposeExtensionPairwise for Op
where Op: ComposableOperator,

Source§

fn pairwise( self, ) -> CompositeOperator<Self, PairwiseOperator<Self::Out, Self::OutError>>
where Self::Out: Clone,

Source§

impl<Op> OperatorComposeExtensionReduce for Op
where Op: ComposableOperator,

Source§

fn reduce<NextOut, Reducer>( self, reducer: Reducer, seed: NextOut, ) -> CompositeOperator<Self, ReduceOperator<Self::Out, Self::OutError, Reducer, NextOut>>
where NextOut: Signal + Clone, Reducer: 'static + Fn(&NextOut, Self::Out) -> NextOut + Clone + Send + Sync,

Source§

impl<Op> OperatorComposeExtensionScan for Op
where Op: ComposableOperator,

Source§

fn scan<NextOut, Reducer>( self, reducer: Reducer, seed: NextOut, ) -> CompositeOperator<Self, ScanOperator<Self::Out, Self::OutError, Reducer, NextOut>>
where NextOut: Signal + Clone, Reducer: 'static + Fn(&NextOut, Self::Out) -> NextOut + Clone + Send + Sync,

Source§

impl<Op> OperatorComposeExtensionSkip for Op
where Op: ComposableOperator,

Source§

fn skip( self, count: usize, ) -> CompositeOperator<Self, SkipOperator<Self::Out, Self::OutError>>

Source§

impl<Op> OperatorComposeExtensionStartWith for Op
where Op: ComposableOperator,

Source§

fn start_with( self, start_with: Self::Out, ) -> CompositeOperator<Self, StartWithOperator<Self::Out, Self::OutError>>
where Self::Out: Clone,

Source§

impl<Op> OperatorComposeExtensionSwitchAll for Op
where Op: ComposableOperator,

Source§

fn switch_all<ErrorMapper>( self, error_mapper: ErrorMapper, ) -> CompositeOperator<Self, SwitchAllOperator<Self::Out, Self::OutError, ErrorMapper>>
where ErrorMapper: 'static + Fn(Self::OutError) -> <Self::Out as ObservableOutput>::OutError + Clone + Send + Sync, Self::Out: Observable, Self::OutError: Into<<Self::Out as ObservableOutput>::OutError>,

Source§

impl<Op> OperatorComposeExtensionSwitchMap for Op
where Op: ComposableOperator,

Source§

fn switch_map<NextInnerObservable, Mapper, ErrorMapper>( self, mapper: Mapper, error_mapper: ErrorMapper, ) -> CompositeOperator<Self, SwitchMapOperator<Self::Out, Self::OutError, Mapper, ErrorMapper, NextInnerObservable>>
where NextInnerObservable: Observable + Signal, Mapper: 'static + Fn(Self::Out) -> NextInnerObservable + Clone + Send + Sync, ErrorMapper: 'static + FnOnce(Self::OutError) -> <NextInnerObservable as ObservableOutput>::OutError + Clone + Send + Sync, Self::OutError: Into<<NextInnerObservable as ObservableOutput>::OutError>,

Source§

impl<Op> OperatorComposeExtensionTake for Op
where Op: ComposableOperator,

Source§

fn take( self, count: usize, ) -> CompositeOperator<Self, TakeOperator<Self::Out, Self::OutError>>

Source§

impl<Op> OperatorComposeExtensionTap for Op
where Op: ComposableOperator,

Source§

fn tap<TapDestination>( self, tap_destination: TapDestination, ) -> CompositeOperator<Self, TapOperator<TapDestination>>
where TapDestination: 'static + RxObserver<In = Self::Out, InError = Self::OutError> + Clone + Send + Sync, Self::Out: Clone, Self::OutError: Clone,

Source§

impl<Op> OperatorComposeExtensionTapNext for Op
where Op: ComposableOperator,

Source§

fn tap_next<OnNext>( self, callback: OnNext, ) -> CompositeOperator<Self, TapNextOperator<Self::Out, Self::OutError, OnNext>>
where OnNext: 'static + Fn(&Self::Out) + Clone + Send + Sync,

Source§

impl<Op, T, S> OperatorComposeExtensionThrottleTime<T, S> for Op
where Op: ComposableOperator<Out = T>, T: Signal, S: 'static + Scheduler + Send + Sync,

Source§

fn throttle_time( self, options: ThrottleTimeOptions, scheduler: SchedulerHandle<S>, ) -> CompositeOperator<Self, ThrottleTimeOperator<T, Self::OutError, S>>

ThrottleTimeOperator Read more
Source§

impl<Op> OperatorComposeExtensionWithLatestFrom for Op
where Op: ComposableOperator,

Source§

fn with_latest_from<InnerObservable>( self, inner_observable: InnerObservable, ) -> CompositeOperator<Self, WithLatestFromOperator<InnerObservable, Self::Out, Self::OutError>>
where InnerObservable: 'static + Observable<OutError = Self::OutError>, <InnerObservable as ObservableOutput>::Out: Clone,

Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<T> ConditionalSend for T
where T: Send,

Source§

impl<T> Signal for T
where T: 'static + Send + Sync,