Lazy rewriting on eager machinery

The article introduces a novel notion of lazy rewriting. By annotating argument positions as lazy, redundant rewrite steps are avoided, and the termination behavior of a term-rewriting system can be improved. Some transformations of rewrite rules enable an implementation using the same primitives as an implementation of eager rewriting.

[1]  Simon L. Peyton Jones,et al.  The spineless tagless G-machine , 1989, FPCA.

[2]  H. R. Walters,et al.  Minimal Term Rewriting Systems , 1995, COMPASS/ADT.

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

[4]  Jacques Cohen,et al.  Garbage Collection of Linked Data Structures , 1981, CSUR.

[5]  Thomas Johnsson.  Efficient compilation of lazy evaluation , 1984, SIGP.

[6]  Daniel P. Friedman,et al.  CONS Should Not Evaluate its Arguments , 1976, ICALP.

[7]  Richard Kennaway.  The Specificity Rule for Lazy Pattern-Matching in Ambiguous Term Rewrite Systems , 1990, ESOP.

[8]  Jan Willem Klop,et al.  Term Graph Rewriting , 1995, HOA.

[9]  Jon Fairbairn,et al.  TIM: A simple, lazy abstract machine to execute supercombinatorics , 1987, FPCA.

[10]  Irène Durand,et al.  Constructor Equivalent Term Rewriting Systems , 1993, Inf. Process. Lett..

[11]  Enno Ohlebusch,et al.  Term Rewriting Systems , 2002 .

[12]  William D. Clinger,et al.  Revised3 report on the algorithmic language scheme , 1986, SIGP.

[13]  Irène Durand.  Bounded, Strongly Sequential and Forward-Branching Term Rewriting Systems , 1994, J. Symb. Comput..

[14]  Kazuhiro Ogata,et al.  Implementation of Term Rewritings with the Evaluation Strategy , 1997, PLILP.

[15]  Peter Zilahy Ingerman,et al.  Thunks: a way of compiling procedure statements with some comments on procedure declarations , 1961, CACM.

[16]  Albert Gräf,et al.  Left-to-Right Tree Pattern Matching , 1991, RTA.

[17]  Robert Strandh.  Optimizing Equational Programs , 1987, RTA.

[18]  Torben Amtoft.  Minimal Thunkification , 1993, WSA.

[19]  Jon Fairbairn,et al.  Non-Strict Languages - Programming and Implementation , 1989, Comput. J..

[20]  Thierry Heuillard.  Compiling Conditional Rewriting Systems , 1987, CTRS.

[21]  H. R. Walters,et al.  ARM abstract rewriting machine , 1993 .

[22]  Geoffrey L. Burn,et al.  Lazy functional languages - abstract interpretation and compilation , 1991, Research monographs in parallel and distributed computing.

[23]  Jan Willem Klop,et al.  On the adequacy of graph rewriting for simulating term rewriting , 1994, TOPL.

[24]  Christoph M. Hoffmann,et al.  Pattern Matching in Trees , 1982, JACM.

[25]  Richard S. Bird,et al.  More haste, less speed: lazy versus eager evaluation , 1997, Journal of Functional Programming.

[26]  Marko C. J. D. van Eekelen,et al.  CLEAN: A language for functional graph writing , 1987, FPCA.

[27]  Robert Strandh,et al.  Efficient Simulation of Forward-Branching Systems with Constructor Systems , 1996, J. Symb. Comput..

[28]  Salvador Lucas,et al.  Fundamentals of Context=Sensitive Rewriting , 1995, SOFSEM.

[29]  Thomas Johnsson,et al.  Parallel graph reduction with the (v , G)-machine , 1989, FPCA.

[30]  Michael J. O’Donnell.  Introduction: Logic and Logic Programming Languages , 1998 .

[31]  Alan Mycroft,et al.  The Theory and Practice of Transforming Call-by-need into Call-by-value , 1980, Symposium on Programming.

[32]  Rachid Echahed,et al.  Abstract Rewriting , 1993, WSA.

[33]  Tobias Nipkow,et al.  Term rewriting and all that , 1998 .

[34]  Rakesh M. Verma.  Transformations and Confluence for Rewrite Systems , 1995, Theor. Comput. Sci..

[35]  Nick Benton,et al.  Strictness Properties of Lazy Algebraic Datatypes , 1993, WSA.

[36]  Corrado Moiso,et al.  An Algorithm for Unification in Equational Theories , 1986, SLP.

[37]  Mitchell Wand,et al.  Selective Thunkification , 1994, SAS.

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

[39]  Paul Chew,et al.  An improved algorithm for computing with equations , 1980, 21st Annual Symposium on Foundations of Computer Science (sfcs 1980).

[40]  J. R. Kennaway,et al.  The adequacy of term graph rewriting for simulating term rewriting , 1993 .

