Defunctionalization at work

Reynolds's defunctionalization technique is a whole-program transformation from higher-order to first-order functional programs. We study practical applications of this transformation and uncover new connections between seemingly unrelated higher-order and first-order specifications and between their correctness proofs. Defunctionalization therefore appearsboth as a springboard for rev ealing new connections and as a bridge for transferring existing results between the first-order world and the higher-order world.

[1]  Christopher Strachey,et al.  Fundamental Concepts in Programming Languages , 2000, High. Order Symb. Comput..

[2]  Robert Harper,et al.  Typed closure conversion , 1996, POPL '96.

[3]  Simon Peyton Jones,et al.  Implementing functional languages , 1992 .

[4]  Olivier Danvy,et al.  Normalization by evaluation with typed abstract syntax , 2001, J. Funct. Program..

[5]  Thomas Johnsson,et al.  Lambda Lifting: Treansforming Programs to Recursive Equations , 1985, FPCA.

[6]  Todd A. Proebsting.  Simple translation of goal-directed evaluation , 1997, PLDI '97.

[7]  Lasse Nielsen,et al.  A Denotational Investigation of Defunctionalization , 2000 .

[8]  Chris Mellish,et al.  Integrating Prolog in the POPLOG Environment , 1984, Implementations of Prolog.

[9]  Olin Shivers,et al.  Control-flow analysis of higher-order languages of taming lambda , 1991 .

[10]  Robert Harper,et al.  Proof-directed debugging , 1999, Journal of Functional Programming.

[11]  John C. Reynolds,et al.  The essence of ALGOL , 1997 .

[12]  Olivier Danvy.  Back to Direct Style , 1992, ESOP.

[13]  Olivier Danvy,et al.  Formalizing Implementation Strategies for First-Class Continuations , 1999, ESOP.

[14]  Simon L. Peyton Jones,et al.  The Implementation of Functional Programming Languages , 1987 .

[15]  Mitchell Wand,et al.  Continuation-Based Program Transformation Strategies , 1980, JACM.

[16]  David Robson,et al.  Smalltalk-80: The Language and Its Implementation , 1983 .

[17]  Suresh Jagannathan,et al.  Flow-Directed Closure Conversion for Typed Languages , 2000, ESOP.

[18]  Mayer Goldberg,et al.  Recursive application-survival in the lambda calculus , 1996 .

[19]  A. Church.  The Calculi of Lambda Conversion. (AM-6) (Annals of Mathematics Studies) , 1985 .

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

[21]  Olivier Danvy,et al.  The Occurrence of Continuation Parameters in CPS Terms , 1995 .

[22]  Jr. Guy L. Steele,et al.  Rabbit: A Compiler for Scheme , 1978 .

[23]  Jean-Yves Girard,et al.  Locus Solum: From the rules of logic to the logic of rules , 2001, Mathematical Structures in Computer Science.

[24]  Simon Peyton Jones,et al.  The Implementation of Functional Programming Languages (Prentice-hall International Series in Computer Science) , 1987 .

[25]  Anindya Banerjee,et al.  Design and Correctness of Program Transformations Based on Control-Flow Analysis , 2001, TACS.

[26]  John Hughes,et al.  A Novel Representation of Lists and its Application to the Function "reverse" , 1986, Inf. Process. Lett..

[27]  Olivier Danvy,et al.  A Unifying Approach to Goal-Directed Evaluation , 2001 .

[28]  D. A. Turner,et al.  A new implementation technique for applicative languages , 1979, Softw. Pract. Exp..

[29]  Jeffrey D. Ullman,et al.  Introduction to Automata Theory, Languages and Computation , 1979 .

[30]  Zoltán Ésik,et al.  The Equational Theory of Fixed Points with Applications to Generalized Language Theory , 2001, Developments in Language Theory.

[31]  Glynn Winskel,et al.  The formal semantics of programming languages - an introduction , 1993, Foundation of computing series.

[32]  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 .

[33]  James Hook,et al.  Type-driven defunctionalization , 1997, ICFP '97.

[34]  Andrew W. Appel,et al.  Type-preserving garbage collectors , 2001, POPL '01.

[35]  Olivier Danvy,et al.  Representing Control: a Study of the CPS Transformation , 1992, Mathematical Structures in Computer Science.

[36]  Andrew W. Appel,et al.  Continuation-passing, closure-passing style , 1989, POPL '89.

[37]  A. Church.  The calculi of lambda-conversion , 1941 .

[38]  Henk Barendregt,et al.  The Lambda Calculus: Its Syntax and Semantics , 1985 .

[39]  Frank D. Valencia,et al.  A Temporal Concurrent Constraint Programming Calculus , 2001, CP.

[40]  Urban Boquist,et al.  Code Optimisation Techniques for Lazy Functional Languages , 1999 .

[41]  E. Dijkstra,et al.  Recursive Programming , 1960 .

[42]  John C. Reynolds.  Theories of programming languages , 1998 .

[43]  Michael Kifer,et al.  HILOG: A Foundation for Higher-Order Logic Programming , 1993, J. Log. Program..

[44]  R. J. M. Hughes,et al.  Super-combinators a new implementation method for applicative languages , 1982, LFP '82.

[45]  Jeff Polakow,et al.  Linear logic programming with an ordered context , 2000, PPDP '00.

[46]  Amr Sabry,et al.  From Syntactic Theories to Interpreters: Automating the Proof of Unique Decomposition , 2001, High. Order Symb. Comput..

[47]  Kwangkeun Yi,et al.  Proving Syntactic Properties of Exceptions in an Ordered Logical Framework , 2001, APLAS.

[48]  Norman Y. Foo,et al.  A denotational semantics for Prolog , 1989, ACM Trans. Program. Lang. Syst..

[49]  John C. Reynolds,et al.  Definitional Interpreters Revisited , 1998, High. Order Symb. Comput..

[50]  R. K. Dybvig.  Three implementation models for scheme , 1987 .

[51]  Mitchell Wand,et al.  Essentials of programming languages , 2008 .

[52]  Torben Æ. Mogensen.  Efficient self-interpretation in lambda calculus , 1992, Journal of Functional Programming.

[53]  P. J. Landin.  The Mechanical Evaluation of Expressions , 1964, Comput. J..

[54]  Mitchell Wand,et al.  Lightweight closure conversion , 1997, TOPL.

[55]  Olivier Danvy,et al.  Back to direct style II: first-class continuations , 1992, LFP '92.

[56]  G. Winskel.  The formal semantics of programming languages , 1993 .

[57]  Jirí Srba,et al.  On the Power of Labels in Transition Systems , 2001, CONCUR.

[58]  Philip Wadler,et al.  Deforestation: Transforming Programs to Eliminate Trees , 1988, Theoretical Computer Science.

[59]  Andrew P. Tolmach,et al.  From ML to Ada: Strongly-typed language interoperability via source translation , 1998, Journal of Functional Programming.