expr

Type Members

1. trait Expr[S <: Sys[S], +A] extends Writable with Disposable[expr.Expr.S.Tx] with Publisher[S, Change[A]]

   

   An expression is a computation that reduces to a single value of type A.

   An expression is a computation that reduces to a single value of type A. Expressions can be understood as dataflow variables. When a tree is composed, a change in the root of the tree propagates through to the leaves in the form of an emitted Change event that carries the old and new value (according to the particular node of the tree).

   Basic expression types are Expr.Const - it simply wraps a constant value and thus will never change or fire an event - and Expr.Var which can be thought of as a mutable variable carrying a peer expression. When the variable assignment changes, the expression currently held is evaluated and propagated as an event. Intermediate nodes or expressions might modify the value, such as a binary operator (e.g., an integer expression that sums two input integer expressions).

2. trait ExprType[A] extends Type

   

3. type ExprType1[A] = ExprType[A] with Type1Like[[$tilde]Expr[~, A]]

   

4. trait List[S <: Sys[S], Elem, U] extends Writable with Disposable[expr.List.S.Tx] with Publisher[S, Update[S, Elem, U]]

   

   An observable linked list with fast head and last operations.

   An observable linked list with fast head and last operations. This is the read-only layer, see List.Modifiable for a mutable list.

   The list will report insertions and deletions, as well as forward designated element events of type U.

   Elem

   the element type of the list

   U

   the updates fired by the element type

5. trait Map[S <: Sys[S], K, V, U] extends Node[S] with Publisher[S, Update[S, K, V, U]]

   

6. trait Type extends AnyRef

   

7. trait Type1[Repr[~ <: Sys[~]]] extends Type1Like[Repr]

   

8. trait Type1A[Repr[~ <: Sys[~]]] extends Type1Like[Repr]

   

   This is for backwards compatibility: Operators are not just identified by an operator id, but also by an arity byte which must be 1 or 2.

   This is for backwards compatibility: Operators are not just identified by an operator id, but also by an arity byte which must be 1 or 2. For new implementations, just Type1 should be used.

9. trait Type1Like[Repr[~ <: Sys[~]]] extends Type

   

10. trait Type2[Repr[~ <: Sys[~], _]] extends Type

    

11. trait Type3[Repr[~ <: Sys[~], _, _]] extends Type