val sexp_of_t :
('a -> Sexplib0.Sexp.t) ->
('w -> Sexplib0.Sexp.t) ->
('a, 'w) t ->
Sexplib0.Sexp.tinclude Core.Invariant.S2 with type ('a, 'b) t := ('a, 'b) tval invariant :
'a Base__.Invariant_intf.inv ->
'b Base__.Invariant_intf.inv ->
('a, 'b) t Base__.Invariant_intf.invval observing : ('a, 'w) t -> ('a, 'w) incrementalval use_is_allowed : (_, _) t -> boolval value : ('a, _) t -> 'a Core.Or_error.tvalue t returns the current value of t, or Error if t does not currently have a stable value. In particular, value t will return Error in the following situations:
stabilize has not been called since t was created.disallow_future_use t has been called.observing t is invalid.Rather than using value in a function that runs during stabilization, one should use map or bind to express the dependence of an incremental computation on an incremental.
val value_exn : ('a, _) t -> 'amodule Update : sig ... endon_update_exn t ~f calls f after the current stabilization and after each subsequent stabilization in which t changes, until disallow_future_use t is called. f will be called at most once per stabilization. Here is a state diagram for the allowable sequences of Update.t's that can be supplied to a particular f:
/-----------------------------------------------------\
| / |
| | v
Start ------> Initialized ------> Changed ------> Invalidated
^ |
\--/on_update_exn raises if disallow_future_use t was previously called.
val disallow_future_use : (_, _) t -> unitAfter disallow_future_use t:
on_update_exn t and value_exn t will raise, and value t will return Error.t's on-update handlers will never run again.stabilize, before recomputing nodes, incremental will mark t as unobserved, and mark as unnecessary all nodes that were necessary only to maintain t.