Struct rxrust::ops::group_by::KeyObservable

pub struct KeyObservable<Key, Subject> {
    pub key: Key,
    /* private fields */
}

Observable used to keep track of the key of the items emitted by the contained subject.

Fields

key: Key

Trait Implementations

impl<Key: Clone, Subject: Clone> Clone for KeyObservable<Key, Subject>

fn clone(&self) -> KeyObservable<Key, Subject>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Key, Item, Err, O, Subject> Observable<Item, Err, O> for KeyObservable<Key, Subject>where Subject: Observable<Item, Err, O>, O: Observer<Item, Err>,

type Unsub = <Subject as Observable<Item, Err, O>>::Unsub

fn actual_subscribe(self, observer: O) -> Self::Unsub

impl<'a, Source, Discr, Key, Item, Err, O> Observable<KeyObservable<Key, Subject<'a, Item, Err>>, Err, O> for GroupByOp<Source, Discr, Subject<'a, Item, Err>>where O: Observer<KeyObservable<Key, Subject<'a, Item, Err>>, Err>, Source: Observable<Item, Err, GroupByObserver<O, Discr, Key, Subject<'a, Item, Err>>>, Discr: FnMut(&Item) -> Key, Key: Hash + Eq + Clone, Item: Clone, Err: Clone,

type Unsub = <Source as Observable<Item, Err, GroupByObserver<O, Discr, Key, Subject<'a, Item, Err>>>>::Unsub

fn actual_subscribe(self, observer: O) -> Self::Unsub

impl<Source, Discr, Key, Item, Err, O> Observable<KeyObservable<Key, SubjectThreads<Item, Err>>, Err, O> for GroupByOp<Source, Discr, SubjectThreads<Item, Err>>where O: Observer<KeyObservable<Key, SubjectThreads<Item, Err>>, Err>, Source: Observable<Item, Err, GroupByObserver<O, Discr, Key, SubjectThreads<Item, Err>>>, Discr: FnMut(&Item) -> Key, Key: Hash + Eq + Clone, Item: Clone, Err: Clone,

type Unsub = <Source as Observable<Item, Err, GroupByObserver<O, Discr, Key, SubjectThreads<Item, Err>>>>::Unsub

fn actual_subscribe(self, observer: O) -> Self::Unsub

impl<Item, Err, Key, Subject> ObservableExt<Item, Err> for KeyObservable<Key, Subject>where Subject: Observer<Item, Err>,

fn first(self) -> TakeOp<Self>

emit only the first item emitted by an Observable

fn first_or(self, default: Item) -> DefaultIfEmptyOp<TakeOp<Self>, Item>

emit only the first item emitted by an Observable

fn last_or(self, default: Item) -> DefaultIfEmptyOp<LastOp<Self, Item>, Item>

Emit only the last final item emitted by a source observable or a default item given.

fn element_at(self, nth: usize) -> TakeOp<SkipOp<Self>>

Emit only item n (0-indexed) emitted by an Observable

fn ignore_elements(self) -> FilterOp<Self, fn(_: &Item) -> bool>

Do not emit any items from an Observable but mirror its termination notification

fn all<F>( self, pred: F ) -> DefaultIfEmptyOp<TakeOp<FilterOp<MapOp<Self, F, Item>, fn(_: &bool) -> bool>>, bool>where F: Fn(Item) -> bool,

Determine whether all items emitted by an Observable meet some criteria

fn contains(self, target: Item) -> ContainsOp<Self, Item>

Determine whether an Observable emits a particular item or not

fn last(self) -> LastOp<Self, Item>

Emits only last final item emitted by a source observable.

fn finalize<F>(self, f: F) -> FinalizeOp<Self, F>where F: FnMut(),

Call a function when observable completes, errors or is unsubscribed from.

fn finalize_threads<F>(self, f: F) -> FinalizeOpThreads<Self, F>where F: FnMut(),

A threads safe version of finalize

fn flatten<'a, Item2, Err2>(self) -> MergeAllOp<'a, Self, Item>where Item: ObservableExt<Item2, Err2>,

Creates an Observable that combines all the emissions from Observables that get emitted from an Observable.

fn flatten_threads<Item2, Err2>(self) -> MergeAllOpThreads<Self, Item>where Item: ObservableExt<Item2, Err2>,

A threads safe version of flatten

fn flat_map<'a, V, Item2, F>(self, f: F) -> FlatMapOp<'a, Self, V, F, Item>where F: Fn(Item) -> V, MapOp<Self, F, Item>: ObservableExt<V, Err>, V: ObservableExt<Item2, Err>,

Applies given function to each item emitted by this Observable, where that function returns an Observable that itself emits items. It then merges the emissions of these resulting Observables, emitting these merged results as its own sequence.

fn flat_map_threads<V, Item2, F>( self, f: F ) -> FlatMapOpThreads<Self, V, F, Item>where F: Fn(Item) -> V, MapOp<Self, F, Item>: ObservableExt<V, Err>, V: ObservableExt<Item2, Err>,

fn group_by<D, Key, Subject>(self, discr: D) -> GroupByOp<Self, D, Subject>where D: FnMut(&Item) -> Key, Key: Hash + Eq + Clone, Subject: Clone + Default + Observer<Item, Err>,

Groups items emitted by the source Observable into Observables. Each emitted Observable emits items matching the key returned by the discriminator function.

fn map<B, F>(self, f: F) -> MapOp<Self, F, Item>where F: FnMut(Item) -> B,

Creates a new stream which calls a closure on each element and uses its return as the value.

fn on_error_map<B, F>(self, f: F) -> OnErrorMapOp<Self, F, Err>where F: FnMut(Err) -> B,

Creates a new stream which calls a closure on each error and uses its return as emitted error.

fn map_to<B>(self, value: B) -> MapToOp<Self, B, Item>

Maps emissions to a constant value.

fn merge<S>(self, other: S) -> MergeOp<Self, S>where S: ObservableExt<Item, Err>,

combine two Observables into one by merging their emissions

fn merge_threads<S>(self, other: S) -> MergeOpThreads<Self, S>where S: ObservableExt<Item, Err>,

A threads safe version of merge

fn merge_all<'a, Item2>(self, concurrent: usize) -> MergeAllOp<'a, Self, Item>where Item: ObservableExt<Item2, Err>,

Converts a higher-order Observable into a first-order Observable which concurrently delivers all values that are emitted on the inner Observables.

fn merge_all_threads<Item2>( self, concurrent: usize ) -> MergeAllOpThreads<Self, Item>where Item: ObservableExt<Item2, Err>,

