An observer lets one get the value of an incremental, either by asking directly for the value or installing an on-update handler to run when the incremental's value changes.
One first creates an observer using
observe. One must then call
stabilize before making any observations on that observer.
let o = observe t causes subsequent calls to
stabilize to maintain the value of
t, until either:
disallow_future_use ois called, or
ois garbage collected and
ohas no on-update handlers.
val sexp_of_t : ('a -> Ppx_sexp_conv_lib.Sexp.t) -> 'a t -> Ppx_sexp_conv_lib.Sexp.t
include Core_kernel.Invariant.S1 with type 'a t := 'a t
val invariant : ('a -> unit) -> 'a t -> unit
val observing : 'a t -> 'a incremental
val use_is_allowed : _ t -> bool
val value : 'a t -> 'a Core_kernel.Or_error.t
value t returns the current value of
t does not currently have a stable value. In particular,
value t will return
Error in the following situations:
- in the middle of stabilization.
stabilizehas not been called since
disallow_future_use thas been called.
observing tis invalid.
Rather than using
value in a function that runs during stabilization, one should use
bind to express the dependence of an incremental computation on an incremental.
val value_exn : 'a t -> 'a
module Update : sig ... end
on_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
val disallow_future_use : _ t -> unit
disallow_future_use t causes all future attempts to use
t to fail and
on_update_exn handlers added to
t to never run again. It also causes incremental to treat
t as unobserved, and thus
stabilize will not maintain the value of
t or any of
t's descendants that are needed only to maintain
disallow_future_use raises if called during stabilization.