Implementing mathematics with the Nuprl proof development system
Implementing mathematics with the Nuprl proof development system
Information and Computation - Semantics of Data Types
PLDI '88 Proceedings of the ACM SIGPLAN 1988 conference on Programming Language design and Implementation
On laziness and optimality in lambda interpreters: tools for specification and analysis
POPL '90 Proceedings of the 17th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A framework for defining logics
Journal of the ACM (JACM)
Unification under a mixed prefix
Journal of Symbolic Computation
POPL '93 Proceedings of the 20th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A notation for lambda terms. A generalization of environment
Theoretical Computer Science
Higher order unification via explicit substitutions
Information and Computation
A compiled implementation of strong reduction
Proceedings of the seventh ACM SIGPLAN international conference on Functional programming
Compiler Construction in Higher Order Logic Programming
PADL '02 Proceedings of the 4th International Symposium on Practical Aspects of Declarative Languages
Let-Polymorphism and Eager Type Schemes
TAPSOFT '97 Proceedings of the 7th International Joint Conference CAAP/FASE on Theory and Practice of Software Development
Confluence and Preservation of Strong Normalisation in an Explicit Substitutions Calculus
LICS '96 Proceedings of the 11th Annual IEEE Symposium on Logic in Computer Science
A λ-calculus with explicit weakening and explicit substitution
Mathematical Structures in Computer Science
Journal of Functional Programming
Closed reduction: explicit substitutions without $\alpha$-conversion
Mathematical Structures in Computer Science
Isabelle/HOL: a proof assistant for higher-order logic
Isabelle/HOL: a proof assistant for higher-order logic
A ρ-calculus of explicit constraint application
Higher-Order and Symbolic Computation
Practical higher-order pattern unification with on-the-fly raising
ICLP'05 Proceedings of the 21st international conference on Logic Programming
Hi-index | 0.00 |
Higher-order representations of objects such as programs, proofs, formulas, and types have become important to many symbolic computation tasks. Systems that support such representations usually depend on the implementation of an intensional view of the terms of some variant of the typed lambda calculus. New notations have been proposed for the lambda calculus that provide an excellent basis for realizing such implementations. There are, however, several choices in the actual deployment of these notations the practical consequences of which are not currently well understood. We attempt to develop such an understanding here by examining the impact on performance of different combinations of the features afforded by such notations. Among the facets examined are the treatment of bound variables, eagerness and laziness in substitution and reduction, the ability to merge different structure traversals into one, and the virtues of annotations on terms that indicate their dependence on variables bound by external abstractions. We complement qualitative assessments with experiments conducted by executing programs in a language that supports an intensional view of lambda terms while varying relevant aspects of the implementation of the language. Our study provides insights into the preferred approaches to representing and reducing lambda terms and also exposes characteristics of computations that have a somewhat unanticipated effect on performance.