A threads safe version of merge_all

fn filter<F>(self, filter: F) -> FilterOp<Self, F>where F: Fn(&Item) -> bool,

Emit only those items from an Observable that pass a predicate test

fn filter_map<F, OutputItem>(self, f: F) -> FilterMapOp<Self, F, Item>where F: FnMut(Item) -> Option<OutputItem>,

The closure must return an Option. filter_map creates an iterator which calls this closure on each element. If the closure returns Some(element), then that element is returned. If the closure returns None, it will try again, and call the closure on the next element, seeing if it will return Some.

fn skip(self, count: usize) -> SkipOp<Self>

Ignore the first count values emitted by the source Observable.

fn skip_until<NotifyItem, NotifyErr, Other>( self, notifier: Other ) -> SkipUntilOp<Self, Other, NotifyItem, NotifyErr>where Other: ObservableExt<NotifyItem, NotifyErr>,

Discard items emitted by an Observable until a second Observable emits an item

fn skip_until_threads<NotifyItem, NotifyErr, Other>( self, notifier: Other ) -> SkipUntilOpThreads<Self, Other, NotifyItem, NotifyErr>where Other: ObservableExt<NotifyItem, NotifyErr>,

A threads safe version of skip_until_threads

fn skip_while<F>(self, predicate: F) -> SkipWhileOp<Self, F>where F: FnMut(&Item) -> bool,

Discard items emitted by an Observable until a specified condition becomes false

fn skip_last(self, count: usize) -> SkipLastOp<Self>

Ignore the last count values emitted by the source Observable.

fn take(self, count: usize) -> TakeOp<Self>

Emits only the first count values emitted by the source Observable.

fn take_until<Notify, NotifyItem, NotifyErr>( self, notifier: Notify ) -> TakeUntilOp<Self, Notify, NotifyItem, NotifyErr>

Emits the values emitted by the source Observable until a notifier Observable emits a value.

fn take_until_threads<Notify, NotifyItem, NotifyErr>( self, notifier: Notify ) -> TakeUntilOpThreads<Self, Notify, NotifyItem, NotifyErr>

fn take_while<F>(self, callback: F) -> TakeWhileOp<Self, F>where F: FnMut(&Item) -> bool,

Emits values while result of an callback is true.

fn take_while_inclusive<F>(self, callback: F) -> TakeWhileOp<Self, F>where F: FnMut(&Item) -> bool,

Emits values while result of an callback is true and the last one that causes the callback to return false.

fn take_last(self, count: usize) -> TakeLastOp<Self>

Emits only the last count values emitted by the source Observable.

fn sample<Sample, SampleItem, SampleErr>( self, sampling: Sample ) -> SampleOp<Self, Sample, SampleItem>where Sample: ObservableExt<SampleItem, SampleErr>,

Emits item it has most recently emitted since the previous sampling

fn sample_threads<Sample, SampleItem, SampleErr>( self, sampling: Sample ) -> SampleOpThreads<Self, Sample, SampleItem>where Sample: ObservableExt<SampleItem, SampleErr>,

A threads safe version of sample

fn scan_initial<OutputItem, BinaryOp>( self, initial_value: OutputItem, binary_op: BinaryOp ) -> ScanOp<Self, BinaryOp, OutputItem, Item>where BinaryOp: Fn(OutputItem, Item) -> OutputItem, OutputItem: Clone,

The Scan operator applies a function to the first item emitted by the source observable and then emits the result of that function as its own first emission. It also feeds the result of the function back into the function along with the second item emitted by the source observable in order to generate its second emission. It continues to feed back its own subsequent emissions along with the subsequent emissions from the source Observable in order to create the rest of its sequence.

fn scan<OutputItem, BinaryOp>( self, binary_op: BinaryOp ) -> ScanOp<Self, BinaryOp, OutputItem, Item>where BinaryOp: Fn(OutputItem, Item) -> OutputItem, OutputItem: Default + Clone,

Works like scan_initial but starts with a value defined by a Default trait for the first argument binary_op operator operates on.

fn reduce_initial<OutputItem, BinaryOp>( self, initial: OutputItem, binary_op: BinaryOp ) -> ReduceOp<Self, BinaryOp, OutputItem, Item>where BinaryOp: Fn(OutputItem, Item) -> OutputItem, OutputItem: Clone,

Apply a function to each item emitted by an observable, sequentially, and emit the final value, after source observable completes.

fn reduce<OutputItem, BinaryOp>( self, binary_op: BinaryOp ) -> ReduceOp<Self, BinaryOp, OutputItem, Item>where BinaryOp: Fn(OutputItem, Item) -> OutputItem, OutputItem: Default + Clone,

Works like reduce_initial but starts with a value defined by a Default trait for the first argument f operator operates on.

fn count(self) -> CountOp<Self, Item>

Emits the number of items emitted by a source observable when this source completes.

fn publish<Subject: Default>(self) -> ConnectableObservable<Self, Subject>

Returns a ConnectableObservable. A ConnectableObservable Observable resembles an ordinary Observable, except that it does not begin emitting items when it is subscribed to, but only when the Connect operator is applied to it. In this way you can wait for all intended observers to subscribe to the Observable before the Observable begins emitting items.

fn share<'a>(self) -> ShareOp<'a, Item, Err, Self>

Returns a new Observable that multicast (shares) the original Observable. As long as there is at least one Subscriber this Observable will be subscribed and emitting data. When all subscribers have unsubscribed it will unsubscribe from the source Observable. Because the Observable is multicasting it makes the stream hot. This is an alias for publish().ref_count()

fn share_threads(self) -> ShareOpThreads<Item, Err, Self>

fn delay<SD>(self, dur: Duration, scheduler: SD) -> DelayOp<Self, SD>

Delays the emission of items from the source Observable by a given timeout or until a given Instant.

fn delay_threads<SD>( self, dur: Duration, scheduler: SD ) -> DelayOpThreads<Self, SD>

A threads safe version of delay

fn delay_at<SD>(self, at: Instant, scheduler: SD) -> DelayOp<Self, SD>

fn delay_at_threads<SD>( self, at: Instant, scheduler: SD ) -> DelayOpThreads<Self, SD>

A threads safe version of delay_at

fn delay_subscription<SD>( self, dur: Duration, scheduler: SD ) -> DelaySubscriptionOp<Self, SD>

It’s similar to delay but rather than timeshifting the emissions from the source Observable, it timeshifts the moment of subscription to that Observable.

