A computational formalization for partial evaluation

We formalize a partial evaluator for Eugenio Moggi's computational metalanguage. This formalization gives an evaluation-order independent view of binding-time analysis and program specialization, including a proper treatment of call unfolding. It also enables us to express the essence of ‘control-based binding-time improvements’ for let expressions. Specifically, we prove that the binding-time improvements given by ‘continuation-based specialization’ can be expressed in the metalanguage via monadic laws.

[1]  Paul Hudak,et al.  Monad transformers and modular interpreters , 1995, POPL '95.

[2]  Philip Wadler,et al.  A reflection on call-by-value , 1997, TOPL.

[3]  Frank Pfenning,et al.  A modal analysis of staged computation , 1996, POPL '96.

[4]  Peter Thiemann.  Cogen in six lines , 1996, ICFP '96.

[5]  Neil D. Jones,et al.  Mix: A self-applicable partial evaluator for experiments in compiler generation , 1989, LISP Symb. Comput..

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

[7]  Jens Palsberg,et al.  Correctness of binding-time analysis , 1993, Journal of Functional Programming.

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

[9]  Roy L. Crole,et al.  Factoring an Adequacy Proof (Preliminary Report) , 1993, Functional Programming.

[10]  Devdatt P. Dubhashi,et al.  Negative dependence through the FKG Inequality , 1996 .

[11]  Robert Glück,et al.  Occam's Razor in Metacompuation: the Notion of a Perfect Process Tree , 1993, WSA.

[12]  Lars Arge,et al.  The I/O - Complexity of Ordered Binary - Decision Diagram Manipulation , 1995, ISAAC.

[13]  Lars Arge,et al.  The Buuer Tree: a New Technique for Optimal I/o-algorithms ? , 1995 .

[14]  P. S. Thiagarajan,et al.  Regular Trace Event Structures , 1996 .

[15]  Andrew Donald Gordon,et al.  Functional programming and input/output , 1995 .

[16]  Dale Miller,et al.  Deriving Mixed Evaluation from Standard Evaluation for a Simple Functional Language , 1989, MPC.

[17]  Peter Nicholas Benton,et al.  Strictness analysis of lazy functional programs , 1992 .

[18]  Carl A. Gunter.  Semantics of programming languages: structures and techniques , 1993, Choice Reviews Online.

[19]  Carolyn L. Talcott.  A Theory for Program and Data Type Specification , 1992, Theor. Comput. Sci..

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

[21]  Ian Stark.  Names, Equations, Relations: Practical Ways to Reason about new , 1997, TLCA.

[22]  Jens Palsberg,et al.  Eta-expansion does The Trick , 1995, TOPL.

[23]  Peter Bro Miltersen,et al.  Fusion Trees can be Implemented with AC0 Instructions Only , 1999, Theor. Comput. Sci..

[24]  Amr Sabry,et al.  Is continuation-passing useful for data flow analysis? , 1994, PLDI '94.

[25]  Olivier Danvy,et al.  A generic account of continuation-passing styles , 1994, POPL '94.

[26]  Nick Benton,et al.  Computational types from a logical perspective , 1998, Journal of Functional Programming.

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

[28]  Jeffrey Shallit,et al.  The Computational Complexity of Some Problems of Linear Algebra , 1996, J. Comput. Syst. Sci..

[29]  Robert Glück,et al.  Efficient Multi-level Generating Extensions for Program Specialization , 1995, PLILP.

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

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

[32]  Olivier Danvy,et al.  Continuation-based partial evaluation , 1994, LFP '94.

[33]  David Sands.  Proving the Correctness of Recursion-Based Automatic Program Transformations , 1995, TAPSOFT.

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

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

[36]  Roy L. Crole,et al.  New Foundations for Fixpoint Computations: FIX-Hyperdoctrines and the FIX-Logic , 1992, Inf. Comput..

[37]  Andrzej Filinski,et al.  Representing monads , 1994, POPL '94.

[38]  Christine Paulin-Mohring,et al.  Synthesis of ML Programs in the System Coq , 1993, J. Symb. Comput..

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

[40]  Morten Heine Sørensen,et al.  Call-By-Name CPS-Translation as a Binding-Time Improvement , 1995, SAS.

[41]  Charles Consel,et al.  A tour of Schism: a partial evaluation system for higher-order applicative languages , 1993, PEPM '93.

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

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

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

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

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

[47]  Amr Sabry,et al.  The essence of compiling with continuations , 1993, PLDI '93.

[48]  J. Girard,et al.  Proofs and types , 1989 .

[49]  David Sands,et al.  Proving the Correctness of Recursion-Based Automatic Program Transformations , 1995, Theor. Comput. Sci..

[50]  Philip Wadler,et al.  The essence of functional programming , 1992, POPL '92.

[51]  Anders Bondorf,et al.  Improving CPS-Based Partial Evaluation: Writing Cogen by Hand , 1994, PEPM.

[52]  John Hatcliff,et al.  Mechanically Verifying the Correctness of an Offline Partial Evaluator , 1995, PLILP.

[53]  Olivier Danvy,et al.  A Computational Formalization for Partial Evaluation (Extended Version) , 1996 .

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

[55]  Peter Sestoft,et al.  Partial evaluation and automatic program generation , 1993, Prentice Hall international series in computer science.

[56]  John Hatcliff,et al.  The structure of continuation-passing styles , 1995 .

[57]  Jens Palsberg,et al.  The essence of eta-expansion in partial evaluation , 1994, LISP Symb. Comput..

[58]  Guy L. Steele,et al.  Building interpreters by composing monads , 1994, POPL '94.

[59]  Robert Glück,et al.  Towards Unifying Partial Evaluation, Deforestation, Supercompilation, and GPC , 1994, ESOP.

[60]  Olivier Danvy,et al.  Type-directed partial evaluation , 1995, POPL '96.

[61]  Olivier Danvy,et al.  CPS-transformation after strictness analysis , 1992, LOPL.

[62]  Philip Wadler,et al.  Comprehending monads , 1990, Mathematical Structures in Computer Science.

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

[64]  Flemming Nielson,et al.  Semantics with applications - a formal introduction , 1992, Wiley professional computing.

[65]  W. V. Quine,et al.  Natural deduction , 2021, An Introduction to Proof Theory.