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]  A. Sabry,et al.  From Syntactic Theories to Interpreters: Automating the Proof of Unique Decomposition , 2001, High. Order Symb. Comput..

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

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

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

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

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

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

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

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

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

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

[12]  J. Hook,et al.  Type-driven defunctionalization , 1997, ICFP '97.

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

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

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

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

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

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

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

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

[21]  Olivier Danvy,et al.  Back to Direct Style , 1992, Sci. Comput. Program..

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

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

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

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

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

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

[28]  H. Barendregt.  The Lambda Calculus: Its Syntax and Semantics , 1985 .

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

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

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

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

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

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

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

[36]  J. C. Reynolds.  Theories of programming languages , 1998 .

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

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

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

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

[41]  Torben Mogensen Diku.  Eecient Self-interpretation in Lambda Calculus , 1994 .

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

[43]  Philip Wadler,et al.  Deforestation: Transforming Programs to Eliminate Trees , 1990, Theor. Comput. Sci..

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

[45]  S. Jones.  The Implementation of Functional Programming Languages , 1987 .

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

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

[48]  H. P. Barendregt.  The lambda calculus - its syntax and semantics , 1985, Studies in logic and the foundations of mathematics.

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

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

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

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

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

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