core

Type Members

1. class Dynamic[+T] extends Rx[T] with Reactor[Any] with Spinlock[T]

   

   An Rx whose dependencies are set dynamically at runtime when calc is evaluated, and may change again any time it gets re-evaluated

2. trait Emitter[+T] extends Node

   

   Something that emits pings.

   Something that emits pings. Manages a list of WeakReferences containing Reactors which need to be pinged when an event is fired.

3. sealed trait Node extends AnyRef

   

   A member of a Scala.

   A member of a Scala.Rx dataflow graph. Apart from the fact that it has a name and a current level in the graph, we don't really know much about it. It could be either a Emitter or a Reactor or both.

4. class Obs extends Reactor[Any]

   

   An Obs is something that produces side-effects when the source Rx changes.

   An Obs is something that produces side-effects when the source Rx changes. An Obs is always run right at the end of every propagation wave, ensuring it is only called once per wave (in contrast with Rxs, which may update multiple times before settling).

5. trait Propagator[P] extends AnyRef

   

   A Propagator is an object which performs a propagation wave over the Scala.

   A Propagator is an object which performs a propagation wave over the Scala.Rx dataflow graph. It is parametrized on the type P which it returns after performing a propagation wave. The two existing Propagators are:

   Propagator.Immediate (Propagator[Unit]), which runs the propagation wave immediately and returns Unit when it is complete.

   Propagator.ExecContext (Propagator[Future[Unit]]), which runs the propagation wave on the given ExecutionContext and returns a Future[Unit] representing the completion of the propagation wave.

   It is conceivable that custom propagators could use the return type P to return other things, e.g. the number of updates performed, or the number of re-tries in that propagation wave. That is up to the implementer to decide.

   P

   the type that the propagate() function returns

6. trait Reactor[-T] extends Node

   

   Something that can receive pings and react to them in some way.

   Something that can receive pings and react to them in some way. How it reacts is up to the implementation.

7. trait Rx[+T] extends Emitter[T] with Reactor[Any]

   

   An Rx is a value that can change over time, emitting pings whenever it changes to notify any dependent Rxs that they need to update.

8. case class SpinSet[T](t: T) extends AtomicReference[T] with Product with Serializable

   

   A wrapper around AtomicReference, allowing you to apply "atomic" transforms to the boxed data by using a Compare-And-Set retry loop.

9. class Staged[T] extends AnyRef

   

10. class Var[T] extends Rx[T]

    

    A Var is an Rx which can be changed manually via assignment.