Cambridge University Press, Appel, Andrew W., Compiling with continuations / Andrew W. Appel. p. 25 cm. Includes bibliographical references. Then, during CPS transformation, continuations desugar into functions. methods, including the well-known treatments in Appel’s Compiling with Continuations. This book shows how continuation-passing style is used as an intermediate representation to perform optimizations and program transformations. Continuations.

Author: Goltir Gulkree
Country: Liberia
Language: English (Spanish)
Genre: Medical
Published (Last): 11 June 2004
Pages: 260
PDF File Size: 13.83 Mb
ePub File Size: 9.18 Mb
ISBN: 883-8-44260-726-1
Downloads: 37936
Price: Free* [*Free Regsitration Required]
Uploader: Doran

How to compile with continuations

This transformation is not hygienic ; if the continuation c references any of the ; bound variables! Code is available in Racket ; techniques applicable to any language. Yet, if the transform tags variables, call forms and lambdas as being user or continuationthe stack is recoverable. A hybrid transform Combining the naive and higher-order transforms provides the best of both worlds. This simple continuatlons in perspective is economical: Continuation-passing style If you’re new to continuation-passing contiuations, I recommend my earlier post on continuation-passing style by example.

Complex expressions may not terminate, and they may produce side effects. This is two steps forward, and one step back: Examples Even while this transformation is simple, its results are poor. The transformation of function application is the main culprit: How to compile with compilihg [ article index ] [] [ mattmight ] [ rss ].

Compiling with Continuations

During compilation, high-level control constructs ranging from coroutines and exceptions to while loops and break statements steadily desugar into a mixture of two constructs: Both of those lambda terms are continuations.

For example, the following: To generate a fresh variable bound to a user value, the transform will use genusymand for a fresh variables bound to a continuation, the transform will use genksym: Fortunately, the hybrid CPS transform readily adapts to features like basic values, conditionals, side effects, sequencing and comipling recursion. The wrinkle in the previous transform was that it forced function application to bind its function and its arguments to variables, even if they were already atomic.


Scaling to real language features The lambda calculus makes a nice platform for studying the architecture of a program transformation. In the function-application transform, the values of both the function and the argument have to be converted into CPS.

In this transformation, we have two functions, M and T: When a continuation gets invoked, deallocate its space by resetting the stack pointer compilinf that continuation. More resources Andrew Kennedy points out that CPS is more advantageous as an intermediate form with respect to optimization than had been previously thought.

There are some advantages [and disadvantages] to stackless compilation. Consider an expanded input language: The transform now has three principal functions: The transformation for letrec is not hygienic, because the transformation can introduce the letrec ‘d bindings into the scope of the continuation that gets passed to the transformer.

For the fourth transform, it will become partitioned CPS, and for the final transform, it will be a more realistic intermediate language with side effects, conditionals, basic values and explict recursion.

Knowing how to convert code into CPS, either by hand or algorithmically, contnuations a continuatiosn weapon in the programmer’s arsenal.

Danvy, Millikin and Nielsen have been able to connect some of these methods, including the well-known treatments in Appel’s Compiling with Continuations and Queinnec’s Lisp in Small Pieces.


When a continuation gets allocated, bump the stack pointer. Because continuations are used in a last-allocated, first-invoked fashion, we can implement them as a stack.

How to compile with continuations

In the higher-order transform, the function T: For the first three transforms, the input language is the lambda calculus: Appel’s Compiling with Continuations and Queinnec’s Lisp in Small Pieces are invaluable resources for the functional compiler writer. We can even use the stack pointer register. The naive transformation The naive transformation likely dates to Plotkin’s earliest work. If the transform receives a real function expecting the atomic version of a the supplied expression, then the transform can check whether it is necessary to bind it to a variable.

My post on implementing exceptions. In terms of unreasonable effectiveness, the transformation to continuation-passing style CPS ranks with the Y combinator.

The goal of this article is to introduce CPS transforms in small, individually digestible compilimg before stitching them back together as a unified whole. T ‘ g a ‘halt produces: To start, split the grammar: The transform converts each with Tand then catches their results in newly-created continuations. My post on A-Normalization.

All calls become tail calls, so in effect, there is no stack.

If you’re new to continuation-passing style, I recommend my earlier post on continuation-passing style by example. Ultimately, however, that transformation must run on real code.