module Lazy_deferred: Lazy_deferred
type 'a t
val create : (unit -> 'a Deferred.t) -> 'a t
create f creates a new lazy deferred that will call f when it is forced.
val force : 'a t -> ('a, exn) Core.Std.Result.t Deferred.t
force t forces evaluation of t and returns a deferred that becomes determined
when the deferred computation becomes determined or raises.
val force_exn : 'a t -> 'a Deferred.t
val wait : 'a t -> ('a, exn) Core.Std.Result.t Deferred.t
wait t waits for t to be forced. If no one ever calls force t, wait will wait
forever.
val wait_exn : 'a t -> 'a Deferred.t
include Monad
bind t f in the lazy-deferred monad creates a computation that, when forced, will
force t, apply f to the result, and then force the result of that.
val bind' : 'a t -> ('a -> 'b Deferred.t) -> 'b t
bind' differs from bind in that the supplied function produces an 'a Deferred.t
rather than an 'a t.
val follow : 'a t -> ('a -> 'b Deferred.t) -> 'b t
follow t f returns a new lazy deferred almost like bind' with the notable
difference that its computation will start as soon as the deferred it is following
becomes determined. Since the resulting deferred depends on the 'a value computed
by t forcing the resulting of follow will force the compuation of t.
Read-only operations.
val peek : 'a t -> ('a, exn) Core.Std.Result.t option
peek t = Deferred.peek (wait t)
val peek_exn : 'a t -> 'a option
val is_determined : 'a t -> bool
val is_forced : 'a t -> bool