Higher-Order Substitutions

  title={Higher-Order Substitutions},
  author={Dominic Duggan},
  journal={Inf. Comput.},
The ??-calculus is a concrete ?-calculus of explicit substitutions, designed for reasoning about implementations of ?-calculi. Higher-order abstract syntax is an approach to metaprogramming that explicitly captures the variable-binding aspects of programming language constructs. A new calculus of explicit substitutions for higher-order abstract syntax is introduced, allowing a high-level description of variable binding in object languages while also providing substitutions as explicit… 

Figures from this paper


Programming in higher-order typed lambda-calculi
The focus throughout is on the unusual style of programming that arises in these languages, where all functions are total and the primary control construct is iteration rather than general recursion.
The Constructive Engine
  • G. Huet
  • Computer Science
    A Perspective in Theoretical Computer Science
  • 1989
An implementation in CAML of a proof-checker for the Calculus of Constructions proceeds by operating an abstract machine, called the constructive engine, which is close in spirit to the inference system described in section 10.2 of [13].
Metacircularity in the Polymorphic lambda-Calculus
From operational semantics to abstract machines: preliminary results
This paper illustrates how a high-level description of evaluation using inference rules can be systematically transformed into a low-level abstract machine by removing dependencies on high- level features of the meta-logic until the resulting inference rules are so simple that they can be immediately identified as specifying an abstract machine.
A Logic Programming Approach to Manipulating Formulas and Programs
This paper shows how a simple natural deduction theorem prover may be implemented in $\lambda$Prolog, and how some simple program transformers for a functional programming language may be written in this language.
A Logic Programming Language with Lambda-Abstraction, Function Variables, and Simple Unification
This paper presents a logic programming language, called Lλ, that also contains both function variables and λ-abstractions, but certain restriction are placed on occurrences of function variables, so that an implementation of Lλ does not need to implement full higher-order unification.
Unification of Simply Typed Lamda-Terms as Logic Programming
This paper shows that the unification of simply typed ‚-terms modulo the rules of fl- and ·-conversions can be coded as a query of the logic programming language L‚ in a natural and clear fashion.
On laziness and optimality in lambda interpreters: tools for specification and analysis
It is shown that ACCL has properties not possessed by Curien's original combinators that make it particularly appropriate as the basis for implementation and analysis of a wide range of reduction schemes using shared environments, closures, or λ-terms.
An Empirical Study of the Runtime Behavior of Higher-Order Logic Programs
The results of an empirical study of existing example programs of λProlog and Elf are reported, finding that Elf is a better choice for this study for two reasons: accessibility of the large suite of examples, and ease of instrumentation of the Elf interpreter to perform measurements.
A framework for defining logics
The Edinburgh Logical Framework provides a means to define (or present) logics through a general treatment of syntax, rules, and proofs by means of a typed λ-calculus with dependent types, whereby each judgment is identified with the type of its proofs.