fn delay_subscription_at<SD>( self, at: Instant, scheduler: SD ) -> DelaySubscriptionOp<Self, SD>

fn subscribe_on<SD>(self, scheduler: SD) -> SubscribeOnOP<Self, SD>

Specify the Scheduler on which an Observable will operate

fn observe_on<SD>(self, scheduler: SD) -> ObserveOnOp<Self, SD>

Re-emits all notifications from source Observable with specified scheduler.

fn observe_on_threads<SD>(self, scheduler: SD) -> ObserveOnOpThreads<Self, SD>

A thread safe version of observe_on

fn debounce<SD>(self, duration: Duration, scheduler: SD) -> DebounceOp<Self, SD>

Emits a value from the source Observable only after a particular time span has passed without another source emission.

fn throttle<SD, F>( self, duration_selector: F, edge: ThrottleEdge, scheduler: SD ) -> ThrottleOp<Self, SD, F>where F: Fn(&Item) -> Duration,

Emits a value from the source Observable, then ignores subsequent source values for duration milliseconds, then repeats this process.

fn throttle_time<SD>( self, duration: Duration, edge: ThrottleEdge, scheduler: SD ) -> ThrottleOp<Self, SD, Box<dyn Fn(&Item) -> Duration + Send + Sync>>where Item: 'static,

Emits a value from the source Observable, then ignores subsequent source values for duration milliseconds, then repeats this process.

fn distinct(self) -> DistinctOp<Self>

Returns an Observable that emits all items emitted by the source Observable that are distinct by comparison from previous items.

fn distinct_key<F>(self, key: F) -> DistinctKeyOp<Self, F>

Variant of distinct that takes a key selector.

fn distinct_until_changed(self) -> DistinctUntilChangedOp<Self>

Only emit when the current value is different than the last

fn distinct_until_key_changed<F>( self, key: F ) -> DistinctUntilKeyChangedOp<Self, F>

Variant of distinct_until_changed that takes a key selector.

fn zip<Other, Item2>(self, other: Other) -> ZipOp<Self, Other>where Other: ObservableExt<Item2, Err>,

‘Zips up’ two observable into a single observable of pairs.

fn zip_threads<Other, Item2>(self, other: Other) -> ZipOpThreads<Self, Other>where Other: ObservableExt<Item2, Err>,

A threads safe version of zip

fn with_latest_from<From, OtherItem>( self, from: From ) -> WithLatestFromOp<Self, From>where From: ObservableExt<OtherItem, Err>, OtherItem: Clone,

Combines the source Observable with other Observables to create an Observable whose values are calculated from the latest values of each, only when the source emits.

fn with_latest_from_threads<From, OtherItem>( self, from: From ) -> WithLatestFromOpThreads<Self, From>where From: ObservableExt<OtherItem, Err>, OtherItem: Clone,

fn default_if_empty(self, default_value: Item) -> DefaultIfEmptyOp<Self, Item>

Emits default value if Observable completed with empty result

fn buffer_with_count(self, count: usize) -> BufferWithCountOp<Self>

Buffers emitted values of type T in a Vec and emits that Vec as soon as the buffer’s size equals the given count. On complete, if the buffer is not empty, it will be emitted. On error, the buffer will be discarded.

fn buffer_with_time<S>( self, time: Duration, scheduler: S ) -> BufferWithTimeOp<Self, S>

Buffers emitted values of type T in a Vec and emits that Vec periodically.

fn buffer_with_count_and_time<S>( self, count: usize, time: Duration, scheduler: S ) -> BufferWithCountOrTimerOp<Self, S>

Buffers emitted values of type T in a Vec and emits that Vec either if the buffer’s size equals count, or periodically. This operator combines the functionality of buffer_with_count and buffer_with_time.

fn combine_latest<Other, OtherItem, BinaryOp, OutputItem>( self, other: Other, binary_op: BinaryOp ) -> CombineLatestOp<Self, Other, BinaryOp>where Other: ObservableExt<OtherItem, Err>, BinaryOp: FnMut(Item, OtherItem) -> OutputItem,

Emits item which is combining latest items from two observables.

fn combine_latest_threads<Other, OtherItem, BinaryOp, OutputItem>( self, other: Other, binary_op: BinaryOp ) -> CombineLatestOpThread<Self, Other, BinaryOp>where Other: ObservableExt<OtherItem, Err>, BinaryOp: FnMut(Item, OtherItem) -> OutputItem,

fn start_with<B>(self, values: Vec<B>) -> StartWithOp<Self, B>

Returns an observable that, at the moment of subscription, will synchronously emit all values provided to this operator, then subscribe to the source and mirror all of its emissions to subscribers.

fn pairwise(self) -> PairwiseOp<Self>

Groups pairs of consecutive emissions together and emits them as an pair of two values.

fn tap<F>(self, f: F) -> TapOp<Self, F>where F: FnMut(&Item),

Used to perform side-effects for notifications from the source observable

fn on_error<F>(self, f: F) -> OnErrorOp<Self, F, Err>where F: FnOnce(Err),

Process the error of the observable and the return observable can’t catch the error any more.

fn on_complete<F>(self, f: F) -> OnCompleteOp<Self, F>where F: FnOnce(),

fn complete_status(self) -> (StatusOp<Self>, Arc<CompleteStatus>)

Turn the observable to an new observable that will track its complete status. The second element of return tuple provide ability let you can query if it completed or error occur. You can also wait the observable finish.

fn collect<C>(self) -> CollectOp<Self, C>where C: IntoIterator + Extend<C::Item> + Default,

Collects all the items emitted by the observable into a collection.

fn collect_into<C>(self, collection: C) -> CollectOp<Self, C>where C: IntoIterator + Extend<C::Item>,

Collects all the items emitted by the observable into the given collection.

impl<'a, Source, Discr, Key, Item, Err> ObservableExt<KeyObservable<Key, Subject<'a, Item, Err>>, Err> for GroupByOp<Source, Discr, Subject<'a, Item, Err>>where Source: ObservableExt<Item, Err>,

fn first(self) -> TakeOp<Self>

emit only the first item emitted by an Observable

fn first_or(self, default: Item) -> DefaultIfEmptyOp<TakeOp<Self>, Item>

emit only the first item emitted by an Observable

fn last_or(self, default: Item) -> DefaultIfEmptyOp<LastOp<Self, Item>, Item>

Emit only the last final item emitted by a source observable or a default item given.

fn element_at(self, nth: usize) -> TakeOp<SkipOp<Self>>

