A syntactic theory of sequential state
Theoretical Computer Science
On laziness and optimality in lambda interpreters: tools for specification and analysis
POPL '90 Proceedings of the 17th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
An algorithm for optimal lambda calculus reduction
POPL '90 Proceedings of the 17th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
The spineless tagless G-machine
FPCA '89 Proceedings of the fourth international conference on Functional programming languages and computer architecture
Parameter-passing and the lambda calculus
POPL '91 Proceedings of the 18th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Optimal derivations in weak lambda-calculi and in orthogonal term rewriting systems
POPL '91 Proceedings of the 18th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
The revised report on the syntactic theories of sequential control and state
Theoretical Computer Science
The geometry of optimal lambda reduction
POPL '92 Proceedings of the 19th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A natural semantics for lazy evaluation
POPL '93 Proceedings of the 20th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Handbook of logic in computer science (vol. 2)
Optimal reduction in weak-&lgr;-calculus with shared environments
FPCA '93 Proceedings of the conference on Functional programming languages and computer architecture
From λσ to λν: a journey through calculi of explicit substitutions
POPL '94 Proceedings of the 21st ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Call-by-need and continuation-passing style
Lisp and Symbolic Computation
A call-by-need lambda calculus
POPL '95 Proceedings of the 22nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Properties of a first-order functional language with sharing
Theoretical Computer Science
Abstract models of memory management
FPCA '95 Proceedings of the seventh international conference on Functional programming languages and computer architecture
An Adequate Operational Semantics for Sharing in Lazy Evaluation
ESOP '92 Proceedings of the 4th European Symposium on Programming
Super-combinators a new implementation method for applicative languages
LFP '82 Proceedings of the 1982 ACM symposium on LISP and functional programming
POPL '76 Proceedings of the 3rd ACM SIGACT-SIGPLAN symposium on Principles on programming languages
The Implementation of Functional Programming Languages (Prentice-Hall International Series in Computer Science)
Monadic state: axiomatization and type safety
ICFP '97 Proceedings of the second ACM SIGPLAN international conference on Functional programming
Correctness of monadic state: an imperative call-by-need calculus
POPL '98 Proceedings of the 25th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A non-deterministic call-by-need lambda calculus
ICFP '98 Proceedings of the third ACM SIGPLAN international conference on Functional programming
Improvement in a lazy context: an operational theory for call-by-need
Proceedings of the 26th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
From Syntactic Theories to Interpreters: Automating the Proof of Unique Decomposition
Higher-Order and Symbolic Computation
Eager Haskell: resource-bounded execution yields efficient iteration
Proceedings of the 2002 ACM SIGPLAN workshop on Haskell
Erratic fudgets: a semantic theory for an embedded coordination language
Science of Computer Programming - Special issue on coordination languages and architectures
A Calculus for Link-Time Compilation
ESOP '00 Proceedings of the 9th European Symposium on Programming Languages and Systems
Erratic Fudgets: A Semantic Theory for an Embedded Coordination Language
COORDINATION '99 Proceedings of the Third International Conference on Coordination Languages and Models
Demonstrating lambda calculus reduction
The essence of computation
Uniform confluence in concurrent computation
Journal of Functional Programming
A calculus with polymorphic and polyvariant flow types
Journal of Functional Programming
What is a purely functional language?
Journal of Functional Programming
Call-by-need in token-passing nets
Mathematical Structures in Computer Science
A concurrent lambda calculus with futures
Theoretical Computer Science - Applied semantics
Infinite Unfolding and Transformations of Nondeterministic Programs
Fundamenta Informaticae - Program Transformation: Theoretical Foundations and Basic Techniques. Part 1
Fundamenta Informaticae - Program Transformation: Theoretical Foundations and Basic Techniques. Part 2
A calculus of open modules: call-by-need strategy and confluence
Mathematical Structures in Computer Science
Explaining the lazy Krivine machine using explicit substitution and addresses
Higher-Order and Symbolic Computation
Closing the stage: from staged code to typed closures
PEPM '08 Proceedings of the 2008 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation
ACM Transactions on Programming Languages and Systems (TOPLAS)
Complete Laziness: a Natural Semantics
Electronic Notes in Theoretical Computer Science (ENTCS)
Minimality in a Linear Calculus with Iteration
Electronic Notes in Theoretical Computer Science (ENTCS)
Lazy evaluation and delimited control
Proceedings of the 36th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A flexible framework for programming with non-deterministicfunctions
Proceedings of the 2009 ACM SIGPLAN workshop on Partial evaluation and program manipulation
Purely functional lazy non-deterministic programming
Proceedings of the 14th ACM SIGPLAN international conference on Functional programming
Congruence of Bisimulation in a Non-Deterministic Call-By-Need Lambda Calculus
Electronic Notes in Theoretical Computer Science (ENTCS)
A Calculus for Reconfiguration
Electronic Notes in Theoretical Computer Science (ENTCS)
Small-step and big-step semantics for call-by-need
Journal of Functional Programming
Similarity implies equivalence in a class of non-deterministic call-by-need lambda calculi
Information and Computation
On generic context lemmas for higher-order calculi with sharing
Theoretical Computer Science
Journal of Visual Languages and Computing
Diagrams for meaning preservation
RTA'03 Proceedings of the 14th international conference on Rewriting techniques and applications
Correctness of copy in calculi with letrec
RTA'07 Proceedings of the 18th international conference on Term rewriting and applications
Mixin modules for dynamic rebinding
TGC'05 Proceedings of the 1st international conference on Trustworthy global computing
Three syntactic theories for combinatory graph reduction
LOPSTR'10 Proceedings of the 20th international conference on Logic-based program synthesis and transformation
Classical call-by-need and duality
TLCA'11 Proceedings of the 10th international conference on Typed lambda calculi and applications
Evaluating call-by-need on the control stack
TFP'10 Proceedings of the 11th international conference on Trends in functional programming
A unified approach to fully lazy sharing
POPL '12 Proceedings of the 39th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Purely functional lazy nondeterministic programming
Journal of Functional Programming - Dedicated to ICFP 2009
A concurrent lambda calculus with futures
FroCoS'05 Proceedings of the 5th international conference on Frontiers of Combining Systems
Skew and ω-skew confluence and abstract Böhm semantics
Processes, Terms and Cycles
Defunctionalized interpreters for call-by-need evaluation
FLOPS'10 Proceedings of the 10th international conference on Functional and Logic Programming
A semantics for context-sensitive reduction semantics
APLAS'11 Proceedings of the 9th Asian conference on Programming Languages and Systems
Theoretical Computer Science
The call-by-need lambda calculus, revisited
ESOP'12 Proceedings of the 21st European conference on Programming Languages and Systems
Classical call-by-need sequent calculi: the unity of semantic artifacts
FLOPS'12 Proceedings of the 11th international conference on Functional and Logic Programming
A Constructive Proof of Dependent Choice, Compatible with Classical Logic
LICS '12 Proceedings of the 2012 27th Annual IEEE/ACM Symposium on Logic in Computer Science
Automatic amortised analysis of dynamic memory allocation for lazy functional programs
Proceedings of the 17th ACM SIGPLAN international conference on Functional programming
Fundamenta Informaticae - Program Transformation: Theoretical Foundations and Basic Techniques. Part 2
Infinite Unfolding and Transformations of Nondeterministic Programs
Fundamenta Informaticae - Program Transformation: Theoretical Foundations and Basic Techniques. Part 1
Asynchronous functional reactive programming for GUIs
Proceedings of the 34th ACM SIGPLAN conference on Programming language design and implementation
A synthetic operational account of call-by-need evaluation
Proceedings of the 15th Symposium on Principles and Practice of Declarative Programming
Three syntactic theories for combinatory graph reduction
ACM Transactions on Computational Logic (TOCL)
Atomic Lambda Calculus: A Typed Lambda-Calculus with Explicit Sharing
LICS '13 Proceedings of the 2013 28th Annual ACM/IEEE Symposium on Logic in Computer Science
Hi-index | 0.00 |
Plotkin (1975) showed that the lambda calculus is a good model of the evaluation process for call-by-name functional programs. Reducing programs to constants or lambda abstractions according to the leftmost-outermost strategy exactly mirrors execution on an abstract machine like Landin's SECD machine. The machine-based evaluator returns a constant or the token closure if and only if the standard reduction sequence starting at the same program will end in the same constant or in some lambda abstraction. However, the calculus does not capture the sharing of the evaluation of arguments that lazy implementations use to speed up the execution. More precisely, a lazy implementation evaluates procedure arguments only when needed and then only once. All other references to the formal procedure parameter re-use the value of the first argument evaluation. The mismatch between the operational semantics of the lambda calculus and the actual behavior of the prototypical implementation is a major obstacle for compiler writers. Unlike implementors of the leftmost-outermost strategy or of a call-by-value language, implementors of lazy systems cannot easily explain the behavior of their evaluator in terms of source level syntax. Hence, they often cannot explain why a certain syntactic transformation ‘works’ and why another doesn't. In this paper we develop an equational characterization of the most popular lazy implementation technique – traditionally called ‘call-by-need’ – and prove it correct with respect to the original lambda calculus. The theory is a strictly smaller theory than Plotkin's call-by-name lambda calculus. Immediate applications of the theory concern the correctness proofs of a number of implementation strategies, e.g. the call-by-need continuation passing transformation and the realization of sharing via assignments. Some of this material first appeared in a paper presented at the 1995 ACM Conference on the Principles of Programming Languages. The paper was a joint effort with Maraist, Odersky and Wadler, who had independently developed a different equational characterization of call-by-need. We contrast our work with that of Maraist et al. in the body of this paper where appropriate.