Observable<T> class

A wrapper class that extends Stream. It combines all the Streams and StreamTransformers contained in this library into a fluent api.

Example

new Observable(new Stream.fromIterable([1]))
  .interval(new Duration(seconds: 1))
  .flatMap((i) => new Observable.just(2))
  .take(1)
  .listen(print); // prints 2

Learning RxDart

This library contains documentation and examples for each method. In addition, more complex examples can be found in the RxDart github repo demonstrating how to use RxDart with web, command line, and Flutter applications.

Additional Resources

In addition to the RxDart documentation and examples, you can find many more articles on Dart Streams that teach the fundamentals upon which RxDart is built.

Dart Streams vs Observables

In order to integrate fluently with the Dart ecosystem, the Observable class extends the Dart Stream class. This provides several advantages:

  • Observables work with any API that expects a Dart Stream as an input.
  • Inherit the many methods and properties from the core Stream API.
  • Ability to create Streams with language-level syntax.

Overall, we attempt to follow the Observable spec as closely as we can, but prioritize fitting in with the Dart ecosystem when a trade-off must be made. Therefore, there are some important differences to note between Dart's Stream class and standard Rx Observable.

First, Cold Observables in Dart are single-subscription. In other words, you can only listen to Observables once, unless it is a hot (aka broadcast) Stream. If you attempt to listen to a cold stream twice, a StateError will be thrown. If you need to listen to a stream multiple times, you can simply create a factory function that returns a new instance of the stream.

Second, many methods contained within, such as first and last do not return a Single nor an Observable, but rather must return a Dart Future. Luckily, Dart Futures are easy to work with, and easily convert back to a Stream using the myFuture.asStream() method if needed.

Third, Streams in Dart do not close by default when an error occurs. In Rx, an Error causes the Observable to terminate unless it is intercepted by an operator. Dart has mechanisms for creating streams that close when an error occurs, but the majority of Streams do not exhibit this behavior.

Fourth, Dart streams are asynchronous by default, whereas Observables are synchronous by default, unless you schedule work on a different Scheduler. You can create synchronous Streams with Dart, but please be aware the the default is simply different.

Finally, when using Dart Broadcast Streams (similar to Hot Observables), please know that onListen will only be called the first time the broadcast stream is listened to.

Inheritance
Implementers

Constructors

Observable(Stream<T> stream)
Observable.concat(Iterable<Stream<T>> streams)
Concatenates all of the specified stream sequences, as long as the previous stream sequence terminated successfully. [...]
factory
Observable.concatEager(Iterable<Stream<T>> streams)
Concatenates all of the specified stream sequences, as long as the previous stream sequence terminated successfully. [...]
factory
Observable.defer(Stream<T> streamFactory(), { bool reusable: false })
The defer factory waits until an observer subscribes to it, and then it creates an Observable with the given factory function. [...]
factory
Observable.empty()
Creates an Observable that contains no values. [...]
factory
Observable.error(Object error)
Returns an observable sequence that emits an error, then immediately completes. [...]
factory
Observable.eventTransformed(Stream<T> source, EventSink<T> mapSink(EventSink<T> sink))
Creates an Observable where all events of an existing stream are piped through a sink-transformation. [...]
factory
Observable.fromFuture(Future<T> future)
Creates an Observable from the future. [...]
factory
Observable.fromIterable(Iterable<T> data)
Creates an Observable that gets its data from data. [...]
factory
Observable.just(T data)
Creates an Observable that contains a single value [...]
factory
Observable.merge(Iterable<Stream<T>> streams)
Flattens the items emitted by the given streams into a single Observable sequence. [...]
factory
Observable.never()
Returns a non-terminating observable sequence, which can be used to denote an infinite duration. [...]
factory
Observable.periodic(Duration period, [ T computation(int computationCount) ])
Creates an Observable that repeatedly emits events at period intervals. [...]
factory
Observable.race(Iterable<Stream<T>> streams)
Given two or more source streams, emit all of the items from only the first of these streams to emit an item or notification. [...]
factory
Observable.repeat(Stream<T> streamFactory(int repeatIndex), [ int count ])
Creates a Stream that will recreate and re-listen to the source Stream the specified number of times until the Stream terminates successfully. [...]
factory
Observable.retry(Stream<T> streamFactory(), [ int count ])
Creates an Observable that will recreate and re-listen to the source Stream the specified number of times until the Stream terminates successfully. [...]
factory
Observable.retryWhen(Stream<T> streamFactory(), Stream<void> retryWhenFactory(dynamic error, StackTrace stack))
Creates a Stream that will recreate and re-listen to the source Stream when the notifier emits a new value. If the source Stream emits an error or it completes, the Stream terminates. [...]
factory
Observable.switchLatest(Stream<Stream<T>> streams)
Convert a Stream that emits Streams (aka a "Higher Order Stream") into a single Observable that emits the items emitted by the most-recently-emitted of those Streams. [...]
factory
Observable.timer(T value, Duration duration)
Emits the given value after a specified amount of time. [...]
factory

