Partial evaluation and automatic program generation

Functions, types and expressions programming languages and their operational semantics compilation partial evaluation of a flow chart languages partial evaluation of a first-order functional languages the view from Olympus partial evaluation of the Lambda calculus partial evaluation of prolog aspects of Similix - a partial evaluator for a subset of scheme partial evaluation of C applications of partial evaluation termination of partial evaluation program analysis more general program transformation guide to the literature the self-applicable scheme specializer.

[1]  John McCarthy,et al.  A basis for a mathematical theory of computation, preliminary report , 1899, IRE-AIEE-ACM '61 (Western).

[2]  Alonzo Church,et al.  A note on the Entscheidungsproblem , 1936, Journal of Symbolic Logic.

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

[4]  S. C. Kleene,et al.  Introduction to Metamathematics , 1952 .

[5]  A. Tarski.  A LATTICE-THEORETICAL FIXPOINT THEOREM AND ITS APPLICATIONS , 1955 .

[6]  John McCarthy,et al.  LISP 1.5 Programmer's Manual , 1962 .

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

[8]  E. Lohse,et al.  A Correspondence Between ALGOL 60 and Church's Lambda- Notation: Part I* , 1965 .

[9]  Kenneth E. Batcher,et al.  Sorting networks and their applications , 1968, AFIPS Spring Joint Computing Conference.

[10]  D. C. Cooper,et al.  Theory of Recursive Functions and Effective Computability , 1969, The Mathematical Gazette.

[11]  Fred G. Gustavson,et al.  Symbolic Generation of an Optimal Crout Algorithm for Sparse Systems of Linear Equations , 1970, JACM.

[12]  Jay Earley,et al.  An efficient context-free parsing algorithm , 1970, Commun. ACM.

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

[14]  Rasmus Lerdorf,et al.  Introduction to combinatory logic , 1972 .

[15]  Alfred V. Aho,et al.  LR Parsing , 1974, ACM Comput. Surv..

[16]  Robert S. Boyer,et al.  Proving Theorems about LISP Functions , 1973, JACM.

[17]  Peter David Mosses.  Mathematical semantics and compiler generation , 1975 .

[18]  Ben Wegbreit.  Goal-Directed Program Transformation , 1976, IEEE Trans. Software Eng..

[19]  Program control via transition matrices: a novel application of micro-programming , 1976, MINI.

[20]  Erik Sandewall,et al.  A Partial Evaluator, and its Use as a Programming Tool , 1976, Artif. Intell..

[21]  Andrei P. Ershov,et al.  On the Partial Computation Principle , 1977, Inf. Process. Lett..

[22]  Donald E. Knuth,et al.  Fast Pattern Matching in Strings , 1977, SIAM J. Comput..

[23]  Richard S. Bird,et al.  Improving programs by the introduction of recursion , 1977, Commun. ACM.

[24]  Andrei P. Ershov,et al.  On the Essence of Compilation , 1977, Formal Description of Programming Concepts.

[25]  Anders Haraldsson.  A program manipulation system based on partial evaluation , 1977 .

[26]  John Darlington,et al.  A Transformation System for Developing Recursive Programs , 1977, J. ACM.

[27]  Andrei P. Ershov,et al.  Mixed computation in the class of recursive program schemata , 1978, Acta Cybern..

[28]  Robin Milner,et al.  A Theory of Type Polymorphism in Programming , 1978, J. Comput. Syst. Sci..

[29]  Brian W. Kernighan,et al.  The C Programming Language , 1978 .

[30]  Anders Haraldsson,et al.  A partial evaluator, and its use for compiling iterative statements in LISP , 1978, POPL.

[31]  Murray Hill,et al.  Yacc: Yet Another Compiler-Compiler , 1978 .

[32]  V. F. Turchin,et al.  A supercompiler system based on the language REFAL , 1979, SIGP.

[33]  William L. Scherlis,et al.  Expression procedures and program derivation , 1980 .

[34]  Anders Haraldsson,et al.  On compiling embedded languages in LISP , 1980, LISP Conference.

[35]  Valentin F. Turchin,et al.  The Use of Metasystem Transition in Theorem Proving and Program Optimization , 1980, ICALP.

[36]  Marie-Claude Gaudel.  Specification of compilers as abstract data type representations , 1980, Semantics-Directed Compiler Generation.