Emit only item n (0-indexed) emitted by an Observable

fn ignore_elements(self) -> FilterOp<Self, fn(_: &Item) -> bool>

Do not emit any items from an Observable but mirror its termination notification

fn all<F>( self, pred: F ) -> DefaultIfEmptyOp<TakeOp<FilterOp<MapOp<Self, F, Item>, fn(_: &bool) -> bool>>, bool>where F: Fn(Item) -> bool,

Determine whether all items emitted by an Observable meet some criteria

fn contains(self, target: Item) -> ContainsOp<Self, Item>

Determine whether an Observable emits a particular item or not

fn last(self) -> LastOp<Self, Item>

Emits only last final item emitted by a source observable.

fn finalize<F>(self, f: F) -> FinalizeOp<Self, F>where F: FnMut(),

Call a function when observable completes, errors or is unsubscribed from.

fn finalize_threads<F>(self, f: F) -> FinalizeOpThreads<Self, F>where F: FnMut(),

A threads safe version of finalize

fn flatten<'a, Item2, Err2>(self) -> MergeAllOp<'a, Self, Item>where Item: ObservableExt<Item2, Err2>,

Creates an Observable that combines all the emissions from Observables that get emitted from an Observable.

fn flatten_threads<Item2, Err2>(self) -> MergeAllOpThreads<Self, Item>where Item: ObservableExt<Item2, Err2>,

A threads safe version of flatten

fn flat_map<'a, V, Item2, F>(self, f: F) -> FlatMapOp<'a, Self, V, F, Item>where F: Fn(Item) -> V, MapOp<Self, F, Item>: ObservableExt<V, Err>, V: ObservableExt<Item2, Err>,

Applies given function to each item emitted by this Observable, where that function returns an Observable that itself emits items. It then merges the emissions of these resulting Observables, emitting these merged results as its own sequence.

fn flat_map_threads<V, Item2, F>( self, f: F ) -> FlatMapOpThreads<Self, V, F, Item>where F: Fn(Item) -> V, MapOp<Self, F, Item>: ObservableExt<V, Err>, V: ObservableExt<Item2, Err>,

fn group_by<D, Key, Subject>(self, discr: D) -> GroupByOp<Self, D, Subject>where D: FnMut(&Item) -> Key, Key: Hash + Eq + Clone, Subject: Clone + Default + Observer<Item, Err>,

Groups items emitted by the source Observable into Observables. Each emitted Observable emits items matching the key returned by the discriminator function.

fn map<B, F>(self, f: F) -> MapOp<Self, F, Item>where F: FnMut(Item) -> B,

Creates a new stream which calls a closure on each element and uses its return as the value.

fn on_error_map<B, F>(self, f: F) -> OnErrorMapOp<Self, F, Err>where F: FnMut(Err) -> B,

Creates a new stream which calls a closure on each error and uses its return as emitted error.

fn map_to<B>(self, value: B) -> MapToOp<Self, B, Item>

Maps emissions to a constant value.

fn merge<S>(self, other: S) -> MergeOp<Self, S>where S: ObservableExt<Item, Err>,

combine two Observables into one by merging their emissions

fn merge_threads<S>(self, other: S) -> MergeOpThreads<Self, S>where S: ObservableExt<Item, Err>,

A threads safe version of merge

fn merge_all<'a, Item2>(self, concurrent: usize) -> MergeAllOp<'a, Self, Item>where Item: ObservableExt<Item2, Err>,

Converts a higher-order Observable into a first-order Observable which concurrently delivers all values that are emitted on the inner Observables.

fn merge_all_threads<Item2>( self, concurrent: usize ) -> MergeAllOpThreads<Self, Item>where Item: ObservableExt<Item2, Err>,

A threads safe version of merge_all

fn filter<F>(self, filter: F) -> FilterOp<Self, F>where F: Fn(&Item) -> bool,

Emit only those items from an Observable that pass a predicate test

fn filter_map<F, OutputItem>(self, f: F) -> FilterMapOp<Self, F, Item>where F: FnMut(Item) -> Option<OutputItem>,

The closure must return an Option. filter_map creates an iterator which calls this closure on each element. If the closure returns Some(element), then that element is returned. If the closure returns None, it will try again, and call the closure on the next element, seeing if it will return Some.

fn skip(self, count: usize) -> SkipOp<Self>

Ignore the first count values emitted by the source Observable.

fn skip_until<NotifyItem, NotifyErr, Other>( self, notifier: Other ) -> SkipUntilOp<Self, Other, NotifyItem, NotifyErr>where Other: ObservableExt<NotifyItem, NotifyErr>,

Discard items emitted by an Observable until a second Observable emits an item

fn skip_until_threads<NotifyItem, NotifyErr, Other>( self, notifier: Other ) -> SkipUntilOpThreads<Self, Other, NotifyItem, NotifyErr>where Other: ObservableExt<NotifyItem, NotifyErr>,

A threads safe version of skip_until_threads

fn skip_while<F>(self, predicate: F) -> SkipWhileOp<Self, F>where F: FnMut(&Item) -> bool,

Discard items emitted by an Observable until a specified condition becomes false

fn skip_last(self, count: usize) -> SkipLastOp<Self>

Ignore the last count values emitted by the source Observable.

fn take(self, count: usize) -> TakeOp<Self>

Emits only the first count values emitted by the source Observable.

fn take_until<Notify, NotifyItem, NotifyErr>( self, notifier: Notify ) -> TakeUntilOp<Self, Notify, NotifyItem, NotifyErr>

Emits the values emitted by the source Observable until a notifier Observable emits a value.

fn take_until_threads<Notify, NotifyItem, NotifyErr>( self, notifier: Notify ) -> TakeUntilOpThreads<Self, Notify, NotifyItem, NotifyErr>

fn take_while<F>(self, callback: F) -> TakeWhileOp<Self, F>where F: FnMut(&Item) -> bool,

Emits values while result of an callback is true.

fn take_while_inclusive<F>(self, callback: F) -> TakeWhileOp<Self, F>where F: FnMut(&Item) -> bool,

Emits values while result of an callback is true and the last one that causes the callback to return false.

fn take_last(self, count: usize) -> TakeLastOp<Self>

Emits only the last count values emitted by the source Observable.

fn sample<Sample, SampleItem, SampleErr>( self, sampling: Sample ) -> SampleOp<Self, Sample, SampleItem>where Sample: ObservableExt<SampleItem, SampleErr>,

Emits item it has most recently emitted since the previous sampling

