RxVar

final def !=(arg0: Any): Boolean

final def ##(): Int

def :=(newValue: A): Unit

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def concat[A1 >: A](other: Rx[A1]): RxStream[A1]

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

macro def debug(message: Any): Unit

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

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

macro def error(message: Any): Unit

def filter(f: (A) ⇒ Boolean): RxStream[A]

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

def forceSet(newValue: A): Unit

def forceUpdate(updater: (A) ⇒ A): Unit

Update the variable and force notification to subscribers

def foreach[U](f: (A) ⇒ U): Cancelable

def get: A

final def getClass(): Class[_]

def hashCode(): Int

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)]

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

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

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

def lastOption: RxOption[A]

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

lazy val logger: Logger

def map[B](f: (A) ⇒ 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) ⇒ U): Cancelable

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

def runContinuously[U](effect: (A) ⇒ U): Cancelable

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

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

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

def set(newValue: A): Unit

def subscribe[U](subscriber: (A) ⇒ U): Cancelable

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

def take(n: Long): RxStream[A]

Take an event up to n elements.

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

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

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

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

def toOption[X, A1 >: A](implicit ev: <:<[A1, Option[X]]): RxOptionVar[X]

def toRxStream: RxStream[A]

def toSeq: Seq[A]

Materialize the stream as Seq[A].

def toString(): String

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

macro def trace(message: Any): Unit

def update(updater: (A) ⇒ A, force: Boolean = false): Unit

Updates the variable and trigger the recalculation of the subscribers currentValue => newValue

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) ⇒ Boolean): RxStream[A]

def withName(name: String): RxStream[A]

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

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

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

Combine two Rx streams to form a sequence of pairs.

def finalize(): Unit