[37]  Valentin F. Turchin,et al.  Semantic definitions in REFAL and the automatic production of compilers , 1980, Semantics-Directed Compiler Generation.

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

[39]  Neil D. Jones.  Compiler Generation from Denotational Semantics , 1980 .

[40]  Pär Emanuelson,et al.  Performance enhancement in a well-structured pattern matcher through partial evaluation , 1980 .

[41]  Frank G. Pagan,et al.  On the Generation of Compilers from Language Definitions , 1980, Inf. Process. Lett..

[42]  Henryk Jan Komorowski,et al.  A specification of an abstract Prolog machine and its application to partial evaluation , 1981 .

[43]  Joseph E. Stoy,et al.  Denotational Semantics: The Scott-Strachey Approach to Programming Language Theory , 1981 .

[44]  David A. Schmidt.  Compiler generation from lambda calculus definitions of programming languages , 1981 .

[45]  William L. Scherlis,et al.  Program improvement by internal specialization , 1981, POPL '81.

[46]  Patrick Cousot,et al.  Semantic foundations of program analysis , 1981 .

[47]  Alan Mycroft,et al.  Abstract interpretation and optimising transformations for applicative programs , 1982 .

[48]  Andrei P. Ershov,et al.  Mixed Computation: Potential Applications and Problems for Study , 1982, Theor. Comput. Sci..

[49]  Yoshihiko Futamura,et al.  Parital Computation of Programs , 1982, RIMS Symposium on Software Science and Engineering.

[50]  Valentin F. Turchin,et al.  Experiments with a supercompiler , 1982, LFP '82.

[51]  P. Emanuelson,et al.  From abstract model to efficient compilation of patterns , 1982, Symposium on Programming.

[52]  Kenneth M. Kahn,et al.  A Partial Evaluator of Lisp Programs Written in Prolog , 1982, ICLP.

[53]  Henning Christiansen,et al.  Control Flow Treatment in a Simple Semantics-Directed Compiler Generator , 1982, Formal Description of Programming Concepts.

[54]  Chris Goad,et al.  Automatic Construction of Special Purpose Programs , 1982, CADE.

[55]  Jan Komorowski,et al.  Partial evaluation as a means for inferencing data structures in an applicative language: a theory and implementation in the case of prolog , 1982, POPL '82.

[56]  Mitchell Wand,et al.  Deriving Target Code as a Representation of Continuation Semantics , 1982, TOPL.

[57]  Dana S. Scott,et al.  Lectures on a Mathematical Theory of Computation , 1982 .

[58]  Lawrence C. Paulson.  A semantics-directed compiler generator , 1982, POPL '82.

[59]  Uwe Kastens,et al.  GAG: A Practical Compiler Generator , 1982, Lecture Notes in Computer Science.

[60]  E. Szemerédi,et al.  Sorting inc logn parallel steps , 1983 .

[61]  R. Schooler,et al.  PARTIAL EVALUATION AS A MEANS OF LANGUAGE EXTENSIBILITY , 1984 .

[62]  Uwe F. Pleban.  Compiler prototyping using formal semantics , 1984, SIGPLAN '84.

[63]  Raf Venken.  A Prolog Meta-Interpreter for Partial Evaluation and its Application to Source to Source Transformation and Query-Optimisation , 1984, ECAI.

[64]  Mats Carlsson,et al.  The Compilation of Prolog Programs without the Use of a Prolog Compiler , 1984, Fifth Generation Computer Systems.

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

[66]  Mitchell Wand.  From interpreter to compiler: a representational derivation , 1985, Programs as Data Objects.

[67]  Lennart Augustsson,et al.  Compiling Pattern Matching , 1985, FPCA.

[68]  Daniel M. Berry,et al.  Deriving a Compiler From an Operational Semantics Written in VDL , 1985, Comput. Lang..

[69]  Valentin F. Turchin,et al.  Program transformation by supercompilation , 1985, Programs as Data Objects.

[70]  Peter Sestoft,et al.  The structure of a self-applicable partial evaluator , 1985, Programs as Data Objects.

[71]  William L. Scherlis,et al.  Compilers and staging transformations , 1986, POPL '86.

[72]  Valentin F. Turchin,et al.  The concept of a supercompiler , 1986, TOPL.

[73]  John P. Gallagher,et al.  Transforming Logic Programs by Specialising Interpreters , 1986, ECAI.

