Background In his classic 1972 paper on definitional interpreters, John Reynolds introduced two key techniques: Continuation-passing style - Makes control flow explicit Defunctionalisation - Makes programs first-order

Background These techniques are often used together: language compiler CPS DEFUN Can the two steps be fused together !? Introduce continuations Remove continuations

This Talk A new approach to transforming high-level semantics into low-level implementations; Only requires simple calculation techniques, and avoids the use of continuations; Scales to exceptions, state, variable binding, loops, non-determinism, interrupts, etc.

Arithmetic Expressions Syntax: data Expr = Val Int | Add Expr Expr Semantics: eval :: Expr  Int eval (Val n) = n eval (Add x y) = eval x + eval y

Step 1 – Add Continuations Make the flow of control explicit by transforming the semantics into continuation-passing style. Definition: A continuation is a function that is applied to the result of another computation.

Specification Aim: define a new semantics such that eval’ :: Expr  Cont  Int Cont = Int  Int such that eval’ e c = c (eval e)

Control flow now explicit. New semantics: eval’ :: Expr  Cont  Int eval’ (Val n) c = c n eval’ (Add x y) c = eval’ x (n  eval’ y (m  c (n + m))) Original semantics: Control flow now explicit. eval e = eval’ e (n  n)

Step 2 - Defunctionalise Make the semantics first-order again by applying the technique of defunctionalisation. Basic idea: Represent the continuations that we actually need using a datatype.

Specification Aim: define a new semantics such that eval’’ :: Expr  CONT  Int such that exec :: CONT  Cont eval’’ e c = eval’ e (exec c)

An abstract machine for evaluating expressions. New semantics: eval’’ :: Expr  CONT  Int eval’’ (Val n) c = exec c n eval’’ (Add x y) c = eval’’ x (NEXT y c) exec :: CONT  Int  Int exec (NEXT y c) n = eval’’ y (ADD n c) exec (ADD n c) m = exec c (n + m) exec HALT n = n An abstract machine for evaluating expressions.

Reflection We now have a two step process for calculating an abstract machine from a high-level semantics: 1 – Add a continuation 2 – Remove the continuations Can the steps be combined?

The Trick Start directly with the combined specification: = eval’’ e c exec c (eval e) = Aim to calculate definitions for eval’’, exec and CONT that satisfy these equations.

In Practice Calculating three interlinked definitions at the same time seems like an impossible task; But... with experience gained from our stepwise approach, it turns out to be straightforward; New calculation is simpler, more direct, and eliminates the use of continuations.

Now we appear to be stuck, as no further definitions can be applied. Case: e = Add x y eval’’ (Add x y) c exec c (eval (Add x y)) = exec c (eval x + eval y) = Now we appear to be stuck, as no further definitions can be applied. But we are using induction, so we have induction hypotheses!

We start by generalising to: To use the hypothesis for y, we need a term of form exec c’ (eval y) for some c’, i.e. we must solve: exec c (eval x + eval y) exec c’ (eval y) = We start by generalising to: exec c (n + m) exec c’ m = But we can’t simply use this as a definition for exec, because c and n are unbound.

Solution Package the free variables up in the argument c’ by adding a new constructor to the CONT type, ADD :: Int  CONT  CONT and a new equation for the exec function: exec (ADD n c) m = exec c (n + m)

Now we can continue: = = = exec c (eval x + eval y) exec (ADD (eval x) c) (eval y) = eval’’ y (ADD (eval x) c) = . =

Summary The rest of the calculation of the abstract machine proceeds in a similar manner; The driving force for the calculation is the desire to apply induction hypotheses; We solve the resulting equations by adding new constructors to CONT on demand.

Final Result data CONT where NEXT :: Expr  CONT  CONT ADD :: Int  CONT  CONT HALT :: CONT eval’’ (Val n) c = exec c n eval’’ (Add x y) c = eval’’ x (NEXT y c) exec (NEXT y c) n = eval’’ y (ADD n c) exec (ADD n c) m = exec c (n + m) exec HALT n = n

Conclusion Purely calculational approach to cutting out the intermediate use of continuations; Only requires simple techniques, and scales to a wide variety of language features; Can also be used to calculate compilers, and everything has been formalised in Coq.