Colloquium presentation

Continuation calculus
An alternative to lambda calculus
Midterm presentation
Bram Geron
(supervised by Herman Geuvers)
Eindhoven University of Technology
FSA colloquium, June 2013
Bram Geron (TU/e) Continuation calculus FSA colloquium 1 / 31

Modeling programming languages
Goals:
Assign exact meaning to programs
Assign exact meaning to functions
Reason on functions
Approaches:
Big-step semantics
Small-step semantics
Reduction to simpler calculus

Goals:
Assign exact meaning to programs
Assign exact meaning to functions
Reason on functions
Approaches:
Big-step semantics: lambda calculus
Small-step semantics: lambda calculus, continuation calculus
Reduction to simpler calculus: programming languages to λ or CC

Simple calculi
Lambda calculus
Tree of expressions
(fact 4)+1
β 25
Tree of “continuation terms”
Fact.(AddOne.Return).4
Return.25

First look
Outline
1 First look
2 Deﬁnition
3 Long-term goal
4 The importance of head reduction
5 Case study: list multiplication
6 Conclusion

First look Rules, names, variables, terms
CC is a term rewriting system in a constrained shape
Comp.f .g.x
def
−→ f .(g.x)
Comp.AddOne.Fact.4 → AddOne.(Fact.4)
Rules
One deﬁnition per name
(max)
No pattern matching
Only head reduction
Consequences
Deterministic
Simple operational semantics
Suitable for modeling
continuations, hence exceptions

First look Rules, names, variables, terms
rule
Comp
name
(constant)
.f .g.x
variables
def
−→ f .(g.x)
Comp.AddOne.Fact.4
term
→ AddOne.(Fact.4)
term
Rules
One deﬁnition per name
(max)
No pattern matching
Only head reduction
Consequences
Deterministic
Simple operational semantics
Suitable for modeling
continuations, hence exceptions

First look Head reduction: continuation passing style
Functions ﬁll in the result in their continuation parameter
Comp.f .g.x
def
−→ f .(g.x)
Comp.AddOne.Fact.4 → AddOne.(Fact).4
Realistic names:
Fact.r.x r.x!
AddOne.r.x r.(x +1)
Fact.(AddOne.r).4 AddOne.r.24
r.25
−→ CPS transformation

First look Head reduction: continuation passing style
Functions ﬁll in the result in their continuation parameter
Comp.r.f .g.x
def
−→ g.(f .r).x
Comp.r.AddOne.Fact.4 → Fact.(AddOne.r).4
Realistic names:
Fact.r.x r.x!
AddOne.r.x r.(x +1)
Fact.(AddOne.r).4 AddOne.r.24
r.25
−→ CPS transformation

First look Another example
Natural numbers
Representation and AddOne
We represent 0 by Zero, 3 by S.(S.(S.Zero)), and n by
S.(··· .(S.Zero)···). These terms are denoted n .
We implement the function AddOne, such that AddOne.r. n r. n +1 .
AddOne.r.m
def
−→ r.(S.m)

Natural numbers
Behavior and Double
There are rules for Zero and S:
Zero.z.s
def
−→ z s.t. 0 .z.s z
S.m.z.s
def
−→ s.m s.t. m +1 .z.s s. m
We can now make a function Double such that Double.r. n r. 2n .
Double.r.m
def
−→ m.(r.Zero).(Double.(AddOne.(AddOne.r)))

Natural numbers
Behavior and Double
Double.r.m
def

Natural numbers
Behavior and Double
Double.r.m
def
Double.r. 0 → Zero.(r. 0 ).(Double.(AddOne.(AddOne.r)))
→ r. 0