fn sample_threads<Sample, SampleItem, SampleErr>( self, sampling: Sample ) -> SampleOpThreads<Self, Sample, SampleItem>where Sample: ObservableExt<SampleItem, SampleErr>,

A threads safe version of sample

fn scan_initial<OutputItem, BinaryOp>( self, initial_value: OutputItem, binary_op: BinaryOp ) -> ScanOp<Self, BinaryOp, OutputItem, Item>where BinaryOp: Fn(OutputItem, Item) -> OutputItem, OutputItem: Clone,

The Scan operator applies a function to the first item emitted by the source observable and then emits the result of that function as its own first emission. It also feeds the result of the function back into the function along with the second item emitted by the source observable in order to generate its second emission. It continues to feed back its own subsequent emissions along with the subsequent emissions from the source Observable in order to create the rest of its sequence.

fn scan<OutputItem, BinaryOp>( self, binary_op: BinaryOp ) -> ScanOp<Self, BinaryOp, OutputItem, Item>where BinaryOp: Fn(OutputItem, Item) -> OutputItem, OutputItem: Default + Clone,

Works like scan_initial but starts with a value defined by a Default trait for the first argument binary_op operator operates on.

fn reduce_initial<OutputItem, BinaryOp>( self, initial: OutputItem, binary_op: BinaryOp ) -> ReduceOp<Self, BinaryOp, OutputItem, Item>where BinaryOp: Fn(OutputItem, Item) -> OutputItem, OutputItem: Clone,

Apply a function to each item emitted by an observable, sequentially, and emit the final value, after source observable completes.

fn reduce<OutputItem, BinaryOp>( self, binary_op: BinaryOp ) -> ReduceOp<Self, BinaryOp, OutputItem, Item>where BinaryOp: Fn(OutputItem, Item) -> OutputItem, OutputItem: Default + Clone,

Works like reduce_initial but starts with a value defined by a Default trait for the first argument f operator operates on.

fn count(self) -> CountOp<Self, Item>

Emits the number of items emitted by a source observable when this source completes.

fn publish<Subject: Default>(self) -> ConnectableObservable<Self, Subject>

Returns a ConnectableObservable. A ConnectableObservable Observable resembles an ordinary Observable, except that it does not begin emitting items when it is subscribed to, but only when the Connect operator is applied to it. In this way you can wait for all intended observers to subscribe to the Observable before the Observable begins emitting items.

fn share<'a>(self) -> ShareOp<'a, Item, Err, Self>

Returns a new Observable that multicast (shares) the original Observable. As long as there is at least one Subscriber this Observable will be subscribed and emitting data. When all subscribers have unsubscribed it will unsubscribe from the source Observable. Because the Observable is multicasting it makes the stream hot. This is an alias for publish().ref_count()

fn share_threads(self) -> ShareOpThreads<Item, Err, Self>

fn delay<SD>(self, dur: Duration, scheduler: SD) -> DelayOp<Self, SD>

Delays the emission of items from the source Observable by a given timeout or until a given Instant.

fn delay_threads<SD>( self, dur: Duration, scheduler: SD ) -> DelayOpThreads<Self, SD>

A threads safe version of delay

fn delay_at<SD>(self, at: Instant, scheduler: SD) -> DelayOp<Self, SD>

fn delay_at_threads<SD>( self, at: Instant, scheduler: SD ) -> DelayOpThreads<Self, SD>

A threads safe version of delay_at

fn delay_subscription<SD>( self, dur: Duration, scheduler: SD ) -> DelaySubscriptionOp<Self, SD>

It’s similar to delay but rather than timeshifting the emissions from the source Observable, it timeshifts the moment of subscription to that Observable.

fn delay_subscription_at<SD>( self, at: Instant, scheduler: SD ) -> DelaySubscriptionOp<Self, SD>

fn subscribe_on<SD>(self, scheduler: SD) -> SubscribeOnOP<Self, SD>

Specify the Scheduler on which an Observable will operate

fn observe_on<SD>(self, scheduler: SD) -> ObserveOnOp<Self, SD>

Re-emits all notifications from source Observable with specified scheduler.

fn observe_on_threads<SD>(self, scheduler: SD) -> ObserveOnOpThreads<Self, SD>

A thread safe version of observe_on

fn debounce<SD>(self, duration: Duration, scheduler: SD) -> DebounceOp<Self, SD>

Emits a value from the source Observable only after a particular time span has passed without another source emission.

fn throttle<SD, F>( self, duration_selector: F, edge: ThrottleEdge, scheduler: SD ) -> ThrottleOp<Self, SD, F>where F: Fn(&Item) -> Duration,

Emits a value from the source Observable, then ignores subsequent source values for duration milliseconds, then repeats this process.

fn throttle_time<SD>( self, duration: Duration, edge: ThrottleEdge, scheduler: SD ) -> ThrottleOp<Self, SD, Box<dyn Fn(&Item) -> Duration + Send + Sync>>where Item: 'static,

Emits a value from the source Observable, then ignores subsequent source values for duration milliseconds, then repeats this process.

fn distinct(self) -> DistinctOp<Self>

Returns an Observable that emits all items emitted by the source Observable that are distinct by comparison from previous items.

fn distinct_key<F>(self, key: F) -> DistinctKeyOp<Self, F>

Variant of distinct that takes a key selector.

fn distinct_until_changed(self) -> DistinctUntilChangedOp<Self>

Only emit when the current value is different than the last

fn distinct_until_key_changed<F>( self, key: F ) -> DistinctUntilKeyChangedOp<Self, F>

Variant of distinct_until_changed that takes a key selector.

fn zip<Other, Item2>(self, other: Other) -> ZipOp<Self, Other>where Other: ObservableExt<Item2, Err>,

‘Zips up’ two observable into a single observable of pairs.

fn zip_threads<Other, Item2>(self, other: Other) -> ZipOpThreads<Self, Other>where Other: ObservableExt<Item2, Err>,

A threads safe version of zip

fn with_latest_from<From, OtherItem>( self, from: From ) -> WithLatestFromOp<Self, From>where From: ObservableExt<OtherItem, Err>, OtherItem: Clone,

Combines the source Observable with other Observables to create an Observable whose values are calculated from the latest values of each, only when the source emits.

fn with_latest_from_threads<From, OtherItem>( self, from: From ) -> WithLatestFromOpThreads<Self, From>where From: ObservableExt<OtherItem, Err>, OtherItem: Clone,

fn default_if_empty(self, default_value: Item) -> DefaultIfEmptyOp<Self, Item>

