Volume II: Parallel Languages on PARLE: Parallel Architectures and Languages Europe
TIM: A simple, lazy abstract machine to execute supercombinators
Proc. of a conference on Functional programming languages and computer architecture
A natural semantics for lazy evaluation
POPL '93 Proceedings of the 20th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A call-by-need lambda calculus
POPL '95 Proceedings of the 22nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A systematic study of functional language implementations
ACM Transactions on Programming Languages and Systems (TOPLAS)
Stackability in the simply-typed call-by-value lambda calculus
Science of Computer Programming
Abstract machines for programming language implementation
Future Generation Computer Systems
Communication and Concurrency
Definitional Interpreters Revisited
Higher-Order and Symbolic Computation
Definitional interpreters for higher-order programming languages
ACM '72 Proceedings of the ACM annual conference - Volume 2
POPL '76 Proceedings of the 3rd ACM SIGACT-SIGPLAN symposium on Principles on programming languages
A functional correspondence between evaluators and abstract machines
Proceedings of the 5th ACM SIGPLAN international conference on Principles and practice of declaritive programming
HAKMEM
The call-by-need lambda calculus
Journal of Functional Programming
Functional runtime systems within the lambda-sigma calculus
Journal of Functional Programming
Deriving a lazy abstract machine
Journal of Functional Programming
The call-by-need lambda calculus
Journal of Functional Programming
A functional correspondence between call-by-need evaluators and lazy abstract machines
Information Processing Letters
Lightweight fusion by fixed point promotion
Proceedings of the 34th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A syntactic correspondence between context-sensitive calculi and abstract machines
Theoretical Computer Science
A concrete framework for environment machines
ACM Transactions on Computational Logic (TOCL)
A call-by-name lambda-calculus machine
Higher-Order and Symbolic Computation
Improving the lazy Krivine machine
Higher-Order and Symbolic Computation
Strongly reducing variants of the Krivine abstract machine
Higher-Order and Symbolic Computation
Information Processing Letters
Lazy evaluation and delimited control
Proceedings of the 36th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Small-step and big-step semantics for call-by-need
Journal of Functional Programming
Semantics Engineering with PLT Redex
Semantics Engineering with PLT Redex
From reduction-based to reduction-free normalization
AFP'08 Proceedings of the 6th international conference on Advanced functional programming
A systematic derivation of the STG machine verified in Coq
Proceedings of the third ACM Haskell symposium on Haskell
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
IFL'10 Proceedings of the 22nd international conference on Implementation and application of functional languages
A unified approach to fully lazy sharing
POPL '12 Proceedings of the 39th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
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
Hi-index | 0.00 |
We present the first operational account of call by need that connects syntactic theory and implementation practice. Syntactic theory: the storeless operational semantics using syntax rewriting to account for demand-driven computation and for caching intermediate results. Implementational practice: the store-based operational technique using memo-thunks to implement demand-driven computation and to cache intermediate results for subsequent sharing. The implementational practice was initiated by Landin and Wadsworth and is prevalent today to implement lazy programming languages such as Haskell. The syntactic theory was initiated by Ariola, Felleisen, Maraist, Odersky and Wadler and is prevalent today to reason equationally about lazy programs, on par with Barendregt et al.'s term graphs. Nobody knows, however, how the theory of call by need compares to the practice of call by need: all that is known is that the theory of call by need agrees with the theory of call by name, and that the practice of call by need optimizes the practice of call by name. Our operational account takes the form of three new calculi for lazy evaluation of lambda-terms and our synthesis takes the form of three lock-step equivalences. The first calculus is a hereditarily compressed variant of Ariola et al.'s call-by-need lambda-calculus and makes "neededness" syntactically explicit. The second calculus distinguishes between strict bindings (which are induced by demand-driven computation) and non-strict bindings (which are used for caching intermediate results). The third calculus uses memo-thunks and an algebraic store. The first calculus syntactically corresponds to a storeless abstract machine, the second to an abstract machine with local stores, and the third to a lazy Krivine machine, i.e., a traditional store-based abstract machine implementing lazy evaluation. The machines are intensionally compatible with extensional reasoning about lazy programs and they are lock-step equivalent. Each machine functionally corresponds to a natural semantics for call by need in the style of Launchbury, though for non-preprocessed λ-terms. Our results reveal a genuine and principled unity of computational theory and computational practice, one that readily applies to variations on the general theme of call by need.