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. Matching a suspension with the special pattern syntax lazy(pattern)
also computes the underlying expression and tries to bind it to pattern
:
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 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.