Properties

first AsObservableFuture<T>
The first element of this stream. [...]
read-only, override
isBroadcast bool
Whether this stream is a broadcast stream.
read-only, override
isEmpty AsObservableFuture<bool>
Whether this stream contains any elements. [...]
read-only, override
last AsObservableFuture<T>
The last element of this stream. [...]
read-only, override
length AsObservableFuture<int>
The number of elements in this stream. [...]
read-only, override
single AsObservableFuture<T>
The single element of this stream. [...]
read-only, override
hashCode int
The hash code for this object. [...]
read-only, inherited
runtimeType Type
A representation of the runtime type of the object.
read-only, inherited

Methods

any(bool test(T element)) AsObservableFuture<bool>
Checks whether test accepts any element provided by this stream. [...]
override
asBroadcastStream({void onListen(StreamSubscription<T> subscription), void onCancel(StreamSubscription<T> subscription) }) Observable<T>
Returns a multi-subscription stream that produces the same events as this. [...]
override
asyncExpand<S>(Stream<S> mapper(T value)) Observable<S>
Maps each emitted item to a new Stream using the given mapper, then subscribes to each new stream one after the next until all values are emitted. [...]
override
asyncMap<S>(FutureOr<S> convert(T value)) Observable<S>
Creates an Observable with each data event of this stream asynchronously mapped to a new event. [...]
override
buffer(SamplerBuilder<T, List<T>> sampler) Observable<List<T>>
Creates an Observable where each item is a List containing the items from the source sequence, batched by the sampler. [...]
bufferCount(int count, [ int startBufferEvery = 0 ]) Observable<List<T>>
Buffers a number of values from the source Observable by count then emits the buffer and clears it, and starts a new buffer each startBufferEvery values. If startBufferEvery is not provided or is null, then new buffers are started immediately at the start of the source and when each buffer closes and is emitted. [...]
bufferFuture<O>(Future<O> onFutureHandler()) Observable<List<T>>
Creates an Observable where each item is a List containing the items from the source sequence, batched whenever onFutureHandler completes. [...]
bufferTest(bool onTestHandler(T event)) Observable<List<T>>
Creates an Observable where each item is a List containing the items from the source sequence, batched whenever onTestHandler passes. [...]
bufferTime(Duration duration) Observable<List<T>>
Creates an Observable where each item is a List containing the items from the source sequence, sampled on a time frame with duration. [...]
bufferWhen<O>(Stream<O> other) Observable<List<T>>
Creates an Observable where each item is a List containing the items from the source sequence, sampled on onStream. [...]
cast<R>() Observable<R>
Adapt this stream to be a Stream<R>. [...]
override
concatMap<S>(Stream<S> mapper(T value)) Observable<S>
Maps each emitted item to a new Stream using the given mapper, then subscribes to each new stream one after the next until all values are emitted. [...]
concatWith(Iterable<Stream<T>> other) Observable<T>
Returns an Observable that emits all items from the current Observable, then emits all items from the given observable, one after the next. [...]
contains(Object needle) AsObservableFuture<bool>
Returns whether needle occurs in the elements provided by this stream. [...]
override
debounce(Duration duration) Observable<T>
Creates an Observable that will only emit items from the source sequence if a particular time span has passed without the source sequence emitting another item. [...]
defaultIfEmpty(T defaultValue) Observable<T>
Emit items from the source Stream, or a single default item if the source Stream emits nothing. [...]
delay(Duration duration) Observable<T>
The Delay operator modifies its source Observable by pausing for a particular increment of time (that you specify) before emitting each of the source Observable’s items. This has the effect of shifting the entire sequence of items emitted by the Observable forward in time by that specified increment. [...]
dematerialize<S>() Observable<S>
Converts the onData, onDone, and onError Notification objects from a materialized stream into normal onData, onDone, and onError events. [...]
distinct([bool equals(T previous, T next) ]) Observable<T>
WARNING: More commonly known as distinctUntilChanged in other Rx implementations. Creates an Observable where data events are skipped if they are equal to the previous data event. [...]
override
distinctUnique({bool equals(T e1, T e2), int hashCode(T e) }) Observable<T>
WARNING: More commonly known as distinct in other Rx implementations. Creates an Observable where data events are skipped if they have already been emitted before. [...]
doOnCancel(void onCancel()) Observable<T>
Invokes the given callback function when the stream subscription is cancelled. Often called doOnUnsubscribe or doOnDispose in other implementations. [...]
doOnData(void onData(T event)) Observable<T>
Invokes the given callback function when the stream emits an item. In other implementations, this is called doOnNext. [...]
doOnDone(void onDone()) Observable<T>
Invokes the given callback function when the stream finishes emitting items. In other implementations, this is called doOnComplete(d). [...]
doOnEach(void onEach(Notification<T> notification)) Observable<T>
Invokes the given callback function when the stream emits data, emits an error, or emits done. The callback receives a Notification object. [...]
doOnError(Function onError) Observable<T>
Invokes the given callback function when the stream emits an error. [...]
doOnListen(void onListen()) Observable<T>
Invokes the given callback function when the stream is first listened to. [...]
doOnPause(void onPause(Future resumeSignal)) Observable<T>
Invokes the given callback function when the stream subscription is paused. [...]
doOnResume(void onResume()) Observable<T>
Invokes the given callback function when the stream subscription resumes receiving items. [...]
drain<S>([S futureValue ]) AsObservableFuture<S>
Discards all data on this stream, but signals when it is done or an error occurred. [...]
override
elementAt(int index) AsObservableFuture<T>
Returns the value of the indexth data event of this stream. [...]
override
every(bool test(T element)) AsObservableFuture<bool>
Checks whether test accepts all elements provided by this stream. [...]
override
exhaustMap<S>(Stream<S> mapper(T value)) Observable<S>
Converts items from the source stream into a new Stream using a given mapper. It ignores all items from the source stream until the new stream completes. [...]
expand<S>(Iterable<S> convert(T value)) Observable<S>
Creates an Observable from this stream that converts each element into zero or more events. [...]
override
firstWhere(bool test(T element), { dynamic defaultValue(), T orElse() }) AsObservableFuture<T>
Finds the first element of this stream matching test. [...]
override
flatMap<S>(Stream<S> mapper(T value)) Observable<S>
Converts each emitted item into a new Stream using the given mapper function. The newly created Stream will be be listened to and begin emitting items downstream. [...]
flatMapIterable<S>(Stream<Iterable<S>> mapper(T value)) Observable<S>
Converts each item into a new Stream. The Stream must return an Iterable. Then, each item from the Iterable will be emitted one by one. [...]
fold<S>(S initialValue, S combine(S previous, T element)) AsObservableFuture<S>
Combines a sequence of values by repeatedly applying combine. [...]
override
forEach(void action(T element)) AsObservableFuture
Executes action on each element of this stream. [...]
override
handleError(Function onError, { bool test(dynamic error) }) Observable<T>
Creates a wrapper Stream that intercepts some errors from this stream. [...]
override
ignoreElements() Observable<T>
Creates an Observable where all emitted items are ignored, only the error / completed notifications are passed [...]
interval(Duration duration) Observable<T>
Creates an Observable that emits each item in the Stream after a given duration. [...]
join([String separator = "" ]) AsObservableFuture<String>
Combines the string representation of elements into a single string. [...]
override
lastWhere(bool test(T element), { Object defaultValue(), T orElse() }) AsObservableFuture<T>
Finds the last element in this stream matching test. [...]
override
listen(void onData(T event), { Function onError, void onDone(), bool cancelOnError }) StreamSubscription<T>
Adds a subscription to this stream. Returns a StreamSubscription which handles events from the stream using the provided onData, onError and onDone handlers. [...]
override
map<S>(S convert(T event)) Observable<S>
Maps values from a source sequence through a function and emits the returned values. [...]
override
mapTo<S>(S value) Observable<S>
Emits the given constant value on the output Observable every time the source Observable emits a value. [...]
materialize() Observable<Notification<T>>
Converts the onData, on Done, and onError events into Notification objects that are passed into the downstream onData listener. [...]
max([Comparator<T> comparator ]) AsObservableFuture<T>
Converts a Stream into a Future that completes with the largest item emitted by the Stream. [...]
mergeWith(Iterable<Stream<T>> streams) Observable<T>
Combines the items emitted by multiple streams into a single stream of items. The items are emitted in the order they are emitted by their sources. [...]
min([Comparator<T> comparator ]) AsObservableFuture<T>
Converts a Stream into a Future that completes with the smallest item emitted by the Stream. [...]
ofType<S>(TypeToken<S> typeToken) Observable<S>
Filters a sequence so that only events of a given type pass [...]
onErrorResume(Stream<T> recoveryFn(dynamic error)) Observable<T>
Intercepts error events and switches to a recovery stream created by the provided recoveryFn. [...]
onErrorResumeNext(Stream<T> recoveryStream) Observable<T>
Intercepts error events and switches to the given recovery stream in that case [...]
onErrorReturn(T returnValue) Observable<T>
instructs an Observable to emit a particular item when it encounters an error, and then terminate normally [...]
onErrorReturnWith(T returnFn(dynamic error)) Observable<T>
instructs an Observable to emit a particular item created by the returnFn when it encounters an error, and then terminate normally. [...]
pairwise() Observable<List<T>>
Triggers on the second and subsequent triggerings of the input observable. The Nth triggering of the input observable passes the arguments from the N-1th and Nth triggering as a pair. [...]
pipe(StreamConsumer<T> streamConsumer) AsObservableFuture
Pipes the events of this stream into streamConsumer. [...]
override
publish() ConnectableObservable<T>
Convert the current Observable into a ConnectableObservable that can be listened to multiple times. It will not begin emitting items from the original Observable until the connect method is invoked. [...]
publishReplay({int maxSize }) ReplayConnectableObservable<T>
Convert the current Observable into a ReplayConnectableObservable that can be listened to multiple times. It will not begin emitting items from the original Observable until the connect method is invoked. [...]
publishValue({T seedValue }) ValueConnectableObservable<T>
Convert the current Observable into a ValueConnectableObservable that can be listened to multiple times. It will not begin emitting items from the original Observable until the connect method is invoked. [...]
reduce(T combine(T previous, T element)) AsObservableFuture<T>
Combines a sequence of values by repeatedly applying combine. [...]
override
sample(Stream sampleStream) Observable<T>
Returns an Observable that, when the specified sample stream emits an item or completes, emits the most recently emitted item (if any) emitted by the source stream since the previous emission from the sample stream. [...]
scan<S>(S accumulator(S accumulated, T value, int index), [ S seed ]) Observable<S>
Applies an accumulator function over an observable sequence and returns each intermediate result. The optional seed value is used as the initial accumulator value. [...]
share() Observable<T>
Convert the current Observable into a new Observable that can be listened to multiple times. It will automatically begin emitting items when first listened to, and shut down when no listeners remain. [...]
shareReplay({int maxSize }) ReplayObservable<T>
Convert the current Observable into a new ReplayObservable that can be listened to multiple times. It will automatically begin emitting items when first listened to, and shut down when no listeners remain. [...]
shareValue({T seedValue }) ValueObservable<T>
Convert the current Observable into a new ValueObservable that can be listened to multiple times. It will automatically begin emitting items when first listened to, and shut down when no listeners remain. [...]
singleWhere(bool test(T element), { T orElse() }) AsObservableFuture<T>
Finds the single element in this stream matching test. [...]
override
skip(int count) Observable<T>
Skips the first count data events from this stream. [...]
override
skipUntil<S>(Stream<S> otherStream) Observable<T>
Starts emitting items only after the given stream emits an item. [...]
skipWhile(bool test(T element)) Observable<T>
Skip data events from this stream while they are matched by test. [...]
override
startWith(T startValue) Observable<T>
Prepends a value to the source Observable. [...]
startWithMany(List<T> startValues) Observable<T>
Prepends a sequence of values to the source Observable. [...]
switchIfEmpty(Stream<T> fallbackStream) Observable<T>
When the original observable emits no items, this operator subscribes to the given fallback stream and emits items from that observable instead. [...]
switchMap<S>(Stream<S> mapper(T value)) Observable<S>
Converts each emitted item into a new Stream using the given mapper function. The newly created Stream will be be listened to and begin emitting items, and any previously created Stream will stop emitting. [...]
take(int count) Observable<T>
Provides at most the first n values of this stream. Forwards the first n data events of this stream, and all error events, to the returned stream, and ends with a done event. [...]
override
takeUntil<S>(Stream<S> otherStream) Observable<T>
Returns the values from the source observable sequence until the other observable sequence produces a value. [...]
takeWhile(bool test(T element)) Observable<T>
Forwards data events while test is successful. [...]
override
throttle(Duration duration) Observable<T>
Returns an Observable that emits only the first item emitted by the source Observable during sequential time windows of a specified duration. [...]
timeInterval() Observable<TimeInterval<T>>
Records the time interval between consecutive values in an observable sequence. [...]
timeout(Duration timeLimit, { void onTimeout(EventSink<T> sink) }) Observable<T>
The Timeout operator allows you to abort an Observable with an onError termination if that Observable fails to emit any items during a specified duration. You may optionally provide a callback function to execute on timeout.
override
timestamp() Observable<Timestamped<T>>
Wraps each item emitted by the source Observable in a Timestamped object that includes the emitted item and the time when the item was emitted. [...]
toList() AsObservableFuture<List<T>>
Collects all elements of this stream in a List. [...]
override
toSet() AsObservableFuture<Set<T>>
Collects the data of this stream in a Set. [...]
override
transform<S>(StreamTransformer<T, S> streamTransformer) Observable<S>
Applies streamTransformer to this stream. [...]
override
where(bool test(T event)) Observable<T>
Filters the elements of an observable sequence based on the test.
override
window(SamplerBuilder<T, Stream<T>> sampler) Observable<Stream<T>>
Creates an Observable where each item is a Stream containing the items from the source sequence, batched by the sampler. [...]
windowCount(int count, [ int startBufferEvery = 0 ]) Observable<Stream<T>>
Buffers a number of values from the source Observable by count then emits the values inside the buffer as a new Stream, and starts a new buffer each startBufferEvery values. If startBufferEvery is not provided or is null, then new buffers are started immediately at the start of the source and when each buffer closes and is emitted. [...]
windowFuture<O>(Future<O> onFutureHandler()) Observable<Stream<T>>
Creates an Observable where each item is a Stream containing the items from the source sequence, batched whenever onFutureHandler completes. [...]
windowTest(bool onTestHandler(T event)) Observable<Stream<T>>
Creates an Observable where each item is a Stream containing the items from the source sequence, batched whenever onTestHandler passes. [...]
windowTime(Duration duration) Observable<Stream<T>>
Creates an Observable where each item is a Stream containing the items from the source sequence, sampled on a time frame with duration. [...]
windowWhen<O>(Stream<O> other) Observable<Stream<T>>
Creates an Observable where each item is a Stream containing the items from the source sequence, sampled on onStream. [...]
withLatestFrom<S, R>(Stream<S> latestFromStream, R fn(T t, S s)) Observable<R>
Creates an Observable that emits when the source stream emits, combining the latest values from the two streams using the provided function. [...]
zipWith<S, R>(Stream<S> other, R zipper(T t, S s)) Observable<R>
Returns an Observable that combines the current stream together with another stream using a given zipper function. [...]
noSuchMethod(Invocation invocation) → dynamic
Invoked when a non-existent method or property is accessed. [...]
inherited
toString() String
Returns a string representation of this object.
inherited

