A delayed computation that can produce a deferred.

Nothing happens with a lazy deferred unless one `force`s 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. There is no way in standard OCaml to hook an asynchronous computation to be triggered when a lazy value gets computed. This functionality is offered by this module (see `wait`). Plus, dealing with an exception raised by the closures provided is slightly easier when done consistently through this API.

There is no `val of_lazy : 'a Deferred.t Lazy.t -> 'a t` because of the difference in power.

`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))`.

`module Monad_infix : Base__.Monad_intf.Infix with type a t := a t`
`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 `Pervasives.ignore`. Some monads still do `let ignore = ignore_m` for historical reasons.

`val all : 'a t list ‑> 'a list t`
`val all_unit : unit t list ‑> unit t`
`val all_ignore : unit t list ‑> unit t`

- Deprecated [since 2018-02] Use [all_unit]

`include Base__.Monad_intf.Syntax with type a t := a t`
`type 'a t`````
`module Let_syntax : sig ... end`
`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`.

Read-only operations.

`val peek : 'a t ‑> 'a Core_kernel.Or_error.t option`

`peek t = Deferred.peek (wait t)`

`val peek_exn : 'a t ‑> 'a option`
`val is_determined : _ t ‑> bool`
`val is_forced : _ t ‑> bool`