[41]  Satish R. Thatte.  On the Correspondence Metween Two Classes of Reduction Systems , 1985, Inf. Process. Lett..

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

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

[44]  H. R. Walters,et al.  Lazy Rewriting and Eager Machinery , 1995, RTA.

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

[46]  Greg Nelson,et al.  Fast Decision Procedures Based on Congruence Closure , 1980, JACM.

[47]  Jan A. Bergstra,et al.  Term-Rewriting Systems with Rule Priorities , 1989, Theor. Comput. Sci..

[48]  Mark P. Jones,et al.  The implementation of the Gofer functional programming system , 1994 .

[49]  Robert Strandh.  Classes of Equational Programs that Compile into Efficient Machine Code , 1989, RTA.

[50]  R. I. Strandh.  Compiling equational programs into efficient machine code , 1988 .

[51]  FokkinkWan,et al.  Lazy rewriting on eager machinery , 2000 .

[52]  Michael J. O'Donnell,et al.  Computing in systems described by equations , 1977, Lecture Notes in Computer Science.

[53]  Henry G. Baker,et al.  CONS should not CONS its arguments, part II: Cheney on the M.T.A. , 1995, SIGP.

[54]  Wan Fokkink,et al.  Simulation as a Correct Transformation of Rewrite Systems , 1997, MFCS.

[55]  LiuChang.  Term rewriting and all that , 2000 .

[56]  Jean-Pierre Jouannaud,et al.  Rewrite Systems , 1991, Handbook of Theoretical Computer Science, Volume B: Formal Models and Sematics.

[57]  Satish R. Thatte.  Implementing First-Order Rewriting with Constructor Systems , 1988, Theor. Comput. Sci..

[58]  FokkinkWan,et al.  Within ARM's reach , 1998 .

[59]  Gérard Huet,et al.  The CAML primer , 1990 .

[60]  Michael J. O'Donnell,et al.  Equational Logic as a Programming Language , 1985, Logic of Programs.

[61]  G. Burn,et al.  Cps-translation and the Correctness of Optimising Compilers , 1992 .

[62]  John Field,et al.  On laziness and optimality in lambda interpreters: tools for specification and analysis , 1989, POPL '90.

[63]  J.F.Th. Kamperman,et al.  Compilation of Term Rewriting Systems , 1996 .

[64]  Peter Henderson,et al.  A lazy evaluator , 1976, POPL.

[65]  H. R. Walters,et al.  EPIC: An Equational Language -Abstract Machine Supporting Tools- , 1996, RTA.

[66]  I. V. Ramakrishnan,et al.  On the power and limitations of strictness analysis , 1997, JACM.

[67]  Thomas Johnsson,et al.  Efficient compilation of lazy evaluation , 1984, SIGPLAN '84.

[68]  Harold Abelson,et al.  Revised5 report on the algorithmic language scheme , 1998, SIGP.

[69]  H. D. Watson.  At 14 , 1979 .

[70]  Peter Lee,et al.  No assembly required: compiling standard ML to C , 1992, LOPL.

[71]  Rafael Dueire Lins,et al.  Benchmarking implementations of functional languages with ‘Pseudoknot’, a float-intensive benchmark , 1996, Journal of Functional Programming.

[72]  Marko C. J. D. van Eekelen,et al.  Functional Programming and Parallel Graph Rewriting , 1993 .

[73]  Wan Fokkink,et al.  Within ARM's reach: compilation of left-linear rewrite systems via minimal rewrite systems , 1997, TOPL.

[74]  Jan Willem Klop,et al.  Term Rewriting Systems: From Church-Rosser to Knuth-Bendix and Beyond , 1990, ICALP.

[75]  Pierre-Louis Curien,et al.  The Categorical Abstract Machine , 1987, Sci. Comput. Program..

[76]  Paul R. Wilson,et al.  Uniprocessor Garbage Collection Techniques , 1992, IWMM.

[77]  Robert Strandh,et al.  Optimization of Equational Programs Using Partial Evaluation , 1991, PEPM.

[78]  John McCarthy,et al.  Recursive functions of symbolic expressions and their computation by machine, Part I , 1960, Commun. ACM.

[79]  Stephen Wilson Bailey.  Help, a fast interactive lazy functional language system , 1995 .

[80]  H. R. Walters.  Epic and ARM -- user''s guide -- , 1997 .

[81]  Simon Peyton Jones,et al.  Implementing Functional Languages: a tutorial , 2000 .

[82]  Christoph M. Hoffmann,et al.  Programming with Equations , 1982, TOPL.

[83]  Jürgen Giesl,et al.  Transforming Context-Sensitive Rewrite Systems , 1999, RTA.

[84]  John Staples,et al.  Computation on Graph-Like Expressions , 1980, Theor. Comput. Sci..