The Lambda Calculus - Yale Universityin the pure lambda calculus: an abstraction. A typical...

33
The Lambda Calculus The Greatest Thing Since Sliced Bread TM , or maybe even before it The basis of functional languages (ML, Haskell, L ISP, Algol 60. . . ) Close connection with logic: Developed by logicians Church, Rosser, Curry since 1930s Intended as a formal proof notation allowing proof transformation Easier to reason about than procedural imperative languages: has no assignment operation and needs no state in its semantics all computation is expressed as applications of abstractions

Transcript of The Lambda Calculus - Yale Universityin the pure lambda calculus: an abstraction. A typical...

Page 1: The Lambda Calculus - Yale Universityin the pure lambda calculus: an abstraction. A typical functional programming language allows functions to only be applied but not inspected, so

The Lambda Calculus

The Greatest Thing Since Sliced BreadTM, or maybe even before it

The basis of functional languages (ML, Haskell, LISP, Algol 60. . . )

Close connection with logic:

Developed by logicians Church, Rosser, Curry since 1930s

Intended as a formal proof notation

allowing proof transformation

Easier to reason about than procedural imperative languages:

has no assignment operation and needs no state in its semantics —

all computation is expressed as applications of abstractions

Page 2: The Lambda Calculus - Yale Universityin the pure lambda calculus: an abstraction. A typical functional programming language allows functions to only be applied but not inspected, so

The Pure Untyped Lambda Calculus

Syntax:

exp ::= var variable

| λvar . exp abstraction (lambda expression)

| exp exp applicationConventions:

the body e of the abstraction λv. e extends as far as the syntax allows

— to a closing parenthesis or end of term

application is left associative

λx. (λy. x y y)λx. λz. x z ≡ λx. ((λy. ((x y) y))(λx. (λz. (x z))))

Page 3: The Lambda Calculus - Yale Universityin the pure lambda calculus: an abstraction. A typical functional programming language allows functions to only be applied but not inspected, so

Syntactic Properties

λv. e binds v in e, so we define the free variables of a lambda term by

FV (v) = vFV (e e′) = FV (e) ∪ FV (e′)

FV (λv. e) = FV (e)− v

and substitution as

v/δ = δ v

(e e′)/δ = (e/δ) (e′/δ)

(λv. e)/δ = λvnew. (e/[δ | v : vnew])

where vnew /∈⋃

w∈FV (e)−vFV (δ w)

Page 4: The Lambda Calculus - Yale Universityin the pure lambda calculus: an abstraction. A typical functional programming language allows functions to only be applied but not inspected, so

Renaming of bound variables

Renaming of bound variables:

Replacing λv. e with λv′. (e/v → v′) where v′ /∈ FV (e)− v.

e′ is α-equivalent to e (e ≡ e′)

if it is obtained from e by renaming of bound variables of subterms.

The semantics of lambda calculus identifies all α-equivalent terms.

Page 5: The Lambda Calculus - Yale Universityin the pure lambda calculus: an abstraction. A typical functional programming language allows functions to only be applied but not inspected, so

Reduction

The first semantics of the lambda calculus was operational,

based on a notion of reduction on terms.

Configurations are lambda terms: Γ = exp.

The single step relation 7→ is not a function:

reduction is nondeterministic

but a terminal configuration, if it exists, is unique.

The central rule is for β-reduction (β-contraction):

(λv. e) e′ 7→ e/v → e′

(λv. e) e′ is the redex and e/v → e′ is its contractum.

Page 6: The Lambda Calculus - Yale Universityin the pure lambda calculus: an abstraction. A typical functional programming language allows functions to only be applied but not inspected, so

Contextual Rules for Reduction

e 7→ e′

λv. e 7→ λv. e′e ≡ e′e 7→∗ e′

e0 7→ e′0e0 e1 7→ e′0 e1

e 7→ e′

e 7→∗ e′

