Up
# Module Lazy_deferred

### Signature

##
include Core_kernel.Std.Monad with type
'a
t :=
'a
t

##
include Monad_intf.S_without_syntax with type
'a
t :=
'a
t

##
include Monad_intf.Infix with type
'a
t :=
'a
t

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 to hook an asynchronous computation to a lazy value in OCaml to be triggered
when the lazy gets computed. This functionality is indeed offered by this module
(see `wait`

). Plus, dealing with 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.

`force t`

forces evaluation of `t`

and returns a deferred that becomes determined
when the deferred computation becomes determined or raises.

`wait t`

and `wait_exn t`

waits for `t`

to be forced. If no one ever calls
`force t`

, they will wait forever.

type
'a
t

A monad is an abstraction of the concept of sequencing of computations. A value of type 'a monad represents a computation that returns a value of type 'a.

val
return : 'a -> 'a t

`return v`

returns the (trivial) computation that returns v.

`bind'`

differs from `bind`

in that the supplied function produces an `'a Deferred.t`

rather than an `'a t`

.

Read-only operations.

val
peek_exn : 'a t -> 'a option

val
is_determined : _ t -> bool

val
is_forced : _ t -> bool