PLDI '88 Proceedings of the ACM SIGPLAN 1988 conference on Programming Language design and Implementation
The semantics of programming languages: an elementary introduction using structural operational semantics
What is an efficient implementation of the &lgr;-calculus?
Proceedings of the 5th ACM conference on Functional programming languages and computer architecture
Constant time factors do matter
STOC '93 Proceedings of the twenty-fifth annual ACM symposium on Theory of computing
Self-applicable online partial evaluation of the pure lambda calculus
PEPM '95 Proceedings of the 1995 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation
Optimality and inefficiency: what isn't a cost model of the lambda calculus?
Proceedings of the first ACM SIGPLAN international conference on Functional programming
Linear-time hierarchies for a functional language machine model
Science of Computer Programming - Special issue on the 6th European symposium on programming
Decidable Call by Need Computations in term Rewriting (Extended Abstract)
CADE-14 Proceedings of the 14th International Conference on Automated Deduction
Typed self-interpretation by pattern matching
Proceedings of the 16th ACM SIGPLAN international conference on Functional programming
| Hi-index | 0.00 |
We show that linear-time self-interpretation of the pure untyped lambda calculus is possible, in the sense that interpretation has a constant overhead compared to direct execution under various execution models. The present paper shows this result for reduction to weak head normal form under call-by-name, call-by-value and call-by-need.We use a self-interpreter based on previous work on self-interpretation and partial evaluation of the pure untyped lambda calculus.We use operational semantics to define each reduction strategy. For each of these we show a simulation lemma that states that each inference step in the evaluation of a term by the operational semantics is simulated by a sequence of steps in evaluation of the self-interpreter applied to the term (using the same operational semantics).By assigning costs to the inference rules in the operational semantics, we can compare the cost of normal evaluation and self-interpretation. Three different cost-measures are used: number of beta-reductions, cost of a substitution-based implementation (similar to graph reduction) and cost of an environment-based implementation.For call-by-need we use a non-deterministic semantics, which simplifies the proof considerably.