e1 7→ e′1e0 e1 7→ e0 e

′1

e0 7→∗ e1 e1 7→∗ e2e0 7→∗ e2

e0 7→ e′0 e′0 ≡ e′1e0 7→ e′1

An expression containing no redexes is a (or in) normal form;

normal forms correspond to terminal configurations.

An expression e has a normal form

if ∃e′ ∈ exp. e 7→∗ e′ and e′ is a normal form.

Page 7: The Lambda Calculus - Yale Universityin the pure lambda calculus: an abstraction. A typical functional programming language allows functions to only be applied but not inspected, so

Confluence: The Church-Rosser Theorem

The single-step reduction is nondeterministic,but determinism is eventually recovered in the interesting cases:

Theorem [Church-Rosser]:For all e, e0, e1 ∈ exp,if e 7→∗ e0 and e 7→∗ e1, then there exists e′ ∈ exp such that e0 7→∗ e′ and e1 7→∗ e′.

Corollary:Every expression has at most one normal from (up to α-equivalence).

Proof:If e 7→∗ e0 and e 7→∗ e1 and both e0 and e1 are normal forms,

then by Church-Rosser there is some e′ such that e0 7→∗ e′ and e1 7→∗ e′.But neither e0 nor e1 have redexes,

so the only rule that can be applied to them is that of α-equivalence.

Page 8: The Lambda Calculus - Yale Universityin the pure lambda calculus: an abstraction. A typical functional programming language allows functions to only be applied but not inspected, so

Examples of Reduction

(λx. x) (λy. y y) 7→ λy. y y Idef= λx. x is the identity combinator

(combinator = closed term)

(λx. λy. x) z (λx. x) 7→ (λy. z) (λx. x) 7→ z Kdef= λx. λy. x is the constant combinator

(λx. x x) (λy. y) 7→ (λy. y) (λy. y) 7→ λy. y ∆def= λx. x x is the self-application comb.

(λx. (λy. x) (x x)) (λy. y)+

uukkkkkkkkkkkkkkkk

++WWWWWWWWWWWWWWWWWWWWWWW

(λx. x) (λy. y)

##GGGGGGGGGGGGGGGGGGGGGGGGGGGG(λy. λy. y) ((λy. y) (λy. y))0

wwpppppppppppppppppppppppppppppppppppp

**UUUUUUUUUUUUUUUUUUU

(λy. λy. y) (λy. y)$

qqddddddddddddddddddddddddddddddddddddddddddddddddddddddd

λy. y

Page 9: The Lambda Calculus - Yale Universityin the pure lambda calculus: an abstraction. A typical functional programming language allows functions to only be applied but not inspected, so

Normal-Order Reduction

∆ ∆ ≡ (λx. x x) ∆ 7→∆ ∆ 7→ . . . Ωdef= ∆ ∆ is a diverging expression

K z Ω 7→ K z Ω 7→ . . . , (where K = λx. λy. x), but also

K z Ω 7→ (λy. z) Ω 7→ z

An outermost redex is one not contained in any other redex.

In the normal-order reduction sequence of a termat each step the contracted redex is the leftmost outermost one.

Theorem [Standardization]:If e has a normal form,

then the normal-order reduction sequence starting with e terminates.

Page 10: The Lambda Calculus - Yale Universityin the pure lambda calculus: an abstraction. A typical functional programming language allows functions to only be applied but not inspected, so

Normal-Order Reduction

K z Ω 7→ (λy. z) Ω 7→ z K z Ω 7→ K z Ω 7→ . . .

app

mmmmmmmmmmmmmm

mmmmmmmmmmmmmm

VVVVVVVVVVVVVVVVVVVVVVV

VVVVVVVVVVVVVVVVVVVVVVV

app

qqqqqqqqqq

qqqqqqqqqq

BBBBBBBBB

BBBBBBBBBapp

ssssssssss

ssssssssss

KKKKKKKKKK

