include Stdlib.Lazy
type 'a t = 'a CamlinternalLazy.t
A value of type
'a Lazy.t
is a deferred computation, called a suspension, that has a result of type'a
. The special expression syntaxlazy (expr)
makes a suspension of the computation ofexpr
, without computingexpr
itself yet. "Forcing" the suspension will then computeexpr
and return its result. Matching a suspension with the special pattern syntaxlazy(pattern)
also computes the underlying expression and tries to bind it topattern
:let lazy_option_map f x = match x with | lazy (Some x) -> Some (Lazy.force f x) | _ -> None
Note: If lazy patterns appear in multiple cases in a pattern-matching, lazy expressions may be forced even outside of the case ultimately selected by the pattern matching. In the example above, the suspension
x
is always computed.Note:
lazy_t
is the built-in type constructor used by the compiler for thelazy
keyword. You should not use it directly. Always useLazy.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 formlet rec x = lazy x
orlet 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.
val force : 'a t -> 'a
force x
forces the suspensionx
and returns its result. Ifx
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. RaiseUndefined
if the forcing ofx
tries to forcex
itself recursively.
val force_val : 'a t -> 'a
force_val x
forces the suspensionx
and returns its result. Ifx
has already been forced,force_val x
returns the same value again without recomputing it. RaiseUndefined
if the forcing ofx
tries to forcex
itself recursively. If the computation ofx
raises an exception, it is unspecified whetherforce_val x
raises the same exception orUndefined
.
val from_fun : (unit -> 'a) -> 'a t
from_fun f
is the same aslazy (f ())
but slightly more efficient.from_fun
should only be used if the functionf
is already defined. In particular it is always less efficient to writefrom_fun (fun () -> expr)
thanlazy expr
.- since
- 4.00.0
val from_val : 'a -> 'a t
from_val v
returns an already-forced suspension ofv
. This is for special purposes only and should not be confused withlazy (v)
.- since
- 4.00.0
val is_val : 'a t -> bool
is_val x
returnstrue
ifx
has already been forced and did not raise an exception.- since
- 4.00.0
val lazy_from_fun : (unit -> 'a) -> 'a t
- deprecated
synonym for
from_fun
.
val lazy_from_val : 'a -> 'a t
- deprecated
synonym for
from_val
.
val lazy_is_val : 'a t -> bool
- deprecated
synonym for
is_val
.
val t_of_sexp : (Sexplib0.Sexp.t -> 'a) -> Sexplib0.Sexp.t -> 'a lazy_t
val sexp_of_t : ('a -> Sexplib0.Sexp.t) -> 'a lazy_t -> Sexplib0.Sexp.t
val t_sexp_grammar : Sexplib0__Sexp.Private.Raw_grammar.t