A lazy evaluator

  title={A lazy evaluator},
  author={Peter Henderson and James H. Morris},
  journal={Proceedings of the 3rd ACM SIGACT-SIGPLAN symposium on Principles on programming languages},
  • Peter Henderson, James H. Morris
  • Published 1 January 1976
  • Computer Science
  • Proceedings of the 3rd ACM SIGACT-SIGPLAN symposium on Principles on programming languages
A different way to execute pure LISP programs is presented. It delays the evaluation of parameters and list structures without ever having to perform more evaluation steps than the usual method. Although the central idea can be found in earlier work this paper is of interest since it treats a rather well-known language and works out an algorithm which avoids full substitution. A partial correctness proof using Scott-Strachey semantics is sketched in a later section. 
Listlessness is better than laziness: Lazy evaluation and garbage collection at compile-time
One reason for interest in functional programming is that it is well-suited for program development by transformation: begin by writing a clear (but inefficient) program, and transform this to an
Lambda-hoisting: A transformation technique for fully lazy evaluation of functional programs
  • M. Takeichi
  • Computer Science
    New Generation Computing
  • 2009
The basic idea of lambda-hoisting is described with remarks on similar techniques, and a simple algorithm is presented in a formal way that has a great advantage in generating efficient code for conventional computers.
A new implementation technique for applicative languages
  • D. Turner
  • Computer Science
    Softw. Pract. Exp.
  • 1979
It is shown how by using results from combinatory logic an applicative language, such as LISP, can be translated into a form from which all bound variables have been removed. A machine is described
A Theory of Lazy Imperative Timing
Lazy evaluation was introduced into the setting of functional programming, and has mainly stayed there, although it is just as applicable to imperative programs, although the name “lazy evaluation” is appropriate in the functional setting.
Partial parametrization eliminates multiple traversals of data structures
A new transformation technique based on partial parametrization and fully lazy evaluation for eliminating multiple traversais of data structures is described, which uses no particular mechanisms in functional programming and transforms a wider class of programs into efficient ones than that proposed so far.
Unbounded computational structures
Problems from the literature involving infinite data structures are solved in a LISP‐like applicative language to demonstrate that simple new semantics can enrich old and ‘friendly’ control structures.
Compiling strictness into streams
A compiler that detects unnecessary laziness would produce code that avoids much of thii overhead, injecting call-by-value behavior into expressions and regaining the efficiency of conventional implementations wherever possible.
Implementation of an interpreter for abstract equations
The main novelties of the interpreter are strict adherence to semantics based on logical consequences, ‘lazy’ (outermost) evaluation applied uniformly, an implementation based on table‐driven pattern matching, and strict separation of syntactic and semantic processing.
Hierarchical Analysis of a Distributed Evaluator
The goal is to show that the least fixed point semantics of FGL are faithfully implemented by the hardware evaluator envisioned in the Applicative Multi-Processor System AMPS.
Annotations to Control Parallelism and Reduction Order in the Distributed Evaluation of Functional Programs
The introduction of annotations to give the programmer control over the above decisions is proposed and their effects are defined in terms of the lambda calculus.


Correct and optimal implementations of recursion in a simple programming language
This paper describes an implementation of recursion which is both correct and optimal in a general class of sequential languages, and therefore constitutes an attractive alternative to both “ call-by-name” and “call- by-value”.
Toward a mathematical semantics for computer languages
The purpose of a mathematical semantics is to give a correct and meaningful correspondence between programs and mathematical entities in a way that is entirely independent of an implementation.
Behavioral semantics of nonrecursive control structures
The PLANNER Project is constructing a Programming Apprentice to make it easier for expert programmers to do knowledge based programming.
The Scott-Strachey approach to the mathematical semantics of programming languages, Course notes at M.I.T
  • Project MAC,
  • 1973
Semantics and Pragmatics of the Lambda-calculus
  • PhD. thesis,
  • 1971
Notes on a lattice-theoretic approach to the theory of computation, Lecture notes
  • Notes on a lattice-theoretic approach to the theory of computation, Lecture notes
  • 1971
The Scott-Strachey approach to the mathematical semantics of programming languages
  • Course notes at M.I.T. Project MAC
  • 1973
Notes on a lattice-theoretic approach to the theory of computation
  • Lecture notes, Syracuse Unversity,
  • 1971