[74]  Bruno Courcelle,et al.  Equivalences and Transformations of Regular Systems-Applications to Recursive Program Schemes and Grammars , 1986, Theor. Comput. Sci..

[75]  L Kott,et al.  Unfold/fold program transformations , 1986 .

[76]  Akikazu Takeuchi,et al.  Partial Evaluation of Prolog Programs and its Application to Meta Programming , 1986, IFIP Congress.

[77]  A. P. Ershov.  On mixed computation: informal account of the strict and polyvariant computational schemes , 1986 .

[78]  Alfred V. Aho,et al.  Compilers: Principles, Techniques, and Tools , 1986, Addison-Wesley series in computer science / World student series edition.

[79]  Thomas J. Pennello,et al.  Very fast LR parsing , 1986, SIGPLAN '86.

[80]  Leon Sterling,et al.  Incremental Flavor-Mixing of Meta-Interpreters for Expert System Construction , 1986, SLP.

[81]  Gilles Kahn,et al.  Natural Semantics , 1987, STACS.

[82]  A. P. Ershov,et al.  Controlled mixed computation and its application to systematic development of language-oriented parsers , 1987 .

[83]  Peter Lee,et al.  A realistic compiler generator based on high-level semantics: another progress report , 1987, POPL '87.

[84]  Peter Sestoft,et al.  Automatic call unfolding in a partial evaluator , 1987 .

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

[86]  S. A. Romanenko,et al.  A compiler generator produced by a self-applicable specializer can have a surprisingly natural and u , 1988 .

[87]  Calton Pu,et al.  The Synthesis Kernel , 1988, Comput. Syst..

[88]  A. P. Ershov,et al.  A Formal Type System for Comparing Partial Evaluators , 1988 .

[89]  Mark Wallace,et al.  A Treatment of Negation during Partial Evaluation , 1989, META.

[90]  Ehud Shapiro,et al.  Meta interpreters for real , 1988 .

[91]  Stephen Owen,et al.  Issues in the Partial Evaluation of Meta-Interpreters , 1989, META.

[92]  Philip Wadler,et al.  When Will Deforestation Stop , 1988 .

[93]  Frank G. Pagan.  Converting interpreters into compilers , 1988, Softw. Pract. Exp..

[94]  Flemming Nielson,et al.  Automatic binding time analysis for a typed λ-calculus , 1988, POPL '88.

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

[96]  Alan Bundy,et al.  Explanation-Based Generalisation = Partial Evaluation , 1988, Artif. Intell..

[97]  Charles Consel,et al.  New Insights into Partial Evaluation: the SCHISM Experiment , 1988, ESOP.

[98]  Torben Æ. Mogensen.  Separating binding times in language specifications , 1989, FPCA.

[99]  Flemming Nielson,et al.  Transformations on higher-order functions , 1989, FPCA.

[100]  Leon Sterling,et al.  Metainterpreters for Expert System Construction , 1989, J. Log. Program..

[101]  Peter Lee.  Realistic compiler generation , 1989, Foundations of Computing Series.

[102]  Neil D. Jones,et al.  Compiler generation by partial evaluation , 1989 .

[103]  Charles Consel.  Analyse de programmes, evaluation partielle et generation de compilateurs , 1989 .

[104]  Flemming Nielson,et al.  Two-Level Semantics and Abstract Interpretation , 1989, Theor. Comput. Sci..

[105]  John Launchbury.  Dependent Sums Express Separation of Binding Times , 1989, Functional Programming.

[106]  Torben Æ. Mogensen.  Binding Time Analysis for Polymorphically Typed Higher Order Languages , 1989, TAPSOFT, Vol.2.

[107]  Philip Wadler,et al.  Theorems for free! , 1989, FPCA.

[108]  Frank G. Pagan.  Partial computation as a practical aid in the compiler construction course , 1989, SGCS.

[109]  John Launchbury,et al.  Projection factorisations in partial evaluation , 1991 .

[110]  Anne Rogers,et al.  Process decomposition through locality of reference , 1989, PLDI '89.

[111]  Olivier Danvy,et al.  Partial Evaluation of Pattern Matching in Strings , 1989, Inf. Process. Lett..

[112]  David Alfredo Fuller.  Partial evaluation and mix computation in logic programming , 1989 .

[113]  Peter Sestoft,et al.  Replacing function parameters by global variables , 1989, FPCA.