Emits default value if Observable completed with empty result

fn buffer_with_count(self, count: usize) -> BufferWithCountOp<Self>

Buffers emitted values of type T in a Vec and emits that Vec as soon as the buffer’s size equals the given count. On complete, if the buffer is not empty, it will be emitted. On error, the buffer will be discarded.

fn buffer_with_time<S>( self, time: Duration, scheduler: S ) -> BufferWithTimeOp<Self, S>

Buffers emitted values of type T in a Vec and emits that Vec periodically.

fn buffer_with_count_and_time<S>( self, count: usize, time: Duration, scheduler: S ) -> BufferWithCountOrTimerOp<Self, S>

Buffers emitted values of type T in a Vec and emits that Vec either if the buffer’s size equals count, or periodically. This operator combines the functionality of buffer_with_count and buffer_with_time.

fn combine_latest<Other, OtherItem, BinaryOp, OutputItem>( self, other: Other, binary_op: BinaryOp ) -> CombineLatestOp<Self, Other, BinaryOp>where Other: ObservableExt<OtherItem, Err>, BinaryOp: FnMut(Item, OtherItem) -> OutputItem,

Emits item which is combining latest items from two observables.

fn combine_latest_threads<Other, OtherItem, BinaryOp, OutputItem>( self, other: Other, binary_op: BinaryOp ) -> CombineLatestOpThread<Self, Other, BinaryOp>where Other: ObservableExt<OtherItem, Err>, BinaryOp: FnMut(Item, OtherItem) -> OutputItem,

fn start_with<B>(self, values: Vec<B>) -> StartWithOp<Self, B>

Returns an observable that, at the moment of subscription, will synchronously emit all values provided to this operator, then subscribe to the source and mirror all of its emissions to subscribers.

fn pairwise(self) -> PairwiseOp<Self>

Groups pairs of consecutive emissions together and emits them as an pair of two values.

fn tap<F>(self, f: F) -> TapOp<Self, F>where F: FnMut(&Item),

Used to perform side-effects for notifications from the source observable

fn on_error<F>(self, f: F) -> OnErrorOp<Self, F, Err>where F: FnOnce(Err),

Process the error of the observable and the return observable can’t catch the error any more.

fn on_complete<F>(self, f: F) -> OnCompleteOp<Self, F>where F: FnOnce(),

fn complete_status(self) -> (StatusOp<Self>, Arc<CompleteStatus>)

Turn the observable to an new observable that will track its complete status. The second element of return tuple provide ability let you can query if it completed or error occur. You can also wait the observable finish.

fn collect<C>(self) -> CollectOp<Self, C>where C: IntoIterator + Extend<C::Item> + Default,

Collects all the items emitted by the observable into a collection.

fn collect_into<C>(self, collection: C) -> CollectOp<Self, C>where C: IntoIterator + Extend<C::Item>,

Collects all the items emitted by the observable into the given collection.

impl<Source, Discr, Key, Item, Err> ObservableExt<KeyObservable<Key, SubjectThreads<Item, Err>>, Err> for GroupByOp<Source, Discr, SubjectThreads<Item, Err>>where Source: ObservableExt<Item, Err>,

fn first(self) -> TakeOp<Self>

emit only the first item emitted by an Observable

fn first_or(self, default: Item) -> DefaultIfEmptyOp<TakeOp<Self>, Item>

emit only the first item emitted by an Observable

fn last_or(self, default: Item) -> DefaultIfEmptyOp<LastOp<Self, Item>, Item>

Emit only the last final item emitted by a source observable or a default item given.

fn element_at(self, nth: usize) -> TakeOp<SkipOp<Self>>

Emit only item n (0-indexed) emitted by an Observable

fn ignore_elements(self) -> FilterOp<Self, fn(_: &Item) -> bool>

Do not emit any items from an Observable but mirror its termination notification

fn all<F>( self, pred: F ) -> DefaultIfEmptyOp<TakeOp<FilterOp<MapOp<Self, F, Item>, fn(_: &bool) -> bool>>, bool>where F: Fn(Item) -> bool,

Determine whether all items emitted by an Observable meet some criteria

fn contains(self, target: Item) -> ContainsOp<Self, Item>

Determine whether an Observable emits a particular item or not

fn last(self) -> LastOp<Self, Item>

Emits only last final item emitted by a source observable.

fn finalize<F>(self, f: F) -> FinalizeOp<Self, F>where F: FnMut(),

Call a function when observable completes, errors or is unsubscribed from.

fn finalize_threads<F>(self, f: F) -> FinalizeOpThreads<Self, F>where F: FnMut(),

A threads safe version of finalize

fn flatten<'a, Item2, Err2>(self) -> MergeAllOp<'a, Self, Item>where Item: ObservableExt<Item2, Err2>,

Creates an Observable that combines all the emissions from Observables that get emitted from an Observable.

fn flatten_threads<Item2, Err2>(self) -> MergeAllOpThreads<Self, Item>where Item: ObservableExt<Item2, Err2>,

A threads safe version of flatten

fn flat_map<'a, V, Item2, F>(self, f: F) -> FlatMapOp<'a, Self, V, F, Item>where F: Fn(Item) -> V, MapOp<Self, F, Item>: ObservableExt<V, Err>, V: ObservableExt<Item2, Err>,

Applies given function to each item emitted by this Observable, where that function returns an Observable that itself emits items. It then merges the emissions of these resulting Observables, emitting these merged results as its own sequence.

fn flat_map_threads<V, Item2, F>( self, f: F ) -> FlatMapOpThreads<Self, V, F, Item>where F: Fn(Item) -> V, MapOp<Self, F, Item>: ObservableExt<V, Err>, V: ObservableExt<Item2, Err>,

fn group_by<D, Key, Subject>(self, discr: D) -> GroupByOp<Self, D, Subject>where D: FnMut(&Item) -> Key, Key: Hash + Eq + Clone, Subject: Clone + Default + Observer<Item, Err>,

Groups items emitted by the source Observable into Observables. Each emitted Observable emits items matching the key returned by the discriminator function.

fn map<B, F>(self, f: F) -> MapOp<Self, F, Item>where F: FnMut(Item) -> B,

Creates a new stream which calls a closure on each element and uses its return as the value.

fn on_error_map<B, F>(self, f: F) -> OnErrorMapOp<Self, F, Err>where F: FnMut(Err) -> B,

Creates a new stream which calls a closure on each error and uses its return as emitted error.

fn map_to<B>(self, value: B) -> MapToOp<Self, B, Item>

