Val

final def !=(arg0: Any): Boolean

final def ##(): Int

def &(that: Val[T]): Val[T]

Group multiple Vals together

def &(that: Stateful[T]): Stateful[T]

Group multiple Statefuls together

final def ==(arg0: Any): Boolean

var _references: Set[Val[_]]

def and(that: Val[T]): Val[T]

Group multiple Vals together

def and(that: Stateful[T]): Stateful[T]

Group multiple Statefuls together

def apply(): T

Convenience wrapper around get

final def asInstanceOf[T0]: T0

def attach(f: (T) ⇒ Unit, priority: Double = Priority.Normal): Reaction[T]

Convenience method to create a Reaction to attach to this Reactive

def attachAndFire(f: (T) ⇒ Unit, priority: Double = Priority.Normal): Reaction[T]

Convenience functionality to attach a Reaction and immediately fire the current state on the Reaction.

def changes(f: (T, T) ⇒ Unit, priority: Double = Priority.Normal): Reaction[T]

Convenience method to create a Reaction to monitor changes to this Reactive

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equality(t1: T, t2: T): Boolean

def equals(arg0: Any): Boolean

def fire(value: T, previous: Option[T], reactions: List[Reaction[T]] = this.reactions()): ReactionStatus

Fires the value to the Reactions

var function: () ⇒ T

def future(condition: (T) ⇒ Boolean = _ => true): Future[T]

Convenience method to create a Future[T] that will complete upon the next reaction that meets to supplied condition.

def get: T

Gets the current value from the current State

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def map[R](f: (T) ⇒ R): Val[R]

Maps this Val to another type.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def on(f: ⇒ Unit, priority: Double = Priority.Normal): Reaction[T]

Convenience method to create a Reaction to monitor changes to this Reactive when you don't care about the actual value.

def once(f: (T) ⇒ Unit, condition: (T) ⇒ Boolean = _ => true, priority: Double = Priority.Normal): Reaction[T]

Convenience method to create a Reaction to monitor a single reaction based on an optional condition.

def option: Option[T]

var previous: Option[T]

lazy val reactions: Reactions[T]

Reactions currently associated with this Reactive

def references: Set[Val[_]]

def set(value: ⇒ T): Unit

var state: Try[T]

def static(value: T): Unit

def status: Option[ReactionStatus]

If the current thread is reacting to a value currently, status represents the status of the reaction.

def status_=(status: ReactionStatus): Unit

def stopPropagation(): Unit

Shortcut functionality to call status = ReactionStatus.Stop

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

def toString(): String

def toTry: Try[T]

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

final def wait(arg0: Long): Unit

final def wait(): Unit

def finalize(): Unit