Zip4Op

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

val a: Rx[A]

final def asInstanceOf[T0]: T0

val b: Rx[B]

val c: Rx[C]

def clone(): AnyRef

def concat[A1 >: (A, B, C, D)](other: Rx[A1]): RxStream[A1]

val d: Rx[D]

macro def debug(message: Any, cause: Throwable): Unit

macro def debug(message: Any): Unit

final def eq(arg0: AnyRef): Boolean

macro def error(message: Any, cause: Throwable): Unit

macro def error(message: Any): Unit

def filter(f: ((A, B, C, D)) ⇒ Boolean): RxStream[(A, B, C, D)]

def flatMap[B](f: ((A, B, C, D)) ⇒ Rx[B]): RxStream[B]

final def getClass(): Class[_]

macro def info(message: Any, cause: Throwable): Unit

macro def info(message: Any): Unit

final def isInstanceOf[T0]: Boolean

def join[B, C, D](b: Rx[B], c: Rx[C], d: Rx[D]): RxStream[((A, B, C, D), B, C, D)]

def join[B, C](b: Rx[B], c: Rx[C]): RxStream[((A, B, C, D), B, C)]

def join[B](other: Rx[B]): RxStream[((A, B, C, D), B)]

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

def lastOption: RxOption[(A, B, C, D)]

macro def logAt(logLevel: LogLevel, message: Any): Unit

lazy val logger: Logger

def map[B](f: ((A, B, C, D)) ⇒ B): RxStream[B]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def parents: Seq[Rx[_]]

def recover[U](f: PartialFunction[Throwable, U]): RxStream[U]

Recover from a known error and emit a replacement value

def recoverWith[A](f: PartialFunction[Throwable, Rx[A]]): RxStream[A]

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

def run[U](effect: ((A, B, C, D)) ⇒ U): Cancelable

Evaluate this Rx[A] and apply the given effect function.

def runContinuously[U](effect: ((A, B, C, D)) ⇒ U): Cancelable

Keep evaluating Rx[A] even if OnError(e) or OnCompletion is reported.

def sample(timeWindow: Long, unit: TimeUnit = TimeUnit.MILLISECONDS): RxStream[(A, B, C, D)]

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

def subscribe[U](subscriber: ((A, B, C, D)) ⇒ U): Cancelable

final def synchronized[T0](arg0: ⇒ T0): T0

def take(n: Long): RxStream[(A, B, C, D)]

Take an event up to n elements.

def throttleFirst(timeWindow: Long, unit: TimeUnit = TimeUnit.MILLISECONDS): RxStream[(A, B, C, D)]

Emit the first item of the source within each sampling period.

def throttleLast(timeWindow: Long, unit: TimeUnit = TimeUnit.MILLISECONDS): RxStream[(A, B, C, D)]

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

def toOption[X, A1 >: (A, B, C, D)](implicit ev: <:<[A1, Option[X]]): RxOption[X]

def toRxStream: RxStream[(A, B, C, D)]

def toSeq: Seq[(A, B, C, D)]

Materialize the stream as Seq[A].

macro def trace(message: Any, cause: Throwable): Unit

macro def trace(message: Any): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

final def wait(): Unit

macro def warn(message: Any, cause: Throwable): Unit

macro def warn(message: Any): Unit

def withFilter(f: ((A, B, C, D)) ⇒ Boolean): RxStream[(A, B, C, D)]

def withName(name: String): RxStream[(A, B, C, D)]

def zip[B, C, D](b: Rx[B], c: Rx[C], d: Rx[D]): RxStream[((A, B, C, D), B, C, D)]

def zip[B, C](b: Rx[B], c: Rx[C]): RxStream[((A, B, C, D), B, C)]

def zip[B](other: Rx[B]): RxStream[((A, B, C, D), B)]

Combine two Rx streams to form a sequence of pairs.

def finalize(): Unit