Maps emissions to a constant value.

fn merge<S>(self, other: S) -> MergeOp<Self, S>where S: ObservableExt<Item, Err>,

combine two Observables into one by merging their emissions

fn merge_threads<S>(self, other: S) -> MergeOpThreads<Self, S>where S: ObservableExt<Item, Err>,

A threads safe version of merge

fn merge_all<'a, Item2>(self, concurrent: usize) -> MergeAllOp<'a, Self, Item>where Item: ObservableExt<Item2, Err>,

Converts a higher-order Observable into a first-order Observable which concurrently delivers all values that are emitted on the inner Observables.

fn merge_all_threads<Item2>( self, concurrent: usize ) -> MergeAllOpThreads<Self, Item>where Item: ObservableExt<Item2, Err>,

A threads safe version of merge_all

fn filter<F>(self, filter: F) -> FilterOp<Self, F>where F: Fn(&Item) -> bool,

Emit only those items from an Observable that pass a predicate test

fn filter_map<F, OutputItem>(self, f: F) -> FilterMapOp<Self, F, Item>where F: FnMut(Item) -> Option<OutputItem>,

The closure must return an Option. filter_map creates an iterator which calls this closure on each element. If the closure returns Some(element), then that element is returned. If the closure returns None, it will try again, and call the closure on the next element, seeing if it will return Some.

fn skip(self, count: usize) -> SkipOp<Self>

Ignore the first count values emitted by the source Observable.

fn skip_until<NotifyItem, NotifyErr, Other>( self, notifier: Other ) -> SkipUntilOp<Self, Other, NotifyItem, NotifyErr>where Other: ObservableExt<NotifyItem, NotifyErr>,

Discard items emitted by an Observable until a second Observable emits an item

fn skip_until_threads<NotifyItem, NotifyErr, Other>( self, notifier: Other ) -> SkipUntilOpThreads<Self, Other, NotifyItem, NotifyErr>where Other: ObservableExt<NotifyItem, NotifyErr>,

A threads safe version of skip_until_threads

fn skip_while<F>(self, predicate: F) -> SkipWhileOp<Self, F>where F: FnMut(&Item) -> bool,

Discard items emitted by an Observable until a specified condition becomes false

fn skip_last(self, count: usize) -> SkipLastOp<Self>

Ignore the last count values emitted by the source Observable.

fn take(self, count: usize) -> TakeOp<Self>

Emits only the first count values emitted by the source Observable.

fn take_until<Notify, NotifyItem, NotifyErr>( self, notifier: Notify ) -> TakeUntilOp<Self, Notify, NotifyItem, NotifyErr>

Emits the values emitted by the source Observable until a notifier Observable emits a value.

fn take_until_threads<Notify, NotifyItem, NotifyErr>( self, notifier: Notify ) -> TakeUntilOpThreads<Self, Notify, NotifyItem, NotifyErr>

fn take_while<F>(self, callback: F) -> TakeWhileOp<Self, F>where F: FnMut(&Item) -> bool,

Emits values while result of an callback is true.

fn take_while_inclusive<F>(self, callback: F) -> TakeWhileOp<Self, F>where F: FnMut(&Item) -> bool,

Emits values while result of an callback is true and the last one that causes the callback to return false.

fn take_last(self, count: usize) -> TakeLastOp<Self>

Emits only the last count values emitted by the source Observable.

fn sample<Sample, SampleItem, SampleErr>( self, sampling: Sample ) -> SampleOp<Self, Sample, SampleItem>where Sample: ObservableExt<SampleItem, SampleErr>,

Emits item it has most recently emitted since the previous sampling

fn sample_threads<Sample, SampleItem, SampleErr>( self, sampling: Sample ) -> SampleOpThreads<Self, Sample, SampleItem>where Sample: ObservableExt<SampleItem, SampleErr>,

A threads safe version of sample

fn scan_initial<OutputItem, BinaryOp>( self, initial_value: OutputItem, binary_op: BinaryOp ) -> ScanOp<Self, BinaryOp, OutputItem, Item>where BinaryOp: Fn(OutputItem, Item) -> OutputItem, OutputItem: Clone,

The Scan operator applies a function to the first item emitted by the source observable and then emits the result of that function as its own first emission. It also feeds the result of the function back into the function along with the second item emitted by the source observable in order to generate its second emission. It continues to feed back its own subsequent emissions along with the subsequent emissions from the source Observable in order to create the rest of its sequence.

fn scan<OutputItem, BinaryOp>( self, binary_op: BinaryOp ) -> ScanOp<Self, BinaryOp, OutputItem, Item>where BinaryOp: Fn(OutputItem, Item) -> OutputItem, OutputItem: Default + Clone,

Works like scan_initial but starts with a value defined by a Default trait for the first argument binary_op operator operates on.

fn reduce_initial<OutputItem, BinaryOp>( self, initial: OutputItem, binary_op: BinaryOp ) -> ReduceOp<Self, BinaryOp, OutputItem, Item>where BinaryOp: Fn(OutputItem, Item) -> OutputItem, OutputItem: Clone,

Apply a function to each item emitted by an observable, sequentially, and emit the final value, after source observable completes.

fn reduce<OutputItem, BinaryOp>( self, binary_op: BinaryOp ) -> ReduceOp<Self, BinaryOp, OutputItem, Item>where BinaryOp: Fn(OutputItem, Item) -> OutputItem, OutputItem: Default + Clone,

Works like reduce_initial but starts with a value defined by a Default trait for the first argument f operator operates on.

fn count(self) -> CountOp<Self, Item>

Emits the number of items emitted by a source observable when this source completes.

fn publish<Subject: Default>(self) -> ConnectableObservable<Self, Subject>

Returns a ConnectableObservable. A ConnectableObservable Observable resembles an ordinary Observable, except that it does not begin emitting items when it is subscribed to, but only when the Connect operator is applied to it. In this way you can wait for all intended observers to subscribe to the Observable before the Observable begins emitting items.

fn share<'a>(self) -> ShareOp<'a, Item, Err, Self>

Returns a new Observable that multicast (shares) the original Observable. As long as there is at least one Subscriber this Observable will be subscribed and emitting data. When all subscribers have unsubscribed it will unsubscribe from the source Observable. Because the Observable is multicasting it makes the stream hot. This is an alias for publish().ref_count()

fn share_threads(self) -> ShareOpThreads<Item, Err, Self>

fn delay<SD>(self, dur: Duration, scheduler: SD) -> DelayOp<Self, SD>

