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

Await the completion of the first Rx result. This method is available only in Scala JVM.

Note: Generally speaking, blocking operations should be avoided in reactive programming. Use this method only for testing purpose. Both airframe-http and AirSpec supports evaluating Rx[X] result (async) in a non-blocking way.

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 => ... }

Applies the given filter and emit the value only when the filter condition matches

Applies f to the input value that produces another Rx stream.

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

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

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

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 { ...} }.

Applies f to the input value and return the result.

Applies f to the input value that produces another Rx stream. This method is an alias of flatMap(f)

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.

Applies f to the value for having a side effect, and return the original value.

The difference from tapOn is that this method will not receive an input failure.

Applies f to the value for having a side effect, and return the original value.

This method is useful for debugging Rx chains. For example:

rx.tapOn {
  case Success(v) => debug(s"received ${v}")
  case Failure(e) => error(s"request failed", e)
}

Applies f to the error if it happens, and return the original value.

This method is useful for logging the error.

Emit the first item of the source within each sampling period. For example, this is useful 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.

Transform a Success(v) or Failure(Throwable) input with a given function.

Transform a specific type of an exception into another exception. This is useful for handling exceptions.

Transform the input value by wrapping it with Try regardless of success or failure. This is useful when you need to handle both success and failure cases in the same way.

Transform the input value by wrapping it with Try regardless of success or failure. This is useful when you need to add a post-processing step after handling success and failure cases.

An alias of filter

An alias of filter

Combine five Rx streams to form a sequence of quintuples. This will emit a new quintuple when all of the streams are updated.

Combine four Rx streams to form a sequence of quadruples. This will emit a new quadruple when all of the streams are updated.

Combine three Rx streams to form a sequence of triples. This will emit a new triple when all of the streams are updated.

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