Definitional Interpreters for Higher-Order Programming Languages

@article{Reynolds1972DefinitionalIF,
  title={Definitional Interpreters for Higher-Order Programming Languages},
  author={John C. Reynolds},
  journal={Higher-Order and Symbolic Computation},
  year={1972},
  volume={11},
  pages={363-397}
}
  • J. C. Reynolds
  • Published 1 August 1972
  • Computer Science
  • Higher-Order and Symbolic Computation
Higher-order programming languages (i.e., languages in which procedures or labels can occur as values) are usually defined by interpreters that are themselves written in a programming language based on the lambda calculus (i.e., an applicative language such as pure LISP). Examples include McCarthy's definition of LISP, Landin's SECD machine, the Vienna definition of PL/I, Reynolds' definitions of GEDANKEN, and recent unpublished work by L. Morris and C. Wadsworth. Such definitions can be… 

Abstracting definitional interpreters (functional pearl)

It is observed that abstract definitional interpreters can inherit the so-called “pushdown control flow” property, wherein function calls and returns are precisely matched in the abstract semantics, simply by virtue of the function call mechanism of the defining-language.

Embedded interpreters

  • Nick Benton
  • Computer Science
    Journal of Functional Programming
  • 2005
The basic idea of using type-indexed embedding/projection pairs when writing interpreters in statically-typed functional languages is described and how it may be extended to languages with recursive types and applied to elementary meta-programming is described.

Tagless staged interpreters for typed languages

This paper extends Shao, Saha, Trifonov and Papaspyrou's λH language to a multi-level setting and formalizes it to demonstrate type safety in a setting where the type language contains all the calculus of inductive constructions, but without having to repeat the work needed for establishing the soundness of that system.

Compiler generation from denotational semantics

Two flow analytic optimization methods are described for generating provably correct compilers from denotational definitions of programming languages to determine runtime properties of object programs in general which a compiler can use to produce less redundant STMs.

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

Intrinsically-typed definitional interpreters for imperative languages

This paper describes and demonstrates techniques and libraries in Agda that successfully scale up intrinsically-typed definitional interpreters to handle rich object languages with non-trivial binding structures and mutable state, and claims that they still meet the goals of being concise, comprehensible, and executable while guaranteeing type safety for more elaborate object languages.

What is a purely functional language?

  • A. Sabry
  • Computer Science
    Journal of Functional Programming
  • 1998
A formal definition of purity is investigated, showing that some proposed definitions which rely on confluence, soundness of the beta axiom, preservation of pure observational equivalences and independence of the order of evaluation, do not withstand close scrutiny.

Typesafe by Definition for Languages with Explicit Deallocation

This paper shows that the technique of "typesafe-byconstruction" can be also applied to interpreters for languages with explicit deallocation, by making an interpreter for a language called ML-dealloc, which is a basic version of ML extended with explicit allocation and deallocated.

Control-flow analysis of higher-order languages of taming lambda

This dissertation presents a technique for recovering the control-flow graph of a Scheme program at compile time, and gives examples of how this information can be used to perform several data-flow analysis optimisations, including copy propagation, induction- variable elimination, useless-variable elimination, and type recovery.

Simple lambda-calculus model of programming languages

A simple correspondence between a large subset of ALGOL 60 language and lambda-calculus is presented, with the aid of this correspondence, a program can be translated into a single lambda-expression.
...

References

SHOWING 1-10 OF 38 REFERENCES

GEDANKEN—a simple typeless language based on the principle of completeness and the reference concept

The functional approach to data structures and the use of references insure that any process which accepts some data structure will accept any logically equivalent structure, regardless of its internal representation.

The next 700 programming languages

A family of unimplemented computing languages is described that is intended to span differences of application area by a unified framework. This framework dictates the rules about the uses of

Correspondence between ALGOL 60 and Church's Lambda-notation

A model for computer languages and computer behavior is described, based on the notions of functional application and functional abstraction, but also having analogues for imperative language features.

Implementation and applications of Scott's logic for computable functions

  • R. Milner
  • Computer Science
    Proving Assertions About Programs
  • 1972
It is shown how the syntax and semantics of a simple programming language may be described completely in the logic, and an example of a theorem which relates syntactic and semantic properties of programs and which can be stated and proved within the logic is given.

Recursive functions of symbolic expressions and their computation by machine, Part I

A programming system called LISP (for LISt Processor) has been developed for the IBM 704 computer by the Artificial Intelligence group at M.I.T. The system was designed to facilitate experiments with

Semantics of Programming Languages

This chapter is a survey of the research on the semantics of programming languages and restricts itself to a description, mainly of allusive nature, of the sort of problems which are considered in semantics.

GEDANKEN: A SIMPLE TYPELESS LANGUAGE WHICH PERMITS FUNCTIONAL DATA STRUCTURES AND COROUTINES.

This chapter discusses the construction of the Syntaxo Applicative Semantics of GEDANKEN and some of the techniques used to develop and implement these techniques.

A λ-CALCULUS APPROACH

Report on the Algorithmic Language ALGOL 68

Report of Algorithmic Language ALGOL 68

Working Group 2.1 on ALGOL of the International Federation for Information Processing has discussed the development of “ALGOL X”, a successor to ALGol 60 since 1963, and invited written descriptions of the language based on the previous discussions.