Classical logic, continuation semantics and abstract machines

One of the goals of this paper is to demonstrate that denotational semantics is useful for operational issues like implementation of functional languages by abstract machines. This is exemplified in a tutorial way by studying the case of extensional untyped call-by-name λ-calculus with Felleisen's control operator C. We derive the transition rules for an abstract machine from a continuation semantics which appears as a generalization of the ¬¬-translation known from logic. The resulting abstract machine appears as an extension of Krivine's machine implementing head reduction. Though the result, namely Krivine's machine, is well known our method of deriving it from continuation semantics is new and applicable to other languages (as e.g. call-by-value variants). Further new results are that Scott's D∞-models are all instances of continuation models. Moreover, we extend our continuation semantics to Parigot's λμ-calculus from which we derive an extension of Krivine's machine for λμ-calculus. The relation between continuation semantics and the abstract machines is made precise by proving computational adequacy results employing an elegant method introduced by Pitts.

[1]  Michel Parigot,et al.  Lambda-Mu-Calculus: An Algorithmic Interpretation of Classical Natural Deduction , 1992, LPAR.

[2]  Matthias Felleisen,et al.  A Syntactic Theory of Sequential Control , 1987, Theor. Comput. Sci..

[3]  J. Roger Hindley,et al.  To H.B. Curry: Essays on Combinatory Logic, Lambda Calculus, and Formalism , 1980 .

[4]  Philippe de Groote,et al.  An environment machine for the λμ-calculus , 1998, Mathematical Structures in Computer Science.

[5]  John C. Reynolds.  Definitional Interpreters for Higher-Order Programming Languages , 1998, High. Order Symb. Comput..

[6]  Michael J. Fischer,et al.  Lambda-calculus schemata , 1993, LISP Symb. Comput..

[7]  Matthias Felleisen,et al.  Control operators, the SECD-machine, and the λ-calculus , 1987, Formal Description of Programming Concepts.

[8]  John C. Reynolds,et al.  Definitional Interpreters for Higher-Order Programming Languages , 1972, ACM '72.

[9]  Peter Lee,et al.  Call-by-need and continuation-passing style , 1994, LISP Symb. Comput..

[10]  Andrew W. Appel,et al.  Compiling with Continuations , 1991 .

[11]  Eugenio Moggi,et al.  Notions of Computation and Monads , 1991, Inf. Comput..

[12]  Harold T. Hodes,et al.  The | lambda-Calculus. , 1988 .

[13]  Timothy G. Griffin,et al.  A formulae-as-type notion of control , 1989, POPL '90.

[14]  C.-H. Luke Ong,et al.  A Generic Strong Normalization Argument: Application to the Calculus of Constructions , 1993, CSL.

[15]  Gordon D. Plotkin,et al.  Call-by-Name, Call-by-Value and the lambda-Calculus , 1975, Theor. Comput. Sci..

[16]  P. J. Freyd.  Applications of Categories in Computer Science: Remarks on algebraically compact categories , 1992 .

[17]  Pierre-Louis Curien,et al.  An Abstract Framework for Environment Machines , 1991, Theor. Comput. Sci..

[18]  Robert Hieb,et al.  The Revised Report on the Syntactic Theories of Sequential Control and State , 1992, Theor. Comput. Sci..

[19]  Andrew M. Pitts,et al.  Computational Adequacy via "Mixed" Inductive Definitions , 1993, MFPS.

[20]  Amr Sabry,et al.  Reasoning about programs in continuation-passing style , 1992, LFP '92.

[21]  Alan Jeffrey,et al.  A fully abstract semantics for concurrent graph reduction , 1994, Proceedings Ninth Annual IEEE Symposium on Logic in Computer Science.

[22]  Martín Abadi,et al.  Explicit substitutions , 1989, POPL '90.

[23]  Martin Hofmann,et al.  Continuation models are universal for lambda-mu-calculus , 1997, LICS 1997.

[24]  Matthias Felleisen,et al.  The calculi of lambda-nu-cs conversion: a syntactic theory of control and state in imperative higher-order programming languages , 1987 .