package async_kernel

  1. Overview
  2. Docs

Module Laziness_preserving_deferred

Laziness_preserving_deferred offers a monad for working with lazy deferreds that has similar semantics to the Deferred monad. In the regular Lazy_deferred monad, each map/bind introduces a new lazy computation, and nothing runs unless explicitly forced. By contrast, this monad lets you build up a tree of computations that can be "weakly run," meaning that it will run until it encounters an unforced lazy deferred, at which point it will wait for that lazy deferred to be forced before continuing.

type 'a t
include Core.Monad.S with type 'a t := 'a t
val (>>=) : 'a t -> ('a -> 'b t) -> 'b t
val (>>|) : 'a t -> ('a -> 'b) -> 'b t
module Monad_infix : sig ... end
val bind : 'a t -> f:('a -> 'b t) -> 'b t
val return : 'a -> 'a t
val map : 'a t -> f:('a -> 'b) -> 'b t
val join : 'a t t -> 'a t
val ignore_m : 'a t -> unit t
val all : 'a t list -> 'a list t
val all_unit : unit t list -> unit t
module Let_syntax : sig ... end
val of_eager : 'a Async_kernel.Deferred.t -> 'a t
val of_lazy : 'a Async_kernel.Lazy_deferred.t -> 'a t
val force : 'a t -> 'a Async_kernel.Deferred.Or_error.t

Begin computing 'a t, forcing lazy deferreds as they are encountered.

val weak_run : 'a t -> 'a Async_kernel.Deferred.Or_error.t

Begin computing 'a t, waiting on lazy deferreds as they are encountered.