reactify

Type Members

1. abstract class AbstractState[T] extends State[T]

   

2. trait ChangeListener[T] extends AnyRef

   

   Convenience functionality for classic change management referencing the old value along with the new value.

   Convenience functionality for classic change management referencing the old value along with the new value.

   T

   the type of changes

3. trait Channel[T] extends Observable[T]

   

4. class Dep[T, V] extends StateChannel[T]

   

   Dep is very much like a Val, but is also a Channel.

   Dep is very much like a Val, but is also a Channel. The basic purpose is to represent a value dependent upon another variable. An example of this might be if you are representing a position left and you also wanted to represent right as well (which would be left + width). These two variables are dependent upon each other and don't fit well as Vars. An example usage might be:

   val left: Var[Double] = Var(0.0) val width: Var[Double] = Var(0.0) val right: Dep[Double, Double] = Dep(left, width)

   If an instance is submissive it removes adjustment from being part of the mutation dependency. For example: in the above scenario if you set width to 100.0 and right to 125.0 then left will be 25.0. Now, what should happen if you change width to 50.0? Should left change to 75.0 (submissive = false) or should right change to 75.0 (submissive = true)?

5. trait DepConnector[T, V] extends AnyRef

   

6. implicit class ListStateChannel[T] extends AnyRef

   

   Syntactic sugar for mutating collections in a StateChannel

7. trait Observable[T] extends AnyRef

   

   Observable, as the name suggests, observes values being fired against it.

   Observable, as the name suggests, observes values being fired against it. This is the core functionality of Reactify and provides the infrastructure used by Channel, Val, Var, Prop, and Dep.

   T

   the type of value this Observable will receive

8. class PreviousFunction[T] extends AnyRef

   

9. class Prop[T] extends StateChannel[T]

   

   Functionally similar to Var, except represents a far more simplistic and light-weight storage of a value, not a function.

   Functionally similar to Var, except represents a far more simplistic and light-weight storage of a value, not a function. Not that Var is heavy, but this is the absolute bare minimum representation of a mutable value while still remaining Observable.

   T

   the type of this Prop

10. trait State[T] extends Observable[T]

    

11. trait StateChannel[T] extends State[T] with Channel[T]

    

12. class Val[T] extends AbstractState[T]

    

    Val, as the name suggests, is like a Scala val.

    Val, as the name suggests, is like a Scala val. This represents an immutable value that is set in the first place and then not modified. However, since the value set may be built from Observables, the generated value may change over time as its dependencies are modified. This class is Observable and will only fire changes if the underlying value is derived from one or more Observables.

    T

    the type of value retained by this State

13. class Var[T] extends Val[T] with StateChannel[T]

    

    Var, as the name suggests, is very similar to a Scala var.

    Var, as the name suggests, is very similar to a Scala var. The value is defined during instantiation, but may be modified later. The value may be a static value, or may be a derived value depending on multiple Observables. If Observables make up the value they will be monitored and events fired on this Observable as the value changes.

    T

    the type of value this channel receives

14. implicit class VectorStateChannel[T] extends AnyRef