KKKKKKKKKK

λx. λy. x z λx. x x λx. x x

An outermost redex is one not contained in any other redex.

In the normal-order reduction sequence of a termat each step the contracted redex is the leftmost outermost one.

(λy. y y ((λx. x x) ∆))K 7→ KK

Theorem [Standardization]:If e has a normal form,

then the normal-order reduction sequence starting with e terminates.

Page 11: The Lambda Calculus - Yale Universityin the pure lambda calculus: an abstraction. A typical functional programming language allows functions to only be applied but not inspected, so

η-Reduction

For every e ∈ exp,the terms e and λv. e v (where v /∈ FV (e)) are extensionally equivalent— they reduce to the same term when applied to any other term e′:

(λv. e v) e′ 7→ e e′

Hence the η-reduction rule:

λv. e v 7→ e when v /∈ FV (e)

The Church-Rosser and Standardization properties hold for the βη-reduction(the union of β- and η-reduction).

Page 12: The Lambda Calculus - Yale Universityin the pure lambda calculus: an abstraction. A typical functional programming language allows functions to only be applied but not inspected, so

Programming in the Lambda Calculus

Idea: Encode data as combinators in normal-form— then uniqueness of normal form then guarantees we can decode a valid result.

Example: Church numerals (note that NUM n is in normal form for every n ∈ N)

NUM ndef= λf. λx. Pn

where P0 = xPn+1 = f Pn

i.e. Pn = f (. . . (f︸ ︷︷ ︸ x) . . .)

n times

SUCCdef= λn. λf. λx. f (n f x)

SUCC NUM n = (λn. λf. λx. f (n f x)) (λf. λx. Pn)7→ λf. λx. f ((λf. λx. Pn) f x)7→ λf. λx. f ((λx. Pn) x)7→ λf. λx. f Pn7→ λf. λx. Pn+1= NUM n+1

Page 13: The Lambda Calculus - Yale Universityin the pure lambda calculus: an abstraction. A typical functional programming language allows functions to only be applied but not inspected, so

Programming with Church Numerals

In Haskell one could implement addition and multiplication using recursion:

data Num = Zero | Succ Num

add Zero n = n

add (Succ m) n = Succ (add m n)

mul Zero n = Zero

mul (Succ m) n = add n (mul m n)

Recursion can also be encoded in lambda calculus,but one can avoid recursion and use Church numerals as iterators:

ADDdef= λm. λn. λf. λx.m f (n f x) ADD NUMmNUM n 7→∗ NUMm+n

MULdef= λm. λn. λf.m (n f) MUL NUMmNUM n 7→∗ NUMmn

EXPdef= λm. λn. n m EXP NUMmNUM n 7→∗ NUMmn

Page 14: The Lambda Calculus - Yale Universityin the pure lambda calculus: an abstraction. A typical functional programming language allows functions to only be applied but not inspected, so

Addition of Church Numerals

ADDdef= λm. λn. λf. λx.m f (n f x)

ADD NUMmNUM n 7→2 λf. λx.NUMm f (NUM n f x)7→2 λf. λx.NUMm f Pn7→2 λf. λx. (Pm/x→ Pn)= λf. λx. f (. . . (f︸ ︷︷ ︸ Pn) . . .)

m times= λf. λx. f (. . . (f︸ ︷︷ ︸ (f (. . . (f︸ ︷︷ ︸ x) . . .))) . . .)

m times n times= λf. λx. Pm+n= NUMm+n

Page 15: The Lambda Calculus - Yale Universityin the pure lambda calculus: an abstraction. A typical functional programming language allows functions to only be applied but not inspected, so

Normal-Order Evaluation

Canonical form: a term with no “top-level” redexes;in the pure lambda calculus: an abstraction.

A typical functional programming language allows functionsto only be applied but not inspected,so once a result is known to be a function, it is not reduced further.

Evaluation: reduction of closed expressions.

