We give a brief account of the discoveries of continuations and related concepts by, A. Van Wijngaarden , A. W. Mazurkiewicz , F. L. Morris , C. P. Wadsworth , J. H. Morris , M. J. Fischer , and S. K. Abdali.

A lambda-calculus schema is an expression of the lambda calculus augmented by uninterpreted constant and operator symbols. It is an abstraction of programming languages such as LISP which permit functions to be passed to and returned from other functions. When given an interpretation for its constant and operator symbols, certain schemata, called lambda abstractions, naturally define partial functions over the domain of interpretation. Two implementation strategies are considered: the retention strategy in which all variable bindings are retained until no longer needed (implying the use of some sort of garbage-collected store) and the deletion strategy, modeled after the usual stack implementation of ALGOL 60, in which variable bindings are destroyed when control leaves the procedure (or block) in which they were created. Not all lambda abstractions evaluate correctly under the deletion strategy. Nevertheless, both strategies are equally powerful in the sense that any lambda abstraction can be mechanically translated into another that evaluates correctly under the deletion strategy and defines the same partial function over the domain of interpretation as the original. Proof is by translation into continuation-passing style.

The last few years have seen a renewed interest in continuations for expressing advanced control structures in programming languages, and new models such as Abstract Continuations have been proposed to capture these dimensions. This article investigates an alternative formulation, exploiting the latent expressive power of the standard continuation-passing style (CPS) instead of introducing yet other new concepts. We build on a single foundation: abstracting control as a hierarchy of continuations, each one modeling a specific language feature as acting on nested evaluation contexts. We show how iterating the continuation-passing conversion allows us to specify a wide range of control behavior. For example, two conversions yield an abstraction of Prologstyle backtracking. A number of other constructs can likewise be expressed i...

ion of Typed Contexts Olivier Danvy & Andrzej Filinski DIKU -- Computer Science Department, University of Copenhagen Universitetsparken 1, 2100 Copenhagen , Denmark uucp: danvy@diku.dk & andrzej@diku.dk Abstract This report investigates abstracting control with functions. This is achieved by defining continuations as functions abstracting lexically a delimited context [C[ ]] rather than dynamically an unlimited one C[ ], as it is usually the case. Because their co-domain is distinguished from the final domain of Answers, such continuations can be composed, and this contrasts with the simple exceptions of ML and Lisp and the unlimited first-class continuations of Scheme. Making these functional control abstractions first-class o#ers a new area in programming which this paper explores. The key points obtained here are: a denotational semantics for a simple, call-by-value, strongly typed expression language with higher-order functions and first-class continuations; its congruence with a ...

We present a simple method for normalizing the control-flow of programs to facilitate program transformations, program analysis, and automatic parallelization. While previous methods result in programs whose control flowgraphs are reducible, programs normalized by this technique satisfy a stronger condition than reducibility and are therefore simpler in their syntax and structure than with previous methods. In particular, all control-flow cycles are normalized into single-entry, single-exit while loops, and all goto's are eliminated. Furthermore, the method avoids problems of code replication that are characteristic of node-splitting techniques. This restructuring obviates the control dependence graph, since afterwards control dependence relations are manifest in the syntax tree of the program. In this paper we present transformations that effect this normalization, and study the complexity of the method. Index Terms: Continuations, control-flow, elimination algorithms, normalization,...

Compilers for higher-order programming languages like Scheme, ML, and Lisp can be broadly characterized as either "direct compilers" or "continuation-passing style (CPS) compilers", depending on their main intermediate representation. Our central result is a precise correspondence between the two compilation strategies. Starting from

This paper gives denotational models for three logic programming languages of progressive complexity, adopting the \logic programming without logic" approach. The rst language is the control ow kernel of sequential Prolog, featuring sequential composition and backtracking. A committedchoice concurrent logic language with parallel composition (parallel AND) and don't care nondeterminism is studied next. The third language is the core of Warren's basic Andorra model, combining parallel composition and don't care nondeterminism with two forms of don't know nondeterminism (interpreted as sequential and parallel OR) and favoring deterministic over nondeterministic computation. We show that continuations are a valuable tool in the analysis and design of semantic models for both sequential and parallel logic programming. Instead of using mathematical notation, we use the functional programming language Haskell as a metalanguage for our denotational semantics, and employ monads in order to facilitate the transition from one language under study to another. Keywords Parallel logic programming, basic Andorra model, denotational semantics, continuations, monads, Haskell. 1.

For a notion of reduction in a #-calculus one can ask whether a term satises conservation and uniform normalization. Conservation means that single-step reductions of the term preserve innite reduction paths from the term. Uniform normalization means that either the term will have no reduction paths leading to a normal form, or all reduction paths will lead to a normal form.

We show how properties of an interesting class of imperative programs can be verifed by means of relational modelling and symbolic computation.

Abstract not found