Delays the emission of items from the source Observable by a given timeout or until a given Instant.

fn delay_threads<SD>( self, dur: Duration, scheduler: SD ) -> DelayOpThreads<Self, SD>

A threads safe version of delay

fn delay_at<SD>(self, at: Instant, scheduler: SD) -> DelayOp<Self, SD>

fn delay_at_threads<SD>( self, at: Instant, scheduler: SD ) -> DelayOpThreads<Self, SD>

A threads safe version of delay_at

fn delay_subscription<SD>( self, dur: Duration, scheduler: SD ) -> DelaySubscriptionOp<Self, SD>

It’s similar to delay but rather than timeshifting the emissions from the source Observable, it timeshifts the moment of subscription to that Observable.

fn delay_subscription_at<SD>( self, at: Instant, scheduler: SD ) -> DelaySubscriptionOp<Self, SD>

fn subscribe_on<SD>(self, scheduler: SD) -> SubscribeOnOP<Self, SD>

Specify the Scheduler on which an Observable will operate

fn observe_on<SD>(self, scheduler: SD) -> ObserveOnOp<Self, SD>

Re-emits all notifications from source Observable with specified scheduler.

fn observe_on_threads<SD>(self, scheduler: SD) -> ObserveOnOpThreads<Self, SD>

A thread safe version of observe_on

fn debounce<SD>(self, duration: Duration, scheduler: SD) -> DebounceOp<Self, SD>

Emits a value from the source Observable only after a particular time span has passed without another source emission.

fn throttle<SD, F>( self, duration_selector: F, edge: ThrottleEdge, scheduler: SD ) -> ThrottleOp<Self, SD, F>where F: Fn(&Item) -> Duration,

Emits a value from the source Observable, then ignores subsequent source values for duration milliseconds, then repeats this process.

fn throttle_time<SD>( self, duration: Duration, edge: ThrottleEdge, scheduler: SD ) -> ThrottleOp<Self, SD, Box<dyn Fn(&Item) -> Duration + Send + Sync>>where Item: 'static,

Emits a value from the source Observable, then ignores subsequent source values for duration milliseconds, then repeats this process.

fn distinct(self) -> DistinctOp<Self>

Returns an Observable that emits all items emitted by the source Observable that are distinct by comparison from previous items.

fn distinct_key<F>(self, key: F) -> DistinctKeyOp<Self, F>

Variant of distinct that takes a key selector.

fn distinct_until_changed(self) -> DistinctUntilChangedOp<Self>

Only emit when the current value is different than the last

fn distinct_until_key_changed<F>( self, key: F ) -> DistinctUntilKeyChangedOp<Self, F>

Variant of distinct_until_changed that takes a key selector.

fn zip<Other, Item2>(self, other: Other) -> ZipOp<Self, Other>where Other: ObservableExt<Item2, Err>,

‘Zips up’ two observable into a single observable of pairs.

fn zip_threads<Other, Item2>(self, other: Other) -> ZipOpThreads<Self, Other>where Other: ObservableExt<Item2, Err>,

A threads safe version of zip

fn with_latest_from<From, OtherItem>( self, from: From ) -> WithLatestFromOp<Self, From>where From: ObservableExt<OtherItem, Err>, OtherItem: Clone,

Combines the source Observable with other Observables to create an Observable whose values are calculated from the latest values of each, only when the source emits.

fn with_latest_from_threads<From, OtherItem>( self, from: From ) -> WithLatestFromOpThreads<Self, From>where From: ObservableExt<OtherItem, Err>, OtherItem: Clone,

fn default_if_empty(self, default_value: Item) -> DefaultIfEmptyOp<Self, Item>

Emits default value if Observable completed with empty result

fn buffer_with_count(self, count: usize) -> BufferWithCountOp<Self>

Buffers emitted values of type T in a Vec and emits that Vec as soon as the buffer’s size equals the given count. On complete, if the buffer is not empty, it will be emitted. On error, the buffer will be discarded.

fn buffer_with_time<S>( self, time: Duration, scheduler: S ) -> BufferWithTimeOp<Self, S>

Buffers emitted values of type T in a Vec and emits that Vec periodically.

fn buffer_with_count_and_time<S>( self, count: usize, time: Duration, scheduler: S ) -> BufferWithCountOrTimerOp<Self, S>

Buffers emitted values of type T in a Vec and emits that Vec either if the buffer’s size equals count, or periodically. This operator combines the functionality of buffer_with_count and buffer_with_time.

fn combine_latest<Other, OtherItem, BinaryOp, OutputItem>( self, other: Other, binary_op: BinaryOp ) -> CombineLatestOp<Self, Other, BinaryOp>where Other: ObservableExt<OtherItem, Err>, BinaryOp: FnMut(Item, OtherItem) -> OutputItem,

Emits item which is combining latest items from two observables.

fn combine_latest_threads<Other, OtherItem, BinaryOp, OutputItem>( self, other: Other, binary_op: BinaryOp ) -> CombineLatestOpThread<Self, Other, BinaryOp>where Other: ObservableExt<OtherItem, Err>, BinaryOp: FnMut(Item, OtherItem) -> OutputItem,

fn start_with<B>(self, values: Vec<B>) -> StartWithOp<Self, B>

Returns an observable that, at the moment of subscription, will synchronously emit all values provided to this operator, then subscribe to the source and mirror all of its emissions to subscribers.

fn pairwise(self) -> PairwiseOp<Self>

Groups pairs of consecutive emissions together and emits them as an pair of two values.

fn tap<F>(self, f: F) -> TapOp<Self, F>where F: FnMut(&Item),

Used to perform side-effects for notifications from the source observable

fn on_error<F>(self, f: F) -> OnErrorOp<Self, F, Err>where F: FnOnce(Err),

Process the error of the observable and the return observable can’t catch the error any more.

fn on_complete<F>(self, f: F) -> OnCompleteOp<Self, F>where F: FnOnce(),

fn complete_status(self) -> (StatusOp<Self>, Arc<CompleteStatus>)

Turn the observable to an new observable that will track its complete status. The second element of return tuple provide ability let you can query if it completed or error occur. You can also wait the observable finish.

fn collect<C>(self) -> CollectOp<Self, C>where C: IntoIterator + Extend<C::Item> + Default,

Collects all the items emitted by the observable into a collection.

fn collect_into<C>(self, collection: C) -> CollectOp<Self, C>where C: IntoIterator + Extend<C::Item>,

Collects all the items emitted by the observable into the given collection.