A typical programming language defines programs as closed terms.If e is closed, e⇒ z (e evaluates to z) when z is the first canonical form

in the normal-order reduction sequence of e.

Even if the normal-order reduction sequence is infinite,it may contain a canonical form;

however other reduction sequences may contain other canonical forms.

Page 16: The Lambda Calculus - Yale Universityin the pure lambda calculus: an abstraction. A typical functional programming language allows functions to only be applied but not inspected, so

Reduction of Closed Terms

A closed term e either diverges or reduces to a canonical form.

Proof:Reduction does not introduce free variables, hence every term of the sequence is closed.

If the sequence is finite, it ends with a normal form which can only be an abstraction:

By induction, a closed normal form can only be an abstraction:

A variable v is a normal form but not a closed term;

An application e1 e2 can be a normal form only if e1 is a normal form;

but then by IH e1, being a closed normal form, may only be an abstraction;

then e1 e2 is a redex,

hence is not a normal form, contradicting the assumption.

Page 17: The Lambda Calculus - Yale Universityin the pure lambda calculus: an abstraction. A typical functional programming language allows functions to only be applied but not inspected, so

Big-Step (Natural) Semantics for Normal-Order Evaluation

Inference rules for evaluation:

(termination)` λv. e⇒ λv. e

(β-evaluation)` e⇒ λv. e1 ` (e1/v → e′)⇒ z

` e e′ ⇒ z

Proposition:If e is a closed term and z is a canonical form, e⇒ z if and only if ` e⇒ z is provable.

Hence the recursive algorithm for normal-order evaluation of a closed e is:

if e is an abstraction, it evaluates to e;

otherwise e = e1 e2; first evaluate e1 to its canonical form, an abstraction λv. e′1,then the value of e is that of e′1/v → e2.

Page 18: The Lambda Calculus - Yale Universityin the pure lambda calculus: an abstraction. A typical functional programming language allows functions to only be applied but not inspected, so

Examples of Normal-Order Evaluation

Expression diverging under βη-reduction may have canonical forms:

K Ω = (λx. λy. x) Ω 7→ λy.Ω

hence K Ω⇒ λy.Ω, although (K Ω) diverges under βη-reduction.

Expressions with the same βη-normal form may have different canonical formsunder normal order evaluation:

(λx. λy. x) ∆ 7→∗ λy.∆ (λx. λy. x) ∆⇒ λy.∆

λx. (λy. y) ∆ 7→∗ λx.∆ but λx. (λy. y) ∆⇒ λx. (λy. y) ∆

Sometimes normal order evaluation performs more work(i.e. needs more steps to get to the same term)than other reduction orders:

normal order: ∆ (I I) 7→ (I I) (I I) 7→ I (I I) 7→ I I 7→ Ianother (eager) strategy: ∆ (I I) 7→∆ I 7→ I I 7→ I

Page 19: The Lambda Calculus - Yale Universityin the pure lambda calculus: an abstraction. A typical functional programming language allows functions to only be applied but not inspected, so

Eager Evaluation

Sometimes normal order evaluation performs more work than other reduction orders:

normal order: ∆ (I I) 7→ (I I) (I I) 7→ I (I I) 7→ I I 7→ Ianother strategy: ∆ (I I) 7→∆ I 7→ I I 7→ I

Reason: When reducing (λv. e) e′ 7→ e/v → e′,redexes in e′ are replicated in e/v → e′ if v occurs more than once in e.

Solution: Use eager evaluation order:First evaluate the argument e′ to canonical form.

βE-reduction rule:

(λv. e) z 7→ (e/v → z) if z is a canonical form or a variable

e⇒E z (e evaluates eagerly to z)if there is a reduction sequence from e to zof contractions of the leftmost βE-redexes not inside a canonical form.

Page 20: The Lambda Calculus - Yale Universityin the pure lambda calculus: an abstraction. A typical functional programming language allows functions to only be applied but not inspected, so

Inference Rules for Eager Evaluation

(termination)` λv. e⇒E λv. e