[114]  Michele Bugliesi,et al.  Partial Evaluation in Prolog: Some Improvements about Cut , 1989, NACLP.

[115]  Evelina Lamma,et al.  Partial Evaluation for Hierarchies of Logic Theories , 1990, NACLP.

[116]  Andrew A. Berlin,et al.  Partial evaluation applied to numerical computation , 1990, LISP and Functional Programming.

[117]  Leon Sterling,et al.  ProMiX: a Prolog partial evaluation system , 1990 .

[118]  John W. Lloyd,et al.  A Partial Evaluation Procedure for Logic Programs , 1990, NACLP.

[119]  Dan Sahlin,et al.  The Mixtus Approach to Automatic Partial Evaluation of Full Prolog , 1990, NACLP.

[120]  Peter D. Mosses,et al.  Denotational semantics , 1995, LICS 1995.

[121]  Anne Rogers,et al.  Compiler parallelization of SIMPLE for a distributed memory machine , 1990 .

[122]  Robin Milner,et al.  Definition of standard ML , 1990 .

[123]  Robert Glück,et al.  Application of metasystem transition to function inversion and transformation , 1990, ISSAC '90.

[124]  Wei-Ngan Chin,et al.  Automatic methods for program transformation , 1990 .

[125]  Anders Bondorf,et al.  Automatic Autoprojection of Higher Order Recursive Equations , 1990, Sci. Comput. Program..

[126]  Andrew A. Berlin,et al.  Compiling scientific code using partial evaluation , 1990, Computer.

[127]  Anders Bondorf,et al.  A self-applicable partial evaluator for the lambda calculus , 1990, Proceedings. 1990 International Conference on Computer Languages.

[128]  Mads Tofte.  Compiler Generators , 1990, EATCS.

[129]  Annalisa Bossi,et al.  A method for specializing logic programs , 1990, TOPL.

[130]  John P. Gallagher,et al.  Some low-level source transformations of logic programs , 1990 .

[131]  Sergei A. Romanenko.  Arity Raiser and its Use in Program Specialization , 1990, ESOP.

[132]  John Hughes,et al.  Towards Binding-Time Improvement for Free , 1990, Functional Programming.

[133]  Frank G. Pagan.  Partial Computation and the Construction of Language Processors , 1990 .

[134]  Jesper Jørgensen,et al.  Generating a Pattern Matching Compiler by Partial Evaluation , 1990, Functional Programming.

[135]  Frank G. Pagan.  Comparative efficiency of general and residual parsers , 1990, SIGP.

[136]  Carsten K. Gomard.  Partial type inference for untyped functional programs , 1990, LISP and Functional Programming.

[137]  Charles Consel,et al.  Binding time analysis for high order untyped functional languages , 1990, LISP and Functional Programming.

[138]  Olivier Danvy,et al.  Semantics-Directed Compilation of Nonlinear Patterns , 1991, Inf. Process. Lett..

[139]  Carsten Kehler Holst,et al.  Finiteness Analysis , 1991, Conference on Functional Programming Languages and Computer Architecture.

[140]  Björn Lisper.  Detecting static algorithms by partial evaluation , 1991 .

[141]  John Launchbury,et al.  A Strongly-Typed Self-Applicable Partial Evaluator , 1991, FPCA.

[142]  R. S. Sundaresh,et al.  Building incremental programs using partial evaluation , 1991, PEPM '91.

[143]  Flemming Nielson,et al.  Using transformations in the implementation of higher-order functions , 1990, Journal of Functional Programming.

[144]  David Sands,et al.  Binding time analysis: a new PERspective , 1991, PEPM '91.

[145]  Donald A. Smith,et al.  Partial evaluation of pattern matching in constraint logic programming languages , 1991, PEPM '91.

[146]  Olivier Danvy,et al.  Static and dynamic semantics processing , 1991, POPL '91.

[147]  Karel De Vlaminck,et al.  Partial Evaluation of Polymorphically Typed Functional Languages: the Representation Problem , 1991, JTASPEFT/WSA.

[148]  Fritz Henglein,et al.  Efficient Type Inference for Higher-Order Binding-Time Analysis , 1991, FPCA.

[149]  Anders Bondorf,et al.  Automatic Autoprojection of Recursive Equations with Global Variables and Abstract Data Types , 1991, Sci. Comput. Program..

