Lazy Computations (F#)
Lazy computations are computations that are not evaluated immediately, but are instead evaluated when the result is needed. This can help to improve the performance of your code.
let identifier = lazy ( expression )
In the previous syntax, expression is code that is evaluated only when a result is required, and identifier is a value that stores the result. The value is of type Lazy<'T>, where the actual type that is used for
'T is determined from the result of the expression.
Lazy computations enable you to improve performance by restricting the execution of a computation to only those situations in which a result is needed.
To force the computation to be performed, you call the method
Force causes the execution to be performed only one time. Subsequent calls to
Force return the same result, but do not execute any code.
The following code illustrates the use of lazy computation and the use of
Force. In this code, the type of
Lazy<int>, and the
Force method returns an
let x = 10 let result = lazy (x + 10) printfn "%d" (result.Force())
Lazy evaluation, but not the
Lazy type, is also used for sequences. For more information, see Sequences (F#).