(βE-evaluation)` e1 ⇒E λv. e′1 ` e2 ⇒E z2 ` (e′1/v → z2)⇒E z

` e1 e2 ⇒E z

This is the strategy used by most implementations of “strict” languages.

Recursive algorithm for eager evaluation of a closed e:

if e is an abstraction, it evaluates to e;

otherwise e = e1 e2:first evaluate e1 to its canonical form, an abstraction λv. e′1,then evaluate e2 to a canonical form z2,then the value of e is that of e′1/v → z2.

Eager evaluation performs more work than normal-order evaluationwhen the parameter does not occur in the abstraction body:

(λx. I) Ω 6⇒E but (λx. I) Ω⇒ I

Page 21: The Lambda Calculus - Yale Universityin the pure lambda calculus: an abstraction. A typical functional programming language allows functions to only be applied but not inspected, so

Denotational Semantics of the Lambda Calculus

We need a set S of denotations and a meaning function [[−]] such that [[−]] ∈ exp → S,and a lambda calculus application is interpreted as a function application:

[[e e′]] = [[e]] [[e′]]

So the set S must contain functions from S to S.

If S contains all functions from S to S, the problem has no non-trivial solutions due toRussell’s paradox:

If S → S ⊆ S, we can construct a fixed point of every function f ∈ S → S:

Let p = λx ∈ S.f (xx), if x ∈ S → Sx (or anything else in S), otherwise.

Then p p = f(p p) is a fixed point of f .The lambda term that manifests this construction is a fixed-point combinator Y :

Ydef= λf. (λx. f (x x))λx. f (x x)

Y e 7→ (λx. e (x x))λx. e (x x) 7→ e ((λx. e (x x))λx. e (x x))

But if S has more than one element, not all functions in S → S have fixed points,e.g. not ∈ B→ B: no element b ∈ B satisfies b = not b.

Page 22: The Lambda Calculus - Yale Universityin the pure lambda calculus: an abstraction. A typical functional programming language allows functions to only be applied but not inspected, so

Scott’s Recursive Domain Isomorphism for the LambdaCalculus

Dana Scott solved the problem by considering a domain of valuesand requiring the functions in it to be continuous.

Scott’s Domain D∞ satisfies the isomorphism

D∞φ−→←−ψ

[D∞ → D∞]

Then the meaning of a lambda calculus term can be given by a function

[[−]] ∈ exp → [Env → D∞]

where Envdef= var→D∞ is the set of environments assigning values to free variables.

Page 23: The Lambda Calculus - Yale Universityin the pure lambda calculus: an abstraction. A typical functional programming language allows functions to only be applied but not inspected, so

Semantic Equations

D∞φ−→←−ψ

[D∞ → D∞]

[[−]] ∈ exp → [(var → D∞)→ D∞]

[[v]] η = η v

[[λv. e]] η = ψ (λx ∈ D∞. [[e]][η | v : x])

[[e e′]] η = φ ([[e]] η) ([[e′]] η)

We have to prove that all terms in this definition are in the required domains:

λx ∈ D∞. [[e]][η | v : x] is a continuous function from D∞ to D∞

the so-defined [[−]] is a continuous function from Env to D∞.

Page 24: The Lambda Calculus - Yale Universityin the pure lambda calculus: an abstraction. A typical functional programming language allows functions to only be applied but not inspected, so

Correctness of the Semantic Equations

Using the continuous (for any predomains P, P ′, P ′′) functions

getP,v η = η v getP,v ∈ [(var → P )→ P ]

extP,v 〈η, x〉 = [η | v : x] extP,v ∈ [(var → P )× P → var → P ]

apP,P ′ 〈f, x〉 = f x apP,P ′ ∈ [(P → P ′)× P → P ′]

