A simple library for incremental computations. Based on "Adaptive Functional Programming" https://www.cs.cmu.edu/~guyb/papers/popl02.pdf
The basic idea is:
- You run a computation, which produces a result.
- The library records information about the dependencies of the result.
- You can then change one or more inputs and it will rerun just the parts of the computation that are needed to update the result.
It is similar to Jane Street's "incremental" library, but much smaller and has no external dependencies.
It is also similar to "react", but the results do not depend on the behaviour of the garbage collector. In particular, functions stop being called as soon as they are no longer needed, and cannot be called with "impossible" inputs.
val const : 'a -> 'a t
const x is the constant value
'a cc is a changeable 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 changeable values, and then updates the destination.
read x f is a computation that depends on
f will be called as necessary to ensure that the result stays up-to-date with changes in
val write : ?eq:('a -> 'a -> bool) -> 'a -> 'a cc
write x is a computation that always returns
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.
These functions are used to interface between the changeable system and other systems (e.g. Lwt).
A mutable value that can be changed using
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.
val var : 'a -> 'a var
var x creates a new variable initially set to
val change : ?eq:('a -> 'a -> bool) -> 'a var -> 'a -> unit
change x v sets the current value of
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.
val observe : 'a t -> 'a
observe t is the current value of
change has been used then the value may be stale until
propagate is called.