eager evaluation

Eager evaluation is commonly the default behavior used in programming languages.

This is done essentially using applicative order, call by value reduction (see below), but usually called "eager evaluation".

The opposite of lazy actions is eager evaluation, sometimes known as strict evaluation.

Imperative programming languages, where the order of execution is implicitly defined by the source code organization, almost always use eager evaluation.

In eager evaluation, an expression is evaluated as soon as it is bound to a variable.

Oz uses eager evaluation by default, but lazy evaluation is possible:

The alternative to eager evaluation is lazy evaluation, where expressions are only evaluated when evaluating a dependent expression.

One advantage of eager evaluation is that it eliminates the need to track and schedule the evaluation of expressions.

Unlike Haskell, ML uses eager evaluation, which means that all subexpressions are always evaluated.

For more on expression evaluation, see the computer science topics: eager evaluation, lazy evaluation, and evaluation operator.

In computer programming, eager evaluation or greedy evaluation is the evaluation strategy used by most traditional programming languages.

Alice adopts an eager evaluation model by default, requiring the programmer to explicitly state that a computation is to be evaluated lazily.

The distinction between reduction strategies relates to the distinction in functional programming languages between eager evaluation and lazy evaluation.

Lazy suspensions - this module implements the suspensions necessary for lazy evaluation (as opposed to eager evaluation).

Alice also provides facilities to allow programmers to use a lazy evaluation strategy in their programs versus the traditional eager evaluation strategy that Standard ML takes.

Under Church encoding, eager evaluation of operators maps to strict evaluation of functions; for this reason, strict evaluation is sometimes called "eager".

Strict programming languages are often associated with eager evaluation, and non-strict languages with lazy evaluation, but other evaluation strategies are possible in each case.

Outermost graph reduction is referred to as lazy evaluation and innermost graph reduction is referred to as eager evaluation.

The operational semantics of ISWIM are defined using Landin's SECD machine and use call-by-value, that is eager evaluation.

Q is an impure functional language (i.e., operations with side-effects are permitted) with a default eager evaluation strategy; "special forms" can be used to implement data structures and operations featuring lazy evaluation.

Plotkin also used a Church-Rosser theorem to prove that the evaluation of functional programs (for both lazy evaluation and eager evaluation) is a function from programs to values (a subset of the lambda terms).

A disadvantage of eager evaluation is that it forces the evaluation of expressions that may not be necessary at run time, or it may delay the evaluation of expressions that have a more immediate need.