Breaking through the normalization barrier: a self-interpreter for f-omega

  title={Breaking through the normalization barrier: a self-interpreter for f-omega},
  author={Matt Brown and Jens Palsberg},
  journal={Proceedings of the 43rd Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages},
  • Matt BrownJ. Palsberg
  • Published 11 January 2016
  • Mathematics
  • Proceedings of the 43rd Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages
According to conventional wisdom, a self-interpreter for a strongly normalizing lambda-calculus is impossible. We call this the normalization barrier. The normalization barrier stems from a theorem in computability theory that says that a total universal function for the total computable functions is impossible. In this paper we break through the normalization barrier and define a self-interpreter for System F_omega, a strongly normalizing lambda-calculus. After a careful analysis of the… 

Figures from this paper


Matt Brown and Jens Palsberg constructed a self-interpreter for System Fω . They require a self-interpreter to have an injective quoting function and that the source codes be β-normal. I show that

Typed self-evaluation via intensional type functions

Fωμi is presented, the first λ-calculus that supports a polymorphically-typed self-evaluator and its key innovation is a novel implementation of type equality proofs that enables it to define a versatile representation of programs.

Generating Code with Polymorphic let: A Ballad of Value Restriction, Copying and Sharing

The polymorphic-let generator turns out to exist and its derivation and the application for the lightweight implementation of quotation via a novel and unexpectedly simple source-to-source transformation to code-generating combinators are presented.

Self-Quotation in a Typed, Intensional Lambda-Calculus

  • B. Jay
  • Computer Science
  • 2018

Collapsing towers of interpreters

Pink, a meta-circular Lisp-like evaluator on top of a multi-level lambda calculus that features staging constructs and stage polymorphism, is presented, and it is shown how user programs can be compiled and recompiled under user-modified semantics.

Jones-optimal partial evaluation by specialization-safe normalization

We present partial evaluation by specialization-safe normalization, a novel partial evaluation technique that is Jones-optimal, that can be self-applied to achieve the Futamura projections and that

System F in Agda, for Fun and Profit

This work presents the first complete, intrinsically typed, executable, formalisation of System F that it is aware of, and is motivated by verifying the core language of a smart contract system based on System F.

Degrees of extensionality in the theory of Böhm trees and Sallé's conjecture

This paper demonstrates that the two aforementioned theories of lambda-theory H*, arising by taking as observables the head normal forms, actually coincide, thus disproving Sall\'e's conjecture and provides a taxonomy of the different degrees of extensionality in the theory of B\"ohm trees.

Incorporating Quotation and Evaluation Into Church's Type Theory

Mœbius: metaprogramming using contextual types: the stage where system f can pattern match on itself

This work provides the appropriate abstractions for both generating and pattern matching on open code without committing to a concrete representation of variable binding and contexts, and is a step towards building a general type-theoretic foundation for multi-staged metaprogramming.



Efficient self-interpretation in lambda calculus

A compact representation schema for λ-terms is given, and it is shown how this leads to an exceedingly small and elegant self-interpreter and a self-reducer, and a constructive proof for the second fixed point theorem for the representation schema is given.

A Self-Interpreter of Lambda Calculus Having a Normal Form

The notion of a canonical algebraic term rewriting system can be interpreted in the lambda calculus by the Bohm — Piperno technique in such a way that strong normalization is preserved and allows us to improve some recent results of Mogensen concerning efficient godelizations.

Typed self-interpretation by pattern matching

This paper presents the first statically-typed language that not only allows representations of different terms to have different types, and supports a self-recogniser, but also supports aSelf-enactor, and implements the approach and experiments support the theory.

Theoretical Pearls: Self-interpretation in lambda calculus

  • H. Barendregt
  • Computer Science
    Journal of Functional Programming
  • 1991
Self-interpretation will be shown here to be possible in lambda calculus to represent functional programs including their input.

Finally tagless, partially evaluated: Tagless staged interpreters for simpler typed languages

This family of tagless interpretations for a higher-order typed object language in a typed metalanguage (Haskell or ML) that require no dependent types, generalized algebraic data types, or postprocessing to eliminate tags demonstrates again that it is useful to abstract over higher-kinded types.

Self-Representation in Girard's System U

It is shown that kind polymorphic types (i.e. types that depend on kinds) are sufficient to "tie the knot" -- they enable representations ofkind polymorphic terms without introducing another form of polymorphism.

Metacircularity in the Polymorphic lambda-Calculus

Typed self-representation

This paper defines the Fω* calculus, an extension of the higher-order polymorphic lambda calculus Fω that allows typed self-representations and believes that this approach makes a significant step towards a new generation of reflective languages that are both safe and efficient.

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.

Types and programming languages

This text provides a comprehensive introduction both to type systems in computer science and to the basic theory of programming languages, with a variety of approaches to modeling the features of object-oriented languages.