Macro-by-example: Deriving syntactic transformations from their specifications
POPL '87 Proceedings of the 14th ACM SIGACT-SIGPLAN symposium on Principles of programming languages
Common LISP: the language (2nd ed.)
Common LISP: the language (2nd ed.)
POPL '91 Proceedings of the 18th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
On the expressive power of programming languages
ESOP '90 Selected papers from the symposium on 3rd European symposium on programming
A confluent calculus of Macro expansion and evaluation
LFP '92 Proceedings of the 1992 ACM conference on LISP and functional programming
Syntactic abstraction in Scheme
Lisp and Symbolic Computation
Building domain-specific embedded languages
ACM Computing Surveys (CSUR) - Special issue: position statements on strategic directions in computing research
Units: cool modules for HOT languages
PLDI '98 Proceedings of the ACM SIGPLAN 1998 conference on Programming language design and implementation
Extending the scope of syntactic abstraction
Proceedings of the 26th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
The Theory of Fexprs is Trivial
Lisp and Symbolic Computation
LFP '86 Proceedings of the 1986 ACM conference on LISP and functional programming
Contracts for higher-order functions
Proceedings of the seventh ACM SIGPLAN international conference on Functional programming
Composable and compilable macros:: you want it when?
Proceedings of the seventh ACM SIGPLAN international conference on Functional programming
Steps toward better debugging tools for LISP
LFP '84 Proceedings of the 1984 ACM Symposium on LISP and functional programming
Rabbit: A Compiler for Scheme
DrScheme: a programming environment for Scheme
Journal of Functional Programming
Improving the static analysis of embedded languages via partial evaluation
Proceedings of the ninth ACM SIGPLAN international conference on Functional programming
EDUCATIONAL PEARL: A Nanopass framework for compiler education
Journal of Functional Programming
The anatomy of a loop: a story of scope and control
Proceedings of the tenth ACM SIGPLAN international conference on Functional programming
The Reasoned Schemer
The design and implementation of typed scheme
Proceedings of the 35th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Revised [6] Report on the Algorithmic Language Scheme
Revised [6] Report on the Algorithmic Language Scheme
Syntactic abstraction in component interfaces
GPCE'05 Proceedings of the 4th international conference on Generative Programming and Component Engineering
Scheme with classes, mixins, and traits
APLAS'06 Proceedings of the 4th Asian conference on Programming Languages and Systems
An implementation of a hygienic syntactic macro system for JavaScript: a preliminary report
Workshop on Self-Sustaining Systems
Proceedings of the 32nd ACM SIGPLAN conference on Programming language design and implementation
Optimization coaching: optimizers learn to communicate with programmers
Proceedings of the ACM international conference on Object oriented programming systems languages and applications
Hi-index | 0.00 |
Over the past two decades, Scheme macros have evolved into a powerful API for the compiler front end. Like Lisp macros, their predecessors, Scheme macros expand source programs into a small core language; unlike Lisp systems, Scheme macro expanders preserve lexical scoping, and advanced Scheme macro systems handle other important properties such as source location. Using such macros, Scheme programmers now routinely develop the ultimate abstraction: embedded domain-specific programming languages. Unfortunately, a typical Scheme programming environment provides little support for macro development. This lack makes it difficult for programmers to debug their macros and for novices to study the behavior of macros. In response, we have developed a stepping debugger specialized to the concerns of macro expansion. This debugger presents the macro expansion process as a linear rewriting sequence of annotated terms; it graphically illustrates the binding structure of the program as expansion reveals it; and it adapts to the programmer's level of abstraction, hiding details of syntactic forms that the programmer considers built-in.