TIM: A simple, lazy abstract machine to execute supercombinatorics

@inproceedings{Fairbairn1987TIMAS,
  title={TIM: A simple, lazy abstract machine to execute supercombinatorics},
  author={Jon Fairbairn and Stuart Wray},
  booktitle={FPCA},
  year={1987}
}
This paper is a description of the three instruction machine Tim, an abstract machine for the execution of supercombinators. Tim usually executes programmes faster than the G-machine style of abstract machine while being at least as easy to implement as an S-K combinator reducer. It has a lower overhead for passing unevaluated arguments than the G-machine, resulting in good performance even without strictness analysis, and is probably easier to implement in hardware. 

Efficient compilation of lazy evaluation

TLDR
The principles underlying an efficient implementation of a lazy functional language, compiling to code for ordinary computers, based on combinator-like graph reduction: the user defined functions are used as rewrite rules in the graph.

ΓCMC: Fast lazy functional languages

The Implementation of Lazy Narrowing

TLDR
A new abstract machine which implements lazy narrowing is presented, which consists of a conventional stack based architecture like the one used for imperative languages and almost orthogonal extensions of this core implement the different concepts of functional logic languages.

Tail recursion without space leaks

TLDR
Why a particular form of space leak occurs in the G-machine is analyzed, and some ideas for fixing this problem are presented.

The spineless tagless G-machine

The Spineless Tagless G-machine is an abstract machine based on graph reduction, designed as a target for compilers for non-strict functional languages. As its name implies, it is a development of

Deriving a lazy abstract machine

  • P. Sestoft
  • Computer Science
    Journal of Functional Programming
  • 1997
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.

Code optimizations for lazy evaluation

TLDR
The techniques in this paper are directly applicable to most of the virtual machines commonly used for implementing such languages and apply to other forms of delayed evaluation such as futures and promises.

CTDNet III-An eager reduction model with laziness features

Explaining the lazy Krivine machine using explicit substitution and addresses

TLDR
It is shown that the weak lambda-calculus of explicit substitution, called λσwa, fits well to the lazy Krivine machine, which describes the core of a lazy (call-by-need) functional programming language implementation.
...

References

SHOWING 1-10 OF 11 REFERENCES

The Functional Abstract Machine

TLDR
The Functional Abstract Machine (Fam) is a stack machine designed to support functional languages on large address space computers which has been optimized to allow very fast function application and the use of true stacks.

A combinator-based compiler for a functional language

TLDR
Functional languages, especially those with fully "lazy" evaluation semantics, are known primarily for their elegance, clarity, and expressive power, but implementation efficiency has been a bottleneck to building efficient implementations for such languages.

Serial Combinators: "Optimal" Grains of Parallelism

TLDR
The notion of a serial combinator is introduced that in some sense has optimal granularity, and that takes into account pragmatic issues such as the complexity of expressions and communication costs between processors.

Code generation techniques for functional languages

TLDR
This paper describes techniques used to generate fast, fully lasy code for the normal order functional language Ponder, and presents the disappointing result that higher order strictness snelyser gives no improvement in performance over a first order analyser that copes with curried functions.

Design and implementation of a simple typed language based on the lambda-calculus

TLDR
This thesis is a reexamination of the possibility of designing and implementing a small but practical language based on very few primitive constructs in a new language called Ponder, which is statically typed and an efficient implementation of normal order reduction.

The Categorical Abstract Machine

The Mechanical Evaluation of Expressions

TLDR
It is shown how some forms of expression in current programming languages can be modelled in Church's X-notation, and a way of "interpreting" such expressions is described, which suggests a method of analyzing the things computer users write.

When Chasing Your Tail Saves Time

  • R. Kieburtz
  • Mathematics, Computer Science
    Inf. Process. Lett.
  • 1986

Strictness detection in non-flat domains

  • John Hughes
  • Computer Science
    Programs as Data Objects
  • 1985

Ponder and its type system