# Module `Base__.Lazy`

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

`val hash_fold_t : (Base.Hash.state -> 'a -> Base.Hash.state) -> Base.Hash.state -> 'a t -> Base.Hash.state`

`include Base.Sexpable.S1 with type 'a t := 'a t`

`val t_of_sexp : (Base.Sexp.t -> 'a) -> Base.Sexp.t -> 'a t`

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

`include Base.Monad.S with type 'a t := 'a t`

`include Base__.Monad_intf.S_without_syntax with type 'a t := 'a t`

`module Monad_infix : Base__.Monad_intf.Infix with type 'a t := 'a t`

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

`return v`

returns the (trivial) computation that returns v.

`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`force_val x`

does not use an exception handler, so it may be more efficient. However, 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 if`f`

is a variable.`from_fun`

should only be used if the function`f`

is already defined. In particular it is always less efficient to write`from_fun (fun () -> expr)`

than`lazy expr`

.

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

`from_val v`

returns an already-forced suspension of`v`

(where`v`

can be any expression). Essentially,`from_val expr`

is the same as`let var = expr in lazy var`

.

`val is_val : 'a t -> bool`

`is_val x`

returns`true`

if`x`

has already been forced and did not raise an exception.

`module T_unforcing : sig ... end`

This type offers a serialization function

`sexp_of_t`

that won't force its argument. Instead, it will serialize the`'a`

if it is available, or just use a custom string indicating it is not forced. Note that this is not a round-trippable type, thus the type does not expose`of_sexp`

. To be used in debug code, while tracking a Heisenbug, etc.