Natural numbers
Behavior and Double
Double.r.m
def
Double.r. 2 → S. 1 .(r. 0 ).(Double.(AddOne.(AddOne.r)))
→ Double.(AddOne.(AddOne.r)). 1
→ S. 0 .(AddOne.(AddOne.r). 0 ).(Double.(AddOne.(AddOne.(AddOne.(Add
→ Double.(AddOne.(AddOne.(AddOne.(AddOne.r)))). 0
→ Zero.(AddOne.(AddOne.(AddOne.(AddOne.r))). 0 ).(Double.(AddOne.(Ad
→ AddOne.(AddOne.(AddOne.(AddOne.r))). 0
r. 4 in 4 steps

Definition
Definitions
There is an infinite set of names, indicated by a capital.
A term is either a name, or two terms combined by a dot.
We write a.b.c as shorthand for (a.b).c.
A program P consists of a set of rules, of the form
Name.variable.··· .variable
def
−→ term over those variables
That rule defines that name.
Each rule defines a different name.
If “N.x1 .··· .xk
def
−→ r” ∈ P, then we reduce N.t → r[t/x].
Term N.x1.··· .xl for l = k does not reduce at all.
There is only head reduction.

Long-term goal
Long-term goal
Formally modeling programming languages
Hopefully as a base for better languages
Operational semantics
Running time: #steps ∼ seconds CPU time
Warning: some unsubstantiated claims
Compositional
Facilitates proving properties
Deterministic by nature
Works with continuations
Explained later

The importance of head reduction
Outline
1 First look
2 Deﬁnition
3 Long-term goal
6 Conclusion

Outline
1 First look
2 Deﬁnition
3 Long-term goal
6 Conclusion

Back to modeling programs
Lambda calculus
λx.+ (f x) (g x)
M N Push N on stack,
continue in M
λx.M Pop N oﬀ stack,
continue in M[N/x]
Programming language
fun x → (f x) + (g x)
M N Apply function object
to argument
fun x → M Make function object
In “real languages”, functions throw exceptions and have other side eﬀects.

Back to modeling programs
Lambda calculus
λx.+ (f x) (g x)
M N Push N on stack,
continue in M
λx.M Pop N oﬀ stack,
continue in M[N/x]
Programming language
fun x → (f x) + (g x)
throws exception
now what?
M N Apply function object
to argument
fun x → M Make function object
In “real languages”, functions throw exceptions and have other side eﬀects.

Operational semantics
Computational models with control
Lambda calculus + continuations (λC)
Reduction using four instructions on the top level
M N Push N on stack, continue in M
λx.M Pop N oﬀ stack, continue in M[N/x]
A M Empty the stack, continue in M
C M Empty the stack, continue in M (λx.S x)
where function S ‘restores’ the previous stack
(details omitted)
Can model exception-like facilities
CPS transformation to transform λC terms to λ terms

CPS transformation
λC
CPS transformation
−−−−−−−−−−−→ subset of λ, makes minimal use of stack
Two calculi in action:
λC calculus: M N, λx.M, A M, C M
Expressive
Subset of λ calculus: M N, λx.M
Simpler

CPS transformation
λC
CPS transformation
Expressive
Simpler
What is this subset, really?

CPS transformation
λC
CPS transformation
Expressive
Simpler
Can we describe it?

CPS transformation
λC
CPS transformation
Expressive
Simpler
Can we describe it?
An elegant model of computation, perhaps?

Lambda calculus vs. continuation calculus
λC
Four instructions on the top level
M N Push N on stack, continue in M
λx.M Pop N oﬀ stack, continue in M[N/x]
A M Empty the stack, continue in M
C M Empty the stack, continue in M (λx.S x)
where function S ‘restores’ the stack
One instruction on the top level, using program P
n.t1.··· .tk Empty the stack, continue in r[t/x]
if n.x1 .··· .xk
def
−→ r ∈ P

One instruction on the top level, using program P
n.t1.··· .tk Continue in r[t/x]
if n.x1 .··· .xk
def
−→ r ∈ P
No stack needed, because
n.t1.··· .tl does not reduce for l = k.
Subterms are not reduced

Case study: list multiplication
Outline
1 First look
2 Deﬁnition
3 Long-term goal
6 Conclusion

List multiplication
An algorithm
product [4,2,6] = 4∗2∗6 = 48
product l = case l of
| [] → 1
| [x]++xs → x ∗product xs
product [4,2,6] = 4∗(2∗(6∗1)) = 48

List multiplication
A better algorithm
product [4,0,6] = 4∗0∗6 = 0
product l = case l of
| [] → 1
| [x]++xs → x ∗product xs
product [4,0,6] = 4∗(0∗(6∗1)) = 0

List multiplication
A better algorithm
product [4,0,6] = 4∗0∗6 = 0
product l =
try:
let subproduct l = case l of
| [] → 1
| [0]++xs → abort
| [x]++xs → x ∗subproduct xs
in subproduct l
catch abort :
0

List multiplication
A better algorithm
product l =
try:
let subproduct l = case l of
| [] → 1
| [0]++xs → abort
| [x]++xs → x ∗subproduct xs
in subproduct l
catch abort :
0
product [4,0,6] = try: {4∗abort} catch abort : 0
= 0

List multiplication
Implementation
Implemented ListMult with this behavior in continuation calculus
includes modeling of naturals and lists with CC rules
Proved correct
ListMult. l .r r. product l for all l ∈ ListN
Empirical evidence of eﬃciency
ListMult. [4,0,6] .r r. 0 in 10 steps
ListMult. [4,2,6] .r r. 48 in 339 steps

Conclusion
Conclusion
CC is deterministic
Only head reduction
As a consequence,
Suitable for control with continuations (exceptions)
CC is similar to a subset of lambda calculus
Mimics running times of real programs to some degree

Conclusion
Current state and future work
Joint paper with Herman Geuvers
Accepted in proceedings of COS 2013, 24–25 June
Future work:
Systematic translation of functional programming language to CC
Prove that this translation preserves semantics
Type system
Model hierarchical side-eﬀects using an extension

Conclusion
The End
Questions?

Bibliography
Bibliography

Extra slides
Extra slides
Extra slides

Extra slides Relation to lambda calculus
Relation to lambda calculus
λ,λC
CPS transformation
−−−−−−−−−−−→ subset of λ
subset of λ
λx to rules∗
−−−−−−−−−−−−−−−−−−−−−−
unfold†
rules to λx
CC
∗ λx to rules: involves a supercombinator transformation
† Unfold rules to λx: ﬁrst apply a ﬁxed-point elimination to eliminate cyclic references
Catchphrase
CC is more limited than λ,
thus more suitable to model continuations

Extra slides Interfaces, not pattern matching
Natural numbers
Slightly similar to lambda calculus
Zero.z.s
def
−→ z
S.x.z.s
def
−→ s.x
Add.r.x.y
def
−→ y.(r.x).(Add.r.(S.x))
Algorithm:
x +0 = x
x +S(y) = S(x)+y
Add.r.(S.Zero).Zero → Zero.(r.(S.Zero)).(Add.r.(S.(S.Zero)))
→ r.(S.Zero)
Add.r.Zero.(S.Zero) → S.Zero.(r.Zero).(Add.r.(S.Zero))
→ Add.r.(S.Zero).Zero
→ Zero.(r.(S.Zero)).(Add.r.(S.(S.Zero)))
→ r.(S.Zero)

Natural numbers
Zero.z.s
def
−→ z
S.x.z.s
def
−→ s.x
Add.r.x.y
def
−→ y.(r.x).(Add.r.(S.x))
Algorithm:
x +0 = x
x +S(y) = S(x)+y
What can we feed to Add?
Zero
S.(··· .(S.Zero)···)
Something else?

Natural numbers
Zero.z.s
def
−→ z
S.x.z.s
def
−→ s.x
Add.r.x.y
def
−→ y.(r.x).(Add.r.(S.x))
Algorithm:
x +0 = x
x +S(y) = S(x)+y
What can we feed to Add?
Zero
S.(··· .(S.Zero)···)
Something else? Yes!

Natural numbers
Compatible naturals
Zero.z.s
def
−→ z
S.x.z.s
def
−→ s.x
Add.r.x.y
def
−→ y.(r.x).(Add.r.(S.x))
Algorithm:
x +0 = x
x +S(y) = S(x)+y
We deﬁne when a term t represents natural number n.
1 t represents 0 if ∀z,s : t.z.s z
Informally: t “behaves the same as” Zero
2 t represents n +1 if ∀z,s : t.z.s s.q, and q represents n
Informally: t “behaves the same as” S.q
With this, we can deﬁne LazyFact such that LazyFact.x represents (x!).
(Omitted.)

Natural numbers
Compatible naturals
Zero.z.s
def
−→ z
S.x.z.s
def
−→ s.x
Add.r.x.y
def
−→ y.(r.x).(Add.r.(S.x))
Algorithm:
x +0 = x
x +S(y) = S(x)+y
(Omitted.)
Add.r.Zero.(LazyFact.(S.Zero)) → LazyFact.(S.Zero).(r.Zero).(Add.r.(S.Zero))
Add.r.(S.Zero).Zero
→ Zero.(r.(S.Zero)).(Add.r.(S.(S.Zero)))
→ r.(S.Zero)

Natural numbers
Compatible naturals
Zero.z.s
def
−→ z
S.x.z.s
def
−→ s.x
Add.r.x.y
def
−→ y.(r.x).(Add.r.(S.x))
Algorithm:
x +0 = x
x +S(y) = S(x)+y
(Omitted.)
Add.r.Zero.(LazyFact.(S.Zero)) r.(S.Zero)
Two types of function names
Call-by-value / eager: calculate result, ﬁll in in continuation
Call-by-name / lazy: compatible with Sn.Zero but delayed
computation

Appendix
Ideas
Eﬃcient te compileren?
OUTLOOK

Colloquium presentation

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (18)

Similar a Colloquium presentation

Similar a Colloquium presentation (20)

Último

Último (20)

Colloquium presentation