Module Observer

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.

Doing let o = observe t causes subsequent calls to stabilize to maintain the value of t, until either:

disallow_future_use o is called, or
o is garbage collected and o has no on-update handlers.

Signature

type 'a t

val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t

include Core_kernel.Std.Invariant.S1 with type 'a t := 'a t

type 'a t

val invariant : 'a Invariant_intf.inv -> 'a t Invariant_intf.inv

val observing : 'a t -> 'a incremental

val use_is_allowed : _ t -> bool

val value : 'a t -> 'a Core_kernel.Std.Or_error.t

value 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:

in the middle of stabilization.
if stabilize has not been called since t was created.
if disallow_future_use t has been called.
if 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 -> '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.

val on_update_exn : 'a t -> f:('a Update.t -> unit) -> unit

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 t. disallow_future_use raises if called during stabilization.