core

Type Members

class AMB[T] extends RxMergerN[T, T]

Mirrors the one Observable in an Iterable of several Observables that first emits an item.
Mirrors the one Observable in an Iterable of several Observables that first emits an item.
class Cache[T] extends RxTransformer[T, T]

Caches the items emitted by the source, so that future subscriptions can "replay" them from the beginning.
Caches the items emitted by the source, so that future subscriptions can "replay" them from the beginning.
class Collect[T, R] extends RxTransformer[T, R]

Applies a partial function to all elements emitted by the source.
class CombineLatest[T] extends RxMergerN[T, Seq[T]]

Combines multiple Observables into a single Observable of lists, emitting a new list each time any of the sources emits a new item.
Combines multiple Observables into a single Observable of lists, emitting a new list each time any of the sources emits a new item.

See also
ReactiveX operators documentation: CombineLatest
class CombineLatest2[T1, T2] extends RxMerger2[T1, T2, (T1, T2)]

Combines two Observables into a single Observable of Tuple2, emitting a new tuple each time either of the sources emits a new item.
Combines two Observables into a single Observable of Tuple2, emitting a new tuple each time either of the sources emits a new item.

See also
ReactiveX operators documentation: CombineLatest
class CombineLatest3[T1, T2, T3] extends RxMerger3[T1, T2, T3, (T1, T2, T3)]

Combines three Observables into a single Observable of Tuple3, emitting a new tuple each time any of the sources emits a new item.
Combines three Observables into a single Observable of Tuple3, emitting a new tuple each time any of the sources emits a new item.

See also
ReactiveX operators documentation: CombineLatest
class Concat[T] extends RxMerger2[T, T, T]

First emits the items emitted by the first source, and then the items emitted by the second.
First emits the items emitted by the first source, and then the items emitted by the second.
class Contains[T] extends RxTransformer[T, Boolean]

Emits a Boolean that indicates whether the source emitted a specified item.
Emits a Boolean that indicates whether the source emitted a specified item.
class Count[T] extends RxTransformer[T, Int]

Counts the total number of elements in the source sequence.
Counts the total number of elements in the source sequence. It can either produce a rolling count on each item, or just one final result when source is complete.
class Debounce[T] extends RxTransformer[T, T]

Drops all values from the source that are followed by newer values before the timeout value expires.
Drops all values from the source that are followed by newer values before the timeout value expires.
class Delay[T] extends RxTransformer[T, T]

Emits the items emitted by the source shifted forward in time by a specified delay.
Emits the items emitted by the source shifted forward in time by a specified delay.
class Distinct[T] extends RxTransformer[T, T]

Applies the selector function to the source sequence and then drops the repeated items.
Applies the selector function to the source sequence and then drops the repeated items. If global parameter is false it deletes sequential repeated elements; if it is true, then it deletes all repeated elements.
class DropByCount[T] extends RxTransformer[T, T]

Drops a specified number of items from the beginning or end of source sequence.
Drops a specified number of items from the beginning or end of source sequence.
class DropByTime[T] extends RxTransformer[T, T]

Drops items from either a beginning or end of the source sequence, for the duration of the specified time window.
Drops items from either a beginning or end of the source sequence, for the duration of the specified time window.
class DropWhile[T] extends RxTransformer[T, T]

Drops items from the source as long as the predicate condition is true.
Drops items from the source as long as the predicate condition is true.
class ElementAt[T] extends RxTransformer[T, T]

Emits the item found at a specified index in a sequence of emissions from a source, or a default item if that index is out of range.
Emits the item found at a specified index in a sequence of emissions from a source, or a default item if that index is out of range.
class Empty extends AbstractRxBlock[Nothing]

Emits no data and completes immediately.
Emits no data and completes immediately.
class Exists[T] extends RxTransformer[T, Boolean]

Tests whether a predicate holds for some of the elements of the source.
class Filter[T] extends RxTransformer[T, T]

Only emits those items from the source sequence for which a given predicate holds.
Only emits those items from the source sequence for which a given predicate holds.
class First[T] extends RxTransformer[T, T]

Emits the very first item emitted by the source, or a default if the source is empty.
Emits the very first item emitted by the source, or a default if the source is empty.
class Fold[T, R] extends RxTransformer[T, R]

Repeatedly applies a function, where the first argument is the result obtained in the previous application (first time - the initial value), and the second argument is each element of the source sequence.
Repeatedly applies a function, where the first argument is the result obtained in the previous application (first time - the initial value), and the second argument is each element of the source sequence. Unlike scan it only emits the final result when the source sequence is complete.
class FromList[A] extends AbstractRxBlock[A]

Combines items passed into its ports into a single Observable.
Combines items passed into its ports into a single Observable.
class Insert[T] extends RxTransformer[T, T]

Emits a specified item either before or after it emits items from the source.
Emits a specified item either before or after it emits items from the source.
class Interval extends AbstractRxBlock[Long]