Operators

operator ==(dynamic other) bool
The equality operator. [...]
inherited

Static Methods

combineLatest<T, R>(Iterable<Stream<T>> streams, R combiner(List<T> values)) Observable<R>
Merges the given Streams into one Observable that emits a List of the values emitted by the source Stream. This is helpful when you need to combine a dynamic number of Streams. [...]
combineLatest2<A, B, T>(Stream<A> streamA, Stream<B> streamB, T combiner(A a, B b)) Observable<T>
Merges the given Streams into one Observable sequence by using the combiner function whenever any of the observable sequences emits an item. [...]
combineLatest3<A, B, C, T>(Stream<A> streamA, Stream<B> streamB, Stream<C> streamC, T combiner(A a, B b, C c)) Observable<T>
Merges the given Streams into one Observable sequence by using the combiner function whenever any of the observable sequences emits an item. [...]
combineLatest4<A, B, C, D, T>(Stream<A> streamA, Stream<B> streamB, Stream<C> streamC, Stream<D> streamD, T combiner(A a, B b, C c, D d)) Observable<T>
Merges the given Streams into one Observable sequence by using the combiner function whenever any of the observable sequences emits an item. [...]
combineLatest5<A, B, C, D, E, T>(Stream<A> streamA, Stream<B> streamB, Stream<C> streamC, Stream<D> streamD, Stream<E> streamE, T combiner(A a, B b, C c, D d, E e)) Observable<T>
Merges the given Streams into one Observable sequence by using the combiner function whenever any of the observable sequences emits an item. [...]
combineLatest6<A, B, C, D, E, F, T>(Stream<A> streamA, Stream<B> streamB, Stream<C> streamC, Stream<D> streamD, Stream<E> streamE, Stream<F> streamF, T combiner(A a, B b, C c, D d, E e, F f)) Observable<T>
Merges the given Streams into one Observable sequence by using the combiner function whenever any of the observable sequences emits an item. [...]
combineLatest7<A, B, C, D, E, F, G, T>(Stream<A> streamA, Stream<B> streamB, Stream<C> streamC, Stream<D> streamD, Stream<E> streamE, Stream<F> streamF, Stream<G> streamG, T combiner(A a, B b, C c, D d, E e, F f, G g)) Observable<T>
Merges the given Streams into one Observable sequence by using the combiner function whenever any of the observable sequences emits an item. [...]
combineLatest8<A, B, C, D, E, F, G, H, T>(Stream<A> streamA, Stream<B> streamB, Stream<C> streamC, Stream<D> streamD, Stream<E> streamE, Stream<F> streamF, Stream<G> streamG, Stream<H> streamH, T combiner(A a, B b, C c, D d, E e, F f, G g, H h)) Observable<T>
Merges the given Streams into one Observable sequence by using the combiner function whenever any of the observable sequences emits an item. [...]
combineLatest9<A, B, C, D, E, F, G, H, I, T>(Stream<A> streamA, Stream<B> streamB, Stream<C> streamC, Stream<D> streamD, Stream<E> streamE, Stream<F> streamF, Stream<G> streamG, Stream<H> streamH, Stream<I> streamI, T combiner(A a, B b, C c, D d, E e, F f, G g, H h, I i)) Observable<T>
Merges the given Streams into one Observable sequence by using the combiner function whenever any of the observable sequences emits an item. [...]
combineLatestList<T>(Iterable<Stream<T>> streams) Observable<List<T>>
Merges the given Streams into one Observable that emits a List of the values emitted by the source Stream. This is helpful when you need to combine a dynamic number of Streams. [...]
range(int startInclusive, int endInclusive) Observable<int>
Returns an Observable that emits a sequence of Integers within a specified range. [...]
tween(double startValue, double changeInTime, Duration duration, { int intervalMs: 16, Ease ease: Ease.LINEAR }) Observable<double>
Creates an Observable that emits values starting from startValue and incrementing according to the ease type over the duration. [...]
zip<T, R>(Iterable<Stream<T>> streams, R zipper(List<T> values)) Observable<R>
Merges the iterable streams into one observable sequence using the given zipper function whenever all of the observable sequences have produced an element at a corresponding index. [...]
zip2<A, B, T>(Stream<A> streamA, Stream<B> streamB, T zipper(A a, B b)) Observable<T>
Merges the specified streams into one observable sequence using the given zipper function whenever all of the observable sequences have produced an element at a corresponding index. [...]
zip3<A, B, C, T>(Stream<A> streamA, Stream<B> streamB, Stream<C> streamC, T zipper(A a, B b, C c)) Observable<T>
Merges the specified streams into one observable sequence using the given zipper function whenever all of the observable sequences have produced an element at a corresponding index. [...]
zip4<A, B, C, D, T>(Stream<A> streamA, Stream<B> streamB, Stream<C> streamC, Stream<D> streamD, T zipper(A a, B b, C c, D d)) Observable<T>
Merges the specified streams into one observable sequence using the given zipper function whenever all of the observable sequences have produced an element at a corresponding index. [...]
zip5<A, B, C, D, E, T>(Stream<A> streamA, Stream<B> streamB, Stream<C> streamC, Stream<D> streamD, Stream<E> streamE, T zipper(A a, B b, C c, D d, E e)) Observable<T>
Merges the specified streams into one observable sequence using the given zipper function whenever all of the observable sequences have produced an element at a corresponding index. [...]
zip6<A, B, C, D, E, F, T>(Stream<A> streamA, Stream<B> streamB, Stream<C> streamC, Stream<D> streamD, Stream<E> streamE, Stream<F> streamF, T zipper(A a, B b, C c, D d, E e, F f)) Observable<T>
Merges the specified streams into one observable sequence using the given zipper function whenever all of the observable sequences have produced an element at a corresponding index. [...]
zip7<A, B, C, D, E, F, G, T>(Stream<A> streamA, Stream<B> streamB, Stream<C> streamC, Stream<D> streamD, Stream<E> streamE, Stream<F> streamF, Stream<G> streamG, T zipper(A a, B b, C c, D d, E e, F f, G g)) Observable<T>
Merges the specified streams into one observable sequence using the given zipper function whenever all of the observable sequences have produced an element at a corresponding index. [...]
zip8<A, B, C, D, E, F, G, H, T>(Stream<A> streamA, Stream<B> streamB, Stream<C> streamC, Stream<D> streamD, Stream<E> streamE, Stream<F> streamF, Stream<G> streamG, Stream<H> streamH, T zipper(A a, B b, C c, D d, E e, F f, G g, H h)) Observable<T>
Merges the specified streams into one observable sequence using the given zipper function whenever all of the observable sequences have produced an element at a corresponding index. [...]
zip9<A, B, C, D, E, F, G, H, I, T>(Stream<A> streamA, Stream<B> streamB, Stream<C> streamC, Stream<D> streamD, Stream<E> streamE, Stream<F> streamF, Stream<G> streamG, Stream<H> streamH, Stream<I> streamI, T zipper(A a, B b, C c, D d, E e, F f, G g, H h, I i)) Observable<T>
Merges the specified streams into one observable sequence using the given zipper function whenever all of the observable sequences have produced an element at a corresponding index. [...]
zipList<T>(Iterable<Stream<T>> streams) Observable<List<T>>
Merges the iterable streams into one observable sequence using the given zipper function whenever all of the observable sequences have produced an element at a corresponding index. [...]