Lazy evaluation and delimited control

@article{Garcia2009LazyEA,
  title={Lazy evaluation and delimited control},
  author={Ronald Garcia and Andrew Lumsdaine and Amr Sabry},
  journal={Log. Methods Comput. Sci.},
  year={2009},
  volume={6}
}
The call-by-need lambda calculus provides an equational framework for reasoning syntactically about lazy evaluation. This paper examines its operational characteristics. By a series of reasoning steps, we systematically unpack the standard-order reduction relation of the calculus and discover a novel abstract machine definition which, like the calculus, goes "under lambdas." We prove that machine evaluation is equivalent to standard-order evaluation. Unlike traditional abstract machines… 

Figures from this paper

Evaluating Call-by-Need on the Control Stack
TLDR
This paper shows how to translate the notion of reduction into an abstract machine that resolves variable references via the control stack, and uses the static address of a variable occurrence to extract its current value from the dynamic control stack.
The Call-by-need Lambda Calculus, Revisited
TLDR
This paper eliminates both the function call retention problem and the extraneous re-association axioms of lazy evaluation using a single axiom, and establishes a correspondence between the semantics and Launchbury's natural semantics.
Defunctionalized Interpreters for Call-by-Need Evaluation
TLDR
This work inter-derive a series of hygienic semantic artifacts: a reduction-free stateless abstract machine, a continuation-passing evaluation function, and what appears to be the first heapless natural semantics for call-by-need evaluation.
Realizability Interpretation and Normalization of Typed Call-by-Need \lambda -calculus with Control
TLDR
A variant of realizability where realizers are pairs of a term and a substitution allows us to prove the normalization of a simply-typed call-by-need $$\lambda$-$calculus with control with control due to Ariola et al.
Realizability Interpretation and Normalization of Typed Call-by-Need λ-calculus With Control
TLDR
This work defines a variant of Krivine realizability where realizers are pairs of a term and a substitution, and extends the proof to a call-by-need λ-calculus equipped with a type system equivalent to classical second-order predicate logic.
Deriving an Abstract Machine for Strong Call by Need
TLDR
A novel reduction semantics and the first abstract machine for the strong call-by-need strategy are shown, which is an example of a hybrid strategy with an infinite number of substrategies.
Cactus Environment Machine - Shared Environment Call-by-Need
TLDR
It is shown how a shared environment can act as both an environment and a mechanism for sharing results, and it is suggested that incorporating this approach into real-world compilers could yield performance benefits in some scenarios.
Classical Call-by-Need Sequent Calculi: The Unity of Semantic Artifacts
TLDR
A classical call-by-need sequent calculus is derived, which does not require an unbounded search for the standard redex, by using the unity of semantic artifacts proposed by Danvy et al.
Small-step and big-step semantics for call-by-need
TLDR
The natural semantics for the acyclic calculus is revised from the previous presentation by Maraist et al, and its adequacy is ascribed to its correspondence with the reduction semantics, which has been proved equivalent to call-by-name by Ariola and Felleisen.
Shared-Environment Call-by-Need
TLDR
This dissertation presents a novel technique for compiling call-by-need semantics by using shared environments to share results of computation, and shows how the approach enables a compiler that generates high-performance code, while staying simple enough to lend itself to formal reasoning.
...
...

References

SHOWING 1-10 OF 59 REFERENCES
A call-by-need lambda calculus
TLDR
This paper derives an equational characterization of call-by-need and proves it correct with respect to the original lambda calculus and is a strictly smaller theory than the lambda calculus.
A call-by-name lambda-calculus machine
  • J. Krivine
  • Computer Science
    High. Order Symb. Comput.
  • 2007
TLDR
A particularly simple lazy lambda-calculus machine, introduced twenty-five years ago, is presented, conceived in order to execute programs obtained from mathematical proofs, by means of the Curry-Howard correspondence.
Defunctionalized Interpreters for Call-by-Need Evaluation
TLDR
This work inter-derive a series of hygienic semantic artifacts: a reduction-free stateless abstract machine, a continuation-passing evaluation function, and what appears to be the first heapless natural semantics for call-by-need evaluation.
Deriving a Lazy Abstract Machine
TLDR
The machine derived is a lazy version of Krivine's abstract machine, which was originally designed for call-by-name evaluation, and is extended with datatype constructors and base values, so the final machine implements all dynamic aspects of a lazy functional language.
Scheme: A Interpreter for Extended Lambda Calculus
TLDR
A completely annotated interpreter for SCHEME, written in MacLISP, is presented to acquaint programmers with the tricks of the trade of implementing non-recursive control structures in a recursive language like LISP.
A concrete framework for environment machines
TLDR
Back to Curien's original calculus of closures (an early calculus with explicit substitutions), it is extended minimally so that it can also express one-step reduction strategies, and a series of environment machines are derived from the specification of two one- step reduction strategies for the lambda-calculus.
Obtaining Lazy Evaluation with Continuations in Scheme
Small-step and big-step semantics for call-by-need
TLDR
The natural semantics for the acyclic calculus is revised from the previous presentation by Maraist et al, and its adequacy is ascribed to its correspondence with the reduction semantics, which has been proved equivalent to call-by-name by Ariola and Felleisen.
Lambda Calculus with Explicit Recursion
TLDR
A family of cyclic?-graph calculi that support the letrec, a feature that is essential to reason about time and space behavior of functional languages and also about compilation and optimizations of programs.
Abstracting control
TLDR
This article investigates an alternative formulation of continuations, exploiting the latent expressive power of the standard continuation-passing style (CPS) instead of introducing yet other new concepts, and describes an improved conversion into applicative-order CPS.
...
...