Var

Type Members

type State[V] = Operators.State[V]

Definition Classes
Signal → ReadAs → ReSource
type Value = Pulse[A]

Definition Classes
Var → Signal → Base → ReSource

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def abortOnError(message: String)(implicit ticket: CreationTicket): Operators.Signal[A]

Definition Classes
Signal
Annotations
@cutOutOfUserComputation()
final def admit(value: A)(implicit ticket: AdmissionTicket[State]): Unit

Definition Classes
Source
def admitPulse(pulse: Pulse[A])(implicit ticket: AdmissionTicket[State]): Unit

Definition Classes
Var → Source
final def apply(): A

Makes the enclosing reactive expression depend on the current value of the reactive.
Makes the enclosing reactive expression depend on the current value of the reactive. Is an alias for value.

Definition Classes
MacroAccess
Annotations
@compileTimeOnly( ... )
See also
value
final def asInstanceOf[T0]: T0

Definition Classes
Any
final def change(implicit ticket: CreationTicket): Operators.Event[Diff[A]]

Create an event that fires every time the signal changes.
Create an event that fires every time the signal changes. It fires the tuple (oldVal, newVal) for the signal. Be aware that no change will be triggered when the signal changes to or from empty

Definition Classes
Signal
Annotations
@cutOutOfUserComputation()
final def changed(implicit ticket: CreationTicket): Operators.Event[A]

Create an event that fires every time the signal changes.
Create an event that fires every time the signal changes. The value associated to the event is the new value of the signal

Definition Classes
Signal
Annotations
@cutOutOfUserComputation()
final def changedTo[V >: A](value: V)(implicit ticket: CreationTicket): Operators.Event[Unit]

Convenience function filtering to events which change this reactive to value
Convenience function filtering to events which change this reactive to value

Definition Classes
Signal
Annotations
@cutOutOfUserComputation()
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def commit(base: Value): Value

Attributes
protected[rescala]
Definition Classes
Signal → ReSource
def disconnect(): Unit

Definition Classes
Var → Disconnectable
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def flatten[R](implicit flatten: Operators.Flatten[Operators.Signal[A], R]): R

Flattens the inner value.
Flattens the inner value.

Definition Classes
Signal
Annotations
@cutOutOfUserComputation()
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
val info: ReInfo

the name of the reactive, useful for debugging as it often contains positional information
the name of the reactive, useful for debugging as it often contains positional information

Definition Classes
Base → ReSource
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final macro def map[B](expression: (A) ⇒ B)(implicit ticket: CreationTicket): Operators.Signal[B]

Return a Signal with f applied to the value
Return a Signal with f applied to the value

Definition Classes
SignalCompat
Annotations
@cutOutOfUserComputation()
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final def now(implicit scheduler: Scheduler[State]): A

Returns the current value of the signal However, using now is in most cases not what you want.
Returns the current value of the signal However, using now is in most cases not what you want. It does not build dependencies, does not integrate into transactions. Use only for examples and debug output.

Definition Classes
Signal
final def observe(onValue: (A) ⇒ Unit, onError: (Throwable) ⇒ Unit = null, fireImmediately: Boolean = true)(implicit ticket: CreationTicket): Disconnectable

add an observer
add an observer

Definition Classes
Signal
def read(v: Value): A

Interprets the internal type to the external type
Interprets the internal type to the external type

Definition Classes
Signal → ReadAs
final def readValueOnce(implicit scheduler: Scheduler[State]): A

Returns the current value of the signal
Returns the current value of the signal

Definition Classes
Signal
final def recover[R >: A](onFailure: PartialFunction[Throwable, R])(implicit ticket: CreationTicket): Operators.Signal[R]

Uses a partial function onFailure to recover an error carried by the event into a value.
Uses a partial function onFailure to recover an error carried by the event into a value.

Definition Classes
Signal
Annotations
@cutOutOfUserComputation()
val resource: Operators.Signal[A]

