An 'a t holds a value of type 'a, which will update as necessary.

const x is the constant value x.

An 'a cc is a changable computation that can be run to get a value of type 'a. Internally, it is a function that takes a destination variable, reads zero or more other changable values, and then updates the destination.

read x f is a computation that depends on x. f will be called as necessary to ensure that the result stays up-to-date with changes in x.

write x is a computation that always returns x.

• parameter eq

  If eq old_value x = true then the new value is considered equal and no update is done. The default is (==). It is always safe (though inefficient) to return false here.

of_cc x is a changeable value holding the result of evaluating x.

on_release fn calls fn if the current computation has to be redone. This may be useful to release external resources when they are no longer needed. Note that the order in which multiple such functions are called is somewhat unpredictable.

A convenience function to read a value, apply a function to it, and write the result.

Processing each item of a set efficiently.

A mutable value that can be changed using change. Internally, type 'a var = 'a t, but it's useful to distinguish between values that are inputs to the system and values that only change in response to computations being rerun.

var x creates a new variable initially set to x.

of_var x casts x to 'a t.

change x v sets the current value of x to v and adds anything that depends on it to the rebuild queue. You must call propagate after this to update everything (you can change several things together and then call propagate once). This function can only be used from the top-level, not from within a computation.

Apply all changes made with change, so that everything is up-to-date.

observe t is the current value of t. If change has been used then the value may be stale until propagate is called.