((abP,P ′,P ′′ f)x) y = f 〈x, y〉 abP,P ′,P ′′ ∈ [P × P ′ → P ′′]→ [P → [P ′ → P ′′]]

rewrite the semantic equations:

[[v]] =λη ∈ Env . η v = getD∞,v

[[λv. e]] =λη ∈ Env . ψ (λx ∈ D∞. [[e]][η | v : x]) =ψ · abEnv ,D∞,D∞ ([[e]] · extD∞,v)

[[e e′]] =λη ∈ Env . φ ([[e]] η) ([[e′]] η) = apD∞,D∞ · ((φ · [[e]])⊗ [[e′]])

Well-formedness and continuity of [[−]] follows from continuity of · and ⊗.

Page 25: The Lambda Calculus - Yale Universityin the pure lambda calculus: an abstraction. A typical functional programming language allows functions to only be applied but not inspected, so

Properties of the Denotational Semantics

Coincidence: If ∀v ∈ FV (e). η v = η′ v, then [[e]] η = [[e]] η′.

Substitution: If ∀v ∈ FV (e). [[δv]] η′ = η v, then [[e/δ]] η′ = [[e]] η.

Finite Substitution:[[e/v1 → e1, . . . vn → en]] η = [[e]] [η | v1 : [[e1]] η | . . . | vn : [[en]] η].

Renaming Preserves Meaning: (i.e. α-equivalence is sound w.r.t. the semantics)If w /∈ FV (e)− v, then [[λw. (e/v → w)]] = [[λv. e]].

Soundness of β-contraction: [[(λv. e) e′]] = [[e/v → e′]](from φ · ψ = I[D∞→D∞])

Soundness of η-contraction: If v /∈ FV (e), then [[λv. e v]] = [[e]]

(from ψ · φ = ID∞)

Page 26: The Lambda Calculus - Yale Universityin the pure lambda calculus: an abstraction. A typical functional programming language allows functions to only be applied but not inspected, so

Soundness of β-Contraction

For any η ∈ Env ,

[[(λv. e) e′]] η=φ ([[λv. e]] η) ([[e′]] η) semantics of application

=φ (ψ (λx ∈ D∞. [[e]] [η | v : x])) ([[e′]] η) semantics of abstraction

= (λx ∈ D∞. [[e]] [η | v : x]) ([[e′]] η) half of the isomorphism

= [[e]] [η | v : [[e′]] η]

= [[e/v → e′]] η finite substitution

Page 27: The Lambda Calculus - Yale Universityin the pure lambda calculus: an abstraction. A typical functional programming language allows functions to only be applied but not inspected, so

Soundness of η-Contraction

For any η ∈ Env ,

[[λv. e v]] η=ψ (λx ∈ D∞. [[e v]] [η | v : x]) semantics of abstraction

=ψ (λx ∈ D∞. φ ([[e]] [η | v : x]) ([[v]] [η | v : x])) semantics of application

=ψ (λx ∈ D∞. φ ([[e]] η) ([[v]] [η | v : x])) coincidence

=ψ (λx ∈ D∞. φ ([[e]] η)x) semantics of a variable

=ψ (φ ([[e]] η))

= [[e]] η half of the isomorphism

Page 28: The Lambda Calculus - Yale Universityin the pure lambda calculus: an abstraction. A typical functional programming language allows functions to only be applied but not inspected, so

The Least Fixed-Point Combinator

The fixed-point combinator

Y = λf. (λx. f (x x))λx. f (x x)

denotes (up to isomorphism)

the least fixed-point operator on the Scott’s Domain D∞:

[[Y ]]η = ψ (YD∞ · φ)

Page 29: The Lambda Calculus - Yale Universityin the pure lambda calculus: an abstraction. A typical functional programming language allows functions to only be applied but not inspected, so

Semantics of Normal-Order Evaluation

In the given semantics [[λx.Ω]] = ⊥ (the term diverges under βη-reduction).

