Lazy evaluation

In computer programming, and in particular in functional languages, lazy evaluation is also known as non-strict evaluation. An expression, when lazily evaluated, is not evaluated as soon as it gets bound to a variable, but when something forces the evaluator to produce the expression's value. This means that lazy evaluation allows programmers to produce infinite sequences without pushing the evaluator into an endless loop, and other neat things.

The opposite of lazy evaluation is eager evaluation, also known as strict evaluation which is the normal (and often only) evaluation method in most programming languages.

In the Scheme programming language, lazy evaluation (in Scheme jargon, "delayed" evaluation) can be forced by using (define delayed-expression (delay expression)). Then (force delayed-expression) will yield the value of expression.

There are some programming languages where expressions are lazily evaluated by default. Haskell is one such language.

Lazy evaluation as a design pattern

As well as the formal concept of lazy evaluation in functional languages, lazy evaluation is a design pattern often seen in general computer programming.

For example, in modern computer window managers, the painting of information to the screen is driven by "expose events" which drive the display code at the last possible moment. By doing this, they avoid the over-eager computation of unnecessary display content.

Another example of laziness in modern computer systems is copy-on-write[?] page allocation.

See also:

• functional programming
• lambda calculus
• Currying

Compare:

• Lazy initialization