An experiment in partial evaluation: the generation of a compiler generator
Proc. of the first international conference on Rewriting techniques and applications
From interpreter to compiler: a representational derivation
on Programs as data objects
4th Annual Symposium on Theoretical Aspects of Computer Sciences on STACS 87
Converting interpreters into compilers
Software—Practice & Experience
Information and Computation - Semantics of Data Types
Partial evaluation with inference rules
New Generation Computing - Special Issue: Selected Papers from the Workshop on Partial Evaluation and Mixed
The foundation of a generic theorem prover
Journal of Automated Reasoning
A meta-logic for functional programming
Meta-programming in logic programming
Semantics-Directed Compiler Generation: Proceedings
Semantics-Directed Compiler Generation: Proceedings
A Natural Deduction treatment of Operational Semantics
Proceedings of the Eighth Conference on Foundations of Software Technology and Theoretical Computer Science
Compiling a functional language
LFP '84 Proceedings of the 1984 ACM Symposium on LISP and functional programming
Specifying and implementing theorem provers in a higher-order logic programming language
Specifying and implementing theorem provers in a higher-order logic programming language
Occurrences in debugger specifications
PLDI '91 Proceedings of the ACM SIGPLAN 1991 conference on Programming language design and implementation
Staging transformations for abstract machines
PEPM '91 Proceedings of the 1991 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation
The correctness of an optimized code generation
PEPM '93 Proceedings of the 1993 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation
An introduction to partial evaluation
ACM Computing Surveys (CSUR)
Information and Computation
On extracting static semantics
The essence of computation
A type-based escape analysis for functional languages
Journal of Functional Programming
Deriving a lazy abstract machine
Journal of Functional Programming
Higher-Order and Symbolic Computation
On the correctness of the Krivine machine
Higher-Order and Symbolic Computation
A logical correspondence between natural semantics and abstract machines
Proceedings of the 15th Symposium on Principles and Practice of Declarative Programming
| Hi-index | 0.00 |
The operational semantics of functional programming languages is frequently presented using inference rules within simple meta-logics. Such presentations of semantics can be high-level and perspicuous since meta-logics often handle numerous syntactic details in a declarative fashion. This is particularly true of the meta-logic we consider here, which includes simply typed &lgr;-terms, quantification at higher types, and &bgr;-conversion. Evaluation of functional programming languages is also often presented using low-level descriptions based on abstract machines: simple term rewriting systems in which few high-level features are present. In this paper, we illustrate 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. In particular, we present in detail the transformation of two inference rules specifying call-by-name evaluation of the untyped &lgr;-calculus into the Krivine machine, a stack-based abstract machine that implements such evaluation. The initial specification uses the meta-logic's &bgr;-conversion to perform substitutions. The resulting machine uses de Bruijn numerals and closures instead of formal substitution. We also comment on a similar construction of a simplified SECD machine implementing call-by-value evaluation. This approach to abstract machine construction provides a semantics-directed method for motivating, proving correct, and extending such abstract machines.