Definition Classes
Var → Signal → MacroAccess
def set(value: A)(implicit sched: Scheduler[State], scopeSearch: ScopeSearch): Unit
def setEmpty()(implicit fac: Scheduler[State]): Unit
val state: Operators.State[Pulse[A]]

the state passed by the scheduler
the state passed by the scheduler

Attributes
protected[rescala]
Definition Classes
Base → ReSource
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
Base → AnyRef → Any
def transform(f: (A) ⇒ A)(implicit sched: Scheduler[State], scopeSearch: ScopeSearch): Unit
final def value: A

Makes the enclosing reactive expression depend on the current value of the reactive.
Makes the enclosing reactive expression depend on the current value of the reactive. Is an alias for rescala.macros.MacroAccess.apply.

Definition Classes
MacroAccess
Annotations
@compileTimeOnly( ... )
See also
apply
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def withDefault[R >: A](value: R)(implicit ticket: CreationTicket): Operators.Signal[R]

Definition Classes
Signal
Annotations
@cutOutOfUserComputation()

Related Docs: object Var | package Sources

class Var[A] extends Base[State, Pulse[A]] with Operators.Source[A] with Operators.Signal[A]

Type Members

type State[V] = Operators.State[V]

type Value = Pulse[A]

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def abortOnError(message: String)(implicit ticket: CreationTicket): Operators.Signal[A]

final def admit(value: A)(implicit ticket: AdmissionTicket[State]): Unit

def admitPulse(pulse: Pulse[A])(implicit ticket: AdmissionTicket[State]): Unit

final def apply(): A

final def asInstanceOf[T0]: T0

final def change(implicit ticket: CreationTicket): Operators.Event[Diff[A]]

final def changed(implicit ticket: CreationTicket): Operators.Event[A]

final def changedTo[V >: A](value: V)(implicit ticket: CreationTicket): Operators.Event[Unit]

def clone(): AnyRef

def commit(base: Value): Value

def disconnect(): Unit

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def flatten[R](implicit flatten: Operators.Flatten[Operators.Signal[A], R]): R

final def getClass(): Class[_]

def hashCode(): Int

val info: ReInfo

final def isInstanceOf[T0]: Boolean

final macro def map[B](expression: (A) ⇒ B)(implicit ticket: CreationTicket): Operators.Signal[B]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def now(implicit scheduler: Scheduler[State]): A

final def observe(onValue: (A) ⇒ Unit, onError: (Throwable) ⇒ Unit = null, fireImmediately: Boolean = true)(implicit ticket: CreationTicket): Disconnectable

def read(v: Value): A

final def readValueOnce(implicit scheduler: Scheduler[State]): A

final def recover[R >: A](onFailure: PartialFunction[Throwable, R])(implicit ticket: CreationTicket): Operators.Signal[R]

val resource: Operators.Signal[A]

def set(value: A)(implicit sched: Scheduler[State], scopeSearch: ScopeSearch): Unit

def setEmpty()(implicit fac: Scheduler[State]): Unit

val state: Operators.State[Pulse[A]]

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

def toString(): String

def transform(f: (A) ⇒ A)(implicit sched: Scheduler[State], scopeSearch: ScopeSearch): Unit

final def value: A

final def wait(): Unit

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

final def wait(arg0: Long): Unit

final def withDefault[R >: A](value: R)(implicit ticket: CreationTicket): Operators.Signal[R]

Inherited from Operators.Signal[A]

Inherited from Operators.SignalCompat[A]

Inherited from Operators.ReadableMacro[Operators.State, A]

Inherited from MacroAccess[A, ReadAs[Operators.State, A]]

Inherited from ReadAs[Operators.State, A]

Inherited from Disconnectable

Inherited from Operators.Source[A]

Inherited from Base[Operators.State, Pulse[A]]

Inherited from ReSource

Inherited from AnyRef

Inherited from Any

internal

Accessor and observers

Signal operators

Signal to Event conversions

Ungrouped