Write You a Haskell Stephen Diehl

1. Evaluate f to λy.e
2. Evaluate [y/x]e
Call-by-need:
1. Allocate a thunk v for x
2. Evaluate f to λy.e
3. Evaluate [y/v]e
Terms that have a normal form in one model, may or may not have a normal form in another. In callby-need
and call-by-name evaluation diverging terms are not necessarily evaluated before entry, so some
terms that have a normal form in these models may diverge under call-by-value.
Call-by-value
Call by value is an extremely common evaluation model. Many programming languages both imperative
and functional use this evaluation strategy. e essence of call-by-value is that there are two categories of
expressions: terms and values. Values are lambda expressions and other terms which are in normal form
and cannot be reduced further. All arguments to a function will be reduced to normal form before they
are bound inside the lambda and reduction only proceeds once the arguments are reduced.
For a simple arithmetic expression, the reduction proceeds as follows. Notice how the subexpression (2
+ 2) is evaluated to normal form before being bound.
(\x. \y. y x) (2 + 2) (\x. x + 1)
=> (\x. \y. y x) 4 (\x. x + 1)
=> (\y. y 4) (\x. x + 1)
=> (\x. x + 1) 4
=> 4 + 1
=> 5
Naturally there are two evaluation rules for applications.
e 1 → e ′ 1
e 1 e 2 → e ′ 1 e 2
e 2 → e ′ 2
v 1 e 2 → v 1 e ′ 2
(λx.e)v → [x/v]e
(E-App1)
(E-App2)
(E-AppLam)
For a simple little lambda calculus the call-by-value interpreter is quite simple. Part of the runtime evaluation
of lambda calculus involves the creation of closures, environments which hold the local variables
in scope. In our little language there are two possible values which reduction may converge on, VInt
and VClosure.
69