incremental
Library
Module
Module type
Parameter
Class
Class type
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
, 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 sincet
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. 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
:
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.