A value of type

`'a Lazy.t`

is a deferred computation, called
a suspension, that has a result of type `'a`

. The special
expression syntax `lazy (expr)`

makes a suspension of the
computation of `expr`

, without computing `expr`

itself yet.
"Forcing" the suspension will then compute `expr`

and return its
result.Note: `lazy_t`

is the built-in type constructor used by the compiler
for the `lazy`

keyword. You should not use it directly. Always use
`Lazy.t`

instead.

Note: `Lazy.force`

is not thread-safe. If you use this module in
a multi-threaded program, you will need to add some locks.

Note: if the program is compiled with the `-rectypes`

option,
ill-founded recursive definitions of the form `let rec x = lazy x`

or `let rec x = lazy(lazy(...(lazy x)))`

are accepted by the type-checker
and lead, when forced, to ill-formed values that trigger infinite
loops in the garbage collector and other parts of the run-time system.
Without the `-rectypes`

option, such ill-founded recursive definitions
are rejected by the type-checker.

type`'a`

t =`'a lazy_t`

`val typerep_of_t : ``'a Typerep_kernel.Std.Typerep.t -> 'a t Typerep_kernel.Std.Typerep.t`

`val typename_of_t : ``'a Typerep_kernel.Std.Typename.t -> 'a t Typerep_kernel.Std.Typename.t`

`include ``Monad.S`

with type t := 'a t

`exception Undefined`

`val force : ``'a t -> 'a`

`force x`

forces the suspension `x`

and returns its result.
If `x`

has already been forced, `Lazy.force x`

returns the
same value again without recomputing it. If it raised an exception,
the same exception is raised again.
Raise `Undefined`

if the forcing of `x`

tries to force `x`

itself
recursively.`val force_val : ``'a t -> 'a`

Like

`force`

except that if the computation of `x`

raises an exception, it is
unspecified whether `force_val x`

raises the same exception or `Undefined`

.`val from_fun : ``(unit -> 'a) -> 'a t`

`from_fun f`

is the same as `lazy (f ())`

but slightly more efficient.`val from_val : ``'a -> 'a t`

`from_val v`

returns an already-forced suspension of `v`

This is for special purposes only and should not be confused with
`lazy (v)`

.`val is_val : ``'a t -> bool`

`is_val x`

returns `true`

if `x`

has already been forced and
did not raise an exception.`val t_of_sexp : ``(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t`

`val sexp_of_t : ``('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t`

`val compare : ``('a -> 'a -> int) -> 'a t -> 'a t -> int`

`val bin_t : ``'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t`

`val bin_read_t : ``'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader`

`val __bin_read_t__ : ``'a Bin_prot.Read.reader -> (int -> 'a t) Bin_prot.Read.reader`

`val bin_reader_t : ``'a Bin_prot.Type_class.reader -> 'a t Bin_prot.Type_class.reader`

`val bin_size_t : ``'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer`

`val bin_write_t : ``'a Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer`

`val bin_writer_t : ``'a Bin_prot.Type_class.writer -> 'a t Bin_prot.Type_class.writer`