[150]  David James Sherman,et al.  Optimization of equational programs using partial evaluation , 1991, PEPM '91.

[151]  Daniel Weise,et al.  Generating Compiled Simulations Using Partial Evaluation , 1991 .

[152]  Carsten Kehler Holst,et al.  Partial evaluation is fuller laziness , 1991, PEPM '91.

[153]  John Hannan.  Staging Transformations for Abstract Machines , 1991, PEPM.

[154]  Erik Ruf,et al.  Automatic Online Partial Evaluation , 1991, FPCA.

[155]  Siau-Cheng Khoo,et al.  Semantics-Directed Generation of a Prolog Compiler , 1991, Sci. Comput. Program..

[156]  Neil D. Jones,et al.  A partial evaluator for the untyped lambda-calculus , 1991, Journal of Functional Programming.

[157]  John Launchbury,et al.  Strictness and binding-time analyses: two for the price of one , 1991, PLDI '91.

[158]  Uwe Meyer,et al.  Techniques for partial evaluation of imperative languages , 1991, PEPM '91.

[159]  Olivier Danvy,et al.  For a Better Support of Static Data Flow , 1991, FPCA.

[160]  Siau-Cheng Khoo,et al.  Compiling inheritance using partial evaluation , 1991 .

[161]  John W. Lloyd,et al.  Partial Evaluation in Logic Programming , 1991, J. Log. Program..

[162]  Torben Amtoft Hansen.  Properties of Unfolding-based Meta-level Systems , 1991 .

[163]  Paul Hudak,et al.  Collecting interpretations of expressions , 1991, TOPL.

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

[165]  Olivier Danvy,et al.  Partial evaluation in parallel , 1992, LISP Symb. Comput..

[166]  Torben Æ. Mogensen.  Self-applicable Partial Evaluation for Pure Lambda Calculus , 1992, PEPM.

[167]  Lars Ole Andersen,et al.  Self-applicable C Program Specialization , 1992, PEPM.

[168]  David A. Fuller,et al.  Extending partial evaluation in logic programming , 1992 .

[169]  Erik Ruf,et al.  Preserving Information during Online Partial Evaluation , 1992 .

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

[171]  Dale Miller,et al.  From operational semantics to abstract machines , 1992, Mathematical Structures in Computer Science.

[172]  Jesper Jørgensen,et al.  Generating a compiler for a lazy language by partial evaluation , 1992, POPL '92.

[173]  Anders Bondorf,et al.  Logimix: A Self-Applicable Partial Evaluator for Prolog , 1992, LOPSTR.

[174]  Bernhard Rytz,et al.  A Polyvariant Binding Time Analysis , 1992, PEPM.

[175]  Flemming Nielson,et al.  Two-level functional languages , 1992, Cambridge tracts in theoretical computer science.

[176]  Lars Ole Andersen.  Partial Evaluation of C and Automatic Compiler Generation (Extended Abstract) , 1992, CC.

[177]  Denis Béchet.  Partial Evaluation of Interaction Nets , 1992, WSA.

[178]  Carsten K. Gomard,et al.  Speedup Analysis in Partial Evaluation: Preliminary Results , 1992, PEPM.

[179]  Raman Srinivas Sundaresh.  Incremental computation via partial evaluation , 1992 .

[180]  Erik Ruf,et al.  Opportunities for Online Partial Evaluation , 1992 .

[181]  William Pugh,et al.  Partial evaluation of high-level imperative programming languages with applications in hard real-time systems , 1992, POPL '92.

[182]  Anders Bondorf,et al.  Improving binding times without explicit CPS-conversion , 1992, LFP '92.

[183]  Carsten K. Gomard.  A self-applicable partial evaluator for the lambda calculus: correctness and pragmatics , 1992, TOPL.

[184]  Erik Ruf,et al.  On the specialization of online program specializers , 1992, Journal of Functional Programming.

[185]  Olivier Danvy,et al.  Tutorial notes on partial evaluation , 1993, POPL '93.

[186]  Erik Ruf.  Topics in online partial evaluation , 1993 .

[187]  Lars Ole Andersen.  Binding-time analysis and the taming of C pointers , 1993, PEPM '93.

[188]  Lockwood Morris.  The next 700 formal language descriptions , 1993, LISP Symb. Comput..

[189]  Mitchell Wand,et al.  Specifying the correctness of binding-time analysis , 1993, POPL '93.

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