Conception, evolution, and application of functional programming languages
ACM Computing Surveys (CSUR)
An algorithm for optimal lambda calculus reduction
POPL '90 Proceedings of the 17th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Let-floating: moving bindings to give faster programs
Proceedings of the first ACM SIGPLAN international conference on Functional programming
Optimality and inefficiency: what isn't a cost model of the lambda calculus?
Proceedings of the first ACM SIGPLAN international conference on Functional programming
Disposable memo functions (extended abstract)
ICFP '97 Proceedings of the second ACM SIGPLAN international conference on Functional programming
Term rewriting and all that
Software—Practice & Experience
On programming of arithmetic operations
Communications of the ACM
Anatomy of LISP
Compiling language definitions: the ASF+SDF compiler
ACM Transactions on Programming Languages and Systems (TOPLAS)
Unlimp, Uniqueness as a Leitmotiv for Implementation
PLILP '92 Proceedings of the 4th International Symposium on Programming Language Implementation and Logic Programming
Imposing a Memory Management Discipline on Software Deployment
Proceedings of the 26th International Conference on Software Engineering
The Implementation of Functional Programming Languages (Prentice-Hall International Series in Computer Science)
Type-safe modular hash-consing
Proceedings of the 2006 workshop on ML
ATerms for manipulation and exchange of structured data: It's all about sharing
Information and Software Technology
Nixos: A purely functional linux distribution
Journal of Functional Programming
| Hi-index | 0.00 |
In lazy functional languages, any variable is evaluated at most once. This paper proposes the notion of maximal laziness, in which syntactically equal terms are evaluated at most once: if two terms e"1 and e"2 arising during the evaluation of a program have the same abstract syntax representation, then only one will be evaluated, while the other will reuse the former's evaluation result. Maximal laziness can be implemented easily in interpreters for purely functional languages based on term rewriting systems that have the property of maximal sharing - if two terms are equal, they have the same address. It makes it easier to write interpreters, as techniques such as closure updating, which would otherwise be required for efficiency, are not needed. Instead, a straight-forward translation of call-by-name semantic rules yields a call-by-need interpreter, reducing the gap between the language specification and its implementation. Moreover, maximal laziness obviates the need for optimisations such as memoisation and let-floating.