incremental v0.14.0 · OCaml Package

type ('a, 'w) t

val sexp_of_t : 
  ('a -> Ppx_sexp_conv_lib.Sexp.t) ->
  ('w -> Ppx_sexp_conv_lib.Sexp.t) ->
  ('a, 'w) t ->
  Ppx_sexp_conv_lib.Sexp.t

include Core_kernel.Invariant.S2 with type ('a, 'b) t := ('a, 'b) t

val invariant : ('a -> unit) -> ('b -> unit) -> ('a, 'b) t -> unit

val observing : ('a, 'w) t -> ('a, 'w) 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, 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

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

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

           /-----------------------------------------------------\
           |                 /                                   |
           |                 |                                   v
          Start ------> Initialized ------> Changed ------> Invalidated
                                              ^  |
                                              \--/

on_update_exn raises if disallow_future_use t was previously called.

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.

package incremental