# Lazy.3o man page

Lazy — Deferred computations.

## Module

Module Lazy

## Documentation

Module **Lazy**

: **sig end**

Deferred computations.

*type* **'a** *t* = **'a lazy_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 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.

*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**

**force_val x** forces the suspension **x** and returns its result. If **x** has already been forced, **force_val x** returns the same value again without recomputing it. Raise **Undefined** if the forcing of **x** tries to force **x** itself recursively. 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.

**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** .

**Since** 4.00.0

*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)** .

**Since** 4.00.0

*val is_val* : **'a t -> bool**

**is_val x** returns **true** if **x** 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** .