But λx.Ω is a canonical form under normal-order evaluation (NOE),so its denotation must be different from ⊥ = [[Ω]].

⇒ the semantic domain D for NOE must include a least element ⊥in addition to a set of values of canonical forms V isomorphic to [D → D]:

D = V⊥ where V ∼= [D → D]

If Vφ−→←−ψ

[D → D], then Dφ⊥⊥−→←−ι↑ · ψ

[D → D], but the latter is not an isomorphism.

The semantic equations then are similar but using the new pair φ⊥⊥ and ι↑ · ψ:

[[v]] η = η v

[[λv. e]] η = (ι↑ · ψ) (λx ∈ D∞. [[e]][η | v : x])

[[e e′]] η = φ⊥⊥ ([[e]] η) ([[e′]] η)

Page 30: The Lambda Calculus - Yale Universityin the pure lambda calculus: an abstraction. A typical functional programming language allows functions to only be applied but not inspected, so

Normal-Order Evaluation and η-Contraction

In this semantics φ⊥⊥ and ι↑ · ψ do not define an isomorphism

between D and [D → D]:

φ⊥⊥ · (ι↑ · ψ) = I[D→D], but (ι↑ · ψ) · φ⊥⊥ 6= ID

Hence β-reduction is sound, while η-reduction is not.

Just what we expected:

λx.Ω x⇒ λx.Ω x is a canonical form, but λx.Ω xη7→ Ω 6⇒,

so [[λx.Ω x]] 6= Ω under NOE.

Y again corresponds to the least fixed fixed-point operator on D.

Page 31: The Lambda Calculus - Yale Universityin the pure lambda calculus: an abstraction. A typical functional programming language allows functions to only be applied but not inspected, so

Semantics of Eager Evaluation

Under eager evaluation arguments are reduced to canonical forms first,

so denotations of functions only operate on values in V

⇒ the environments are in [var → V ], and the domain equation is

D = V⊥ where V ∼= [V → D]

If Vφ−→←−ψ

[V → D], the semantic equations are

[[v]] η = ι↑ (η v)

[[λv. e]] η = (ι↑ · ψ) (λx ∈ D∞. [[e]][η | v : x])

[[e e′]] η = (φ⊥⊥ ([[e]] η))⊥⊥ ([[e′]] η)

Note: ι↑ is used to inject into D values from V

(denotations of canonical forms).

Page 32: The Lambda Calculus - Yale Universityin the pure lambda calculus: an abstraction. A typical functional programming language allows functions to only be applied but not inspected, so

The Fixed-Point Combinator Y and Eager Evaluation

The fixed-point combinator Y = λf. (λx. f (x x))λx. f (x x)

is not suitable for eager evaluation because Y e diverges for any e:

Y eβ7→∗E Y z if e⇒E z

β7→E (λv. z (v v))λv. z (v v) where v /∈ FV (z)β7→E z ((λv. z (v v))λv. z (v v))β7→E z (z ((λv. z (v v))λv. z (v v)))β7→E . . .

Page 33: The Lambda Calculus - Yale Universityin the pure lambda calculus: an abstraction. A typical functional programming language allows functions to only be applied but not inspected, so

The Fixed-Point Combinator Yv

Instead, use the call-by-value fixed-point combinator

Yvdef= λf. (λx. f (λy. x x y))λx. f (λy. x x y)

For any term e, if e⇒E z, then

Yv eβ7→∗E e′

def= (λv. z (λy. v v y))λv. z (λy. v v y) where v /∈ FV (z)

such that λv. e′ v is extensionally a fixed-point of e: for any term e1,

(λv. e′ v) e1β7→E e′ e1

β7→E z (λv. (λv. z (λy. v v y)) (λv. z (λy. v v y)) v) e1

= z (λv. e′ v) e1

(e (λv. e′ v)) e1β7→∗E z (λv. e′ v) e1