Module Async_kernel__.Lazy_deferred A delayed computation that can produce a deferred.
Nothing happens with a lazy deferred unless one forces it. Forcing a lazy deferred starts the computation, which will eventually cause the deferred to become determined. As usual with laziness, multiply forcing a lazy deferred is no different than forcing it a single time.
Exceptions (both synchronous and asynchronous) raised by a delayed computation are returned by force (wait, peek, etc.), or will be raised to the monitor in effect when force_exn (wait_exn, peek_exn, etc.) was called.
The type is not exposed nor defined as 'a Deferred.t Lazy.t or 'a Or_error.t
Deferred.t Lazy.t, because there is a difference in power with these types. Any value of type 'a Deferred.t Lazy.t would mishandle asynchronous exceptions in the computation of 'a. For instance, the following code blocks forever regardless of how v is defined:
let v : Nothing.t Deferred.t Lazy.t = lazy (return "" >>| failwith) in
let%bind _ = try_with (fun () -> force v) in
let%bind _ = try_with (fun () -> force v) inThere is no val of_lazy : 'a Deferred.t Lazy.t -> 'a t because of the difference in power.
See also Deferred.Memo.unit, if you only are interested in create and force.
type 'a t val create : (unit -> 'a Async_kernel.Deferred.t -> 'a t create f creates a new lazy deferred that will call f when it is forced.
val force : 'a t -> 'a Core_kernel.Or_error.t Async_kernel.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 Async_kernel.Deferred.t val wait : 'a t -> 'a Core_kernel.Or_error.t Async_kernel.Deferred.t wait t and wait_exn t waits for t to be forced. If no one ever calls force t, they will wait forever.
val wait_exn : 'a t -> 'a Async_kernel.Deferred.t 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.
include Core_kernel.Monad with type 'a t := 'a t type 'a t include Base__.Monad_intf.S_without_syntax with type 'a t := 'a t type 'a t include Base__.Monad_intf.Infix with type 'a t := 'a t type 'a t val (>>=) : 'a t -> ('a -> 'b t -> 'b t t >>= f returns a computation that sequences the computations represented by two monad elements. The resulting computation first does t to yield a value v, and then runs the computation returned by f v.
val (>>|) : 'a t -> ('a -> 'b ) -> 'b t t >>| f is t >>= (fun a -> return (f a)).
val bind : 'a t -> f:('a -> 'b t -> 'b t bind t ~f = t >>= f
val return : 'a -> 'a t return v returns the (trivial) computation that returns v.
val map : 'a t -> f:('a -> 'b ) -> 'b t map t ~f is t >>| f.
val join : 'a t t -> 'a t join t is t >>= (fun t' -> t').
val ignore_m : 'a t -> unit t ignore_m t is map t ~f:(fun _ -> ()). ignore_m used to be called ignore, but we decided that was a bad name, because it shadowed the widely used Caml.ignore. Some monads still do let ignore = ignore_m for historical reasons.
val all : 'a t -> 'a listt val all_unit : unit t list-> unit t Like all, but ensures that every monadic value in the list produces a unit value, all of which are discarded rather than being collected into a list.
val bind' : 'a t -> ('a -> 'b Async_kernel.Deferred.t -> 'b t bind' differs from bind in that the supplied function produces an 'a Deferred.t rather than an 'a t.
val peek : 'a t -> 'a Core_kernel.Or_error.t peek t = Deferred.peek (wait t)
val peek_exn : 'a t -> 'a optionval is_determined : _ t -> boolval is_forced : _ t -> bool