A value of type
'a Lazy.t is a deferred computation, called
a suspension, that has a result of type
'a. The special
lazy (expr) makes a suspension of the
expr, without computing
expr itself yet.
"Forcing" the suspension will then compute
expr and return its
lazy_t is the built-in type constructor used by the compiler
lazy keyword. You should not use it directly. Always use
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
ill-founded recursive definitions of the form
let rec x = lazy x
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.
-rectypes option, such ill-founded recursive definitions
are rejected by the type-checker.
force x forces the suspension
x and returns its result.
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.
Undefined if the forcing of
x tries to force
force except that if the computation of
x raises an exception, it is
force_val x raises the same exception or
from_fun f is the same as
lazy (f ()) but slightly more efficient.
from_val v returns an already-forced suspension of
This is for special purposes only and should not be confused with
is_val x returns
x has already been forced and
did not raise an exception.