RxBlockingQueue

Combine Rx stream and Future operators.

This method is useful when you need to call RPC multiple times and chain the next operation after receiving the response.

Rx.intervalMillis(1000)
 .andThen { i => callRpc(...) } // Returns Future
 .map { (rpcReturnValue) => ... } // Use the Future response

Cache the last item, and emit the cached value if available.

The cached value will be preserved to the operator itself even after cancelling the subscription. Re-subscription of this operator will immediately return the cached value to the downstream operator.

This operator is useful if we need to involve time-consuming process, and want to reuse the last result: val v = Rx.intervalMillis(1000).map(i => (heavy process)).cache

v.map { x => ... }

Emit a new output if one of Rx[A] or Rx[B] is changed.

This method is useful when you need to monitor multiple Rx objects.

Using joins will be more intuitive than nesting multiple Rx operators like Rx[A].map { x => ... Rx[B].map { ...} }.

Recover from a known error and emit a replacement value

Recover from a known error and emit replacement values from a given Rx

Evaluate this Rx[A] and apply the given effect function. Once OnError(e) or OnCompletion is observed, it will stop the evaluation.

Keep evaluating Rx[A] even if OnError(e) or OnCompletion is reported. This is useful for keep processing streams.

Emit the most recent item of the source within periodic time intervals.

Emit the given items first before returning the items from the source.

Emit the given item first before returning the items from the source.

Take an event up to n elements. This may receive fewer events than n if the upstream operator completes before generating n elements.

Emit the first item of the source within each sampling period. This is useful, for example, to prevent double-clicks of buttons.

Emit the most recent item of the source within periodic time intervals.

Materialize the stream as Seq[A]. This works only for the finite stream and for Scala JVM.

Combine two Rx streams to form a sequence of pairs. This will emit a new pair when both of the streams are updated.