Note that the choice comes from the congruence rules
relative to application. When we have a term (\x.M) N, we can choose to
evaluate N first, or to make the beta-reduction first.
There are two main strategies, depending on this choice:
It can be shown that the lazy strategy is complete, i.e. it covers all the
possible reductions of the Lambda Calculus, while the eager strategy
is not complete. On the other hand, the eager strategy is (usually) more
efficient, although not always. In fact, if x occurs several times in M, then
in call-by-value we evaluate N only once, while in call-by-value (in principle)
we would evaluate N several times.
However, there are implementations which use a pointer to N, instead of N itself;
in these implementations N will be evaluated at most once, and the performance is better.
(The use of pointers however is rather tricky with higher-order.)
- Call-by-value, or eager strategy, which always evaluates
the argument N first,
- Call-by-name, or lazy strategy, which first makes the substitution
(beta-reduction), and evaluates the arguments N only if necessary
(i.e. if it is necessary for the evaluation of M[N/x]).
Other issues of relevance here are: