Definitional Interpreters Revisited

  title={Definitional Interpreters Revisited},
  author={John C. Reynolds},
  journal={Higher-Order and Symbolic Computation},
  • J. C. Reynolds
  • Published 1 December 1998
  • Computer Science
  • Higher-Order and Symbolic Computation
To introduce the republication of “Definitional Interpreters for Higher-Order Programming Languages”, the author recounts the circumstances of its creation, clarifies several obscurities, corrects a few mistakes, and briefly summarizes some more recent developments. 

Refunctionalization at work

The left inverse of Reynolds' defunctionalization is presented and its relevance to programming and to programming languages is shown and it is illustrated with a recognizer for Dyck words and with Dijkstra's shunting-yard algorithm.

Engineering definitional interpreters

This case study implements interpreters based on three semantics for a simple subset of Lua, in OCaml, based on natural semantics, and systematically investigates hundreds of combinations of algorithms and data structures.

Draft Proceedings of the 24th Symposium on Implementation and Application of Functional Languages (IFL 2012)

This paper shows how to eliminate both the function parameter and the polymorphism in a polymorphic monad, and the resulting characterization is amenable to reasoning.

Efficient Deconstruction with Typed Pointer Reversal (abstract)

A way to derive destructors for algebraic data types that consume a constant amount of stack and heap for predictably and reliablyCalling destructors in an ML-style language with first-class resources is described.

Defunctionalization at work

Practical applications of defunctionalization are studied and new connections between seemingly unrelated higher-order and first-order specifications and between their correctness proofs are uncovered.

Subtyping delimited continuations

We present a type system with subtyping for first-class delimited continuations that generalizes Danvy and Filinski's type system for shift and reset by maintaining explicit information about the

A principled approach to REPL interpreters

This paper identifies and defines the class of sequential languages, which admit a sound REPL implementation based on a definitional interpreter, and presents design guidelines for extending existing language implementations to support REPL-style interfaces (including computational notebooks).

Polymorphic typed defunctionalization and concretization

It is shown that defunctionalization can be viewed as a type-preserving transformation of an extension of F with guarded algebraic data types into itself and suggested that defunctionsalization is an instance of concretization, a more general technique that allows eliminating constructs other than functions.

Eff Directly in OCaml

OCaml may be regarded as another implementation of Eff, broadening the scope and appeal of that language, including the novel, direct denotational semantics of multi-prompt delimited control.



Definitional Interpreters for Higher-Order Programming Languages

This work considers the definition of a simple applicative programming language by means of an interpreter written in a similar language, and considers the treatment of imperative features such as jumps and assignment.

On the Relation between Direct and Continuation Semantics

This work gives two theorems which specify the relationship between the direct and the continuation semantic functions for a purely applicative language and shows that direct semantics are included in continuation semantics.

Typing first-class continuations in ML

The soundness of the Damas–Milner polymorphic type assignment system with respect to this semantics is proved, and the full Damas-Milner type system is shown to be unsound in the presence of first-class continuations.

Revised5 Report on the Algorithmic Language Scheme

The report gives a defining description of the programming language Scheme. Scheme is a statically scoped and properly tail-recursive dialect of the Lisp programming language invented by Guy Lewis

Scheme: A Interpreter for Extended Lambda Calculus

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.

Compiling with Continuations

This book shows how continuation-passing style is used as an intermediate representation to perform optimizations and program transformations to create practical optimizing compilers for modern languages like ML.

Continuations: A Mathematical Semantics for Handling Full Jumps

This paper describes a method of giving the mathematical semantics of programming languages which include the most general form of jumps, which includes Python, Java, and Ruby.

Continuation Semantics in Typed Lambda-Calculi (Summary)

This paper reports preliminary work on the semantics of the continuation transform and shows that the mechanism of inclusive predicates can be replaced by retractions in the case of the typed lambda-calculus.

The lambda calculus and its relation to programming languages

The approach is tutorial in nature, concentrating on explaining the methods rather than on giving the details, and no knowledge of the λ -calculus is assumed.

Rabbit: A Compiler for Scheme

A compiler for the lexically-scoped dialect of LISP known as SCHEME, which handles only a small basis set which reflects the semantics of lambda-calculus, and serves to produce code as good as that produced by more traditional compilers.