Emits values 0, 1, 2 and so on at equal time intervals.
Emits values 0, 1, 2 and so on at equal time intervals.
class IsEmpty extends RxTransformer[Any, Boolean]

Tests whether the source emits no elements.
class Last[T] extends RxTransformer[T, T]

Emits the very last item emitted by the source, or a default if the source is empty.
Emits the very last item emitted by the source, or a default if the source is empty.
class Length extends Count[Any]

A shortcut for Count with a trivial predicate that always returns true, i.e.
A shortcut for Count with a trivial predicate that always returns true, i.e. it counts all the items in the source sequence.
class Merge[T] extends RxMerger2[T, T, T]

Flattens two Observables into one Observable, without any transformation.
Flattens two Observables into one Observable, without any transformation.
class RandomInterval extends AbstractRxBlock[Long]

Emits 0, 1, 2, ... with a delay, randomly chosen for each item.
class Reduce[T] extends RxTransformer[T, T]

Repeatedly applies a function, where the first argument is the result obtained in the previous application and the second argument is each element of the source sequence.
Repeatedly applies a function, where the first argument is the result obtained in the previous application and the second argument is each element of the source sequence.
class Repeat[T] extends RxTransformer[T, T]

Repeats the sequence of items emitted by the source either indefinitely or at most count times.
Repeats the sequence of items emitted by the source either indefinitely or at most count times.
class Retry[T] extends RxTransformer[T, T]

Retries the sequence emitted by the source in case of an error, either indefinitely or at most count times.
Retries the sequence emitted by the source in case of an error, either indefinitely or at most count times.
class Sample[T] extends RxTransformer[T, T]

Emits the results of sampling the items emitted by the source at a specified time interval.
Emits the results of sampling the items emitted by the source at a specified time interval.
class Scan[T, R] extends RxTransformer[T, R]

Continuouly applies a function, where the first argument is the result obtained in the previous application (first time - the initial value), and the second argument is each element of the source sequence.
Continuouly applies a function, where the first argument is the result obtained in the previous application (first time - the initial value), and the second argument is each element of the source sequence. Unlike fold it emits each intermediate result.
class Sequence[A] extends AbstractRxBlock[A]

Emits items from the supplied collection.
Emits items from the supplied collection.
class TakeByCount[T] extends RxTransformer[T, T]

Emits only first count items emitted by the source.
Emits only first count items emitted by the source.
class TakeByTime[T] extends RxTransformer[T, T]

Emits items from the source before a specified time runs out.
Emits items from the source before a specified time runs out.
class TakeRight[T] extends RxTransformer[T, T]

Emits items from the source that were emitted in a specified window of time before the source completed, or the last count items of the source.
Emits items from the source that were emitted in a specified window of time before the source completed, or the last count items of the source.
class TakeWhile[T] extends RxTransformer[T, T]

Emits items from the source as long as the predicate condition is true.
Emits items from the source as long as the predicate condition is true.
class Timer extends AbstractRxBlock[Long]

Emits 0L after the specified delay and completes.
Emits 0L after the specified delay and completes.
class Transform[T, R] extends RxTransformer[T, R]

Transforms each item of the source sequence into a new one, using the functional operator.
Transforms each item of the source sequence into a new one, using the functional operator.
class ValueHolder[A] extends AbstractRxBlock[A]

Forwards the values passed into its value port.
Forwards the values passed into its value port.
class WindowBySize[T] extends RxTransformer[T, Seq[T]]

Creates an Observable which produces buffers of collected values.
Creates an Observable which produces buffers of collected values.
It produces a new buffer of at most count size every skip values. Therefore if count == skip, it produces non-overlapping buffers.
class WindowByTime[T] extends RxTransformer[T, Seq[T]]

Creates an Observable which produces buffers of collected values.
class Zero[T] extends AbstractRxBlock[T]

Emits a single "zero" item for the specified numeric type.
class Zip[T] extends RxMergerN[T, Seq[T]]

Combines multiple Observables into a single Observable of lists.
Combines multiple Observables into a single Observable of lists. Unlike CombineLatest it emits a new value only when all sources have emitted the next item.
class Zip2[T1, T2] extends RxMerger2[T1, T2, (T1, T2)]

Combines two Observables into a single Observable of Tuple2, emitting a new tuple after both sources emitted the next item.
class Zip3[T1, T2, T3] extends RxMerger3[T1, T2, T3, (T1, T2, T3)]

Combines three Observables into a single Observable of Tuple3, emitting a new tuple after all sources emitted the next item.
class Zip4[T1, T2, T3, T4] extends RxMerger4[T1, T2, T3, T4, (T1, T2, T3, T4)]

Combines three Observables into a single Observable of Tuple4, emitting a new tuple after all sources emitted the next item.
class ZipWithIndex[T] extends RxTransformer[T, (T, Int)]

Combines the items from the source Observable with their indices.