Implicit phasing for R6RS libraries

Ghuloum, Abdulaziz; Dybvig, R. Kent

doi:10.1145/1291220.1291197

Cited by 3 publications

(2 citation statements)

References 6 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Scheme in particular has embraced macros, pioneering the development of declarative definitions [22] and working out the hygiene conditions for term rewriting macros (rule macros) [7] and procedural macros (case macros) [20] that enable true composability. In addition there has been work to integrate procedural macros and module systems [13,17]. Racket takes it even further by extending the Scheme macro system with deep hooks into the compilation process [14,35] and robust pattern specifications [9].…”

Section: Related Workmentioning

confidence: 99%

Sweeten your JavaScript

et al. 2014

View full text Add to dashboard Cite

Lisp and Scheme have demonstrated the power of macros to enable programmers to evolve and craft languages. In languages with more complex syntax, macros have had less success. In part, this has been due to the difficulty in building expressive hygienic macro systems for such languages. JavaScript in particular presents unique challenges for macro systems due to ambiguities in the lexing stage that force the JavaScript lexer and parser to be intertwined. In this paper we present a novel solution to the lexing ambiguity of JavaScript that enables us to cleanly separate the JavaScript lexer and parser by recording enough history during lexing to resolve ambiguities. We give an algorithm for this solution along with a proof that it does in fact correctly resolve ambiguities in the language. Though the algorithm and proof we present is specific to JavaScript, the general technique can be applied to other languages with ambiguous grammars. With lexer and parser separated, we then implement an expressive hygienic macro system for JavaScript called sweet.js.

show abstract

Section: Related Workmentioning

confidence: 99%

Sweeten your JavaScript

et al. 2014

View full text Add to dashboard Cite

show abstract

“…The compiler begins with a syntax-case expander, extended with a module system and R6RS libraries [6,8,12,23]. The expander produces a simplified core language with letrec, letrec*, and case-lambda as binding forms, quoted constants, primitive references, procedure calls, variable references, and a handful of other forms.…”

Section: Workings Of the Existing Chez Scheme Compilermentioning

confidence: 99%

A nanopass framework for commercial compiler development

Keep

Dybvig

2013

Proceedings of the 18th ACM SIGPLAN International Conference on Functional Programming

Self Cite

View full text Add to dashboard Cite

Contemporary compilers must typically handle sophisticated highlevel source languages, generate efficient code for multiple hardware architectures and operating systems, and support source-level debugging, profiling, and other program development tools. As a result, compilers tend to be among the most complex of software systems. Nanopass frameworks are designed to help manage this complexity. A nanopass compiler is comprised of many singletask passes with formally defined intermediate languages. The perceived downside of a nanopass compiler is that the extra passes will lead to substantially longer compilation times. To determine whether this is the case, we have created a plug replacement for the commercial Chez Scheme compiler, implemented using an updated nanopass framework, and we have compared the speed of the new compiler and the code it generates against the original compiler for a large set of benchmark programs. This paper describes the updated nanopass framework, the new compiler, and the results of our experiments. The compiler produces faster code than the original, averaging 15-27% depending on architecture and optimization level, due to a more sophisticated but slower register allocator and improvements to several optimizations. Compilation times average well within a factor of two of the original compiler, despite the slower register allocator and the replacement of five passes of the original 10 with over 50 nanopasses.

show abstract

Hygienic macro technology

Clinger¹,

Wand

2020

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

The fully parenthesized Cambridge Polish syntax of Lisp, originally regarded as a temporary expedient to be replaced by more conventional syntax, possesses a peculiar virtue: A read procedure can parse it without knowing the syntax of any expressions, statements, definitions, or declarations it may represent. The result of that parsing is a list structure that establishes a standard representation for uninterpreted abstract syntax trees. This representation provides a convenient basis for macro processing, which allows the programmer to specify that some simple piece of abstract syntax should be replaced by some other, more complex piece of abstract syntax. As is well-known, this yields an abstraction mechanism that does things that procedural abstraction cannot, such as introducing new binding structures. The existence of that standard representation for uninterpreted abstract syntax trees soon led Lisp to a greater reliance upon macros than was common in other high-level languages. The importance of those features is suggested by the ten pages devoted to macros in an earlier ACM HOPL paper, “The Evolution of Lisp.” However, na'ive macro expansion was a leaky abstraction, because the movement of a piece of syntax from one place to another might lead to the accidental rebinding of a program’s identifiers. Although this problem was recognized in the 1960s, it was 20 years before a reliable solution was discovered, and another 10 before a solution was discovered that was reliable, flexible, and efficient. In this paper, we summarize that early history with greater focus on hygienic macros, and continue the story by describing the further development, adoption, and influence of hygienic and partially hygienic macro technology in Scheme. The interplay between the desire for standardization and the development of new algorithms is a major theme of that story. We then survey the ways in which hygienic macro technology has been adapted into recent non-parenthetical languages. Finally, we provide a short history of attempts to provide a formal account of macro processing.

show abstract

Implicit phasing for R6RS libraries

Cited by 3 publications

References 6 publications

Sweeten your JavaScript

Sweeten your JavaScript

A nanopass framework for commercial compiler development

Hygienic macro technology

Contact Info

Product

Resources

About