Hygienic quasiquotation in scheme

Rhiger, Morten

doi:10.1145/2661103.2661109

Cited by 3 publications

(6 citation statements)

References 16 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…The first pass α-renames lexical bindings introduced by the gexp in order to preserve lexical scope, as illustrated by Figure 4. The implementation is similar to MetaScheme [15] and to that described by Rhiger [13], with caveats discussed in Section 5. 3.…”

Section: Methodsmentioning

confidence: 99%

“…G-expressions are "hygienic": they preserve lexical scope across stages [9,13,15]. Figure 4 illustrates two well-known properties of hygienic multi-stage programs: first, binding x in one stage (outside the gexp) is distinguished from binding x in another stage (inside the gexp); second, binding x introduced inside gen-body does not shadow binding x in the outer gexp thanks to the renaming of these variables in the residual program.…”

Section: G-expressionsmentioning

confidence: 99%

“…Hygiene. Our implementation of hygiene, discussed in Section 3.2, follows the well-documented approach to the problem [13,15]. Rhiger's implementation handles a single binding construct (lambda) and MetaScheme handles a couple more constructs, but ours has to deal with more binding constructs: R6RS defines around ten binding constructs, and Guile adds a couple more.…”

Section: Limitationsmentioning

confidence: 99%

See 2 more Smart Citations

Code staging in GNU Guix

Courtès

2017

Proceedings of the 16th ACM SIGPLAN International Conference on Generative Programming: Concepts and Experiences

View full text Add to dashboard Cite

GNU Guix is a "functional" package manager that builds upon earlier work on Nix. Guix implements high-level abstractions such as packages and operating system services as domain-specific languages (DSLs) embedded in Scheme. It also implements build actions and operating system orchestration in Scheme. This leads to a multi-tier programming environment where embedded code snippets are staged for eventual execution.This paper presents G-expressions or "gexps", the staging mechanism we devised for Guix. We explain our journey from traditional Lisp S-expressions to G-expressions, which augment the former with contextual information and ensure hygienic code staging. We discuss the implementation of gexps and report on our experience using them in a variety of operating system use cases-from package build processes to system services. Gexps provide a novel way to cover many aspects of OS configuration in a single, multitier language, while facilitating code reuse and code sharing.

show abstract

Section: Methodsmentioning

confidence: 99%

Section: G-expressionsmentioning

confidence: 99%

Section: Limitationsmentioning

confidence: 99%

See 1 more Smart Citation

Code staging in GNU Guix

Courtès

2017

Proceedings of the 16th ACM SIGPLAN International Conference on Generative Programming: Concepts and Experiences

View full text Add to dashboard Cite

show abstract

“…However, within a single phase it is still possible to observe unintended variable capture. Rhiger [2012a] proposed a finer-grained hygiene system for Scheme-like code quasiquotes, but it does not support pattern matching on code values. The idea of code quasiquotation was picked up in a statically-typed context by Taha and Sheard [2000] with MetaML (and subsequently MetaOCaml [Taha 2004]) to enable Multi-Stage Programming (MSP).…”

Section: Existing Quasiquotation Systemsmentioning

confidence: 99%

Unifying analytic and statically-typed quasiquotes

Parreaux

Voizard

Shaikhha

et al. 2017

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

Metaprograms are programs that manipulate (generate, analyze and evaluate) other programs. These tasks are greatly facilitated by quasiquotation, a technique to construct and deconstruct program fragments using quoted code templates expressed in the syntax of the manipulated language. We argue that two main flavors of quasiquotes have existed so far: Lisp-style quasiquotes, which can both construct and deconstruct programs but may produce code that contains type mismatches and unbound variables; and MetaML-style quasiquotes, which rely on static typing to prevent these errors, but can only construct programs. In this paper, we show how to combine the advantages of both flavors into a unified framework: we allow the construction, deconstruction and evaluation of program fragments while ensuring that generated programs are well-typed and well-scoped, a combination unseen in previous work. We formalize our approach as λ { } , a multi-stage calculus with code pattern matching and rewriting, and prove its type safety. We also present its realization in Squid, a metaprogramming framework for Scala, leveraging Scala's expressive type system. To demonstrate the usefulness of our approach, we introduce speculative rewrite rules, a novel code transformation technique that makes decisive use of these capabilities, and we outline how it simplifies the design of some crucial query compiler optimizations. CCS Concepts: • Software and its engineering → Language features; Semantics;

show abstract

“…Therefore, Scheme and its successor Racket still provide support for (unhygienic) quasiquotes, which are viewed as a lower-level building tool. Hygienic Scheme quasiquotes have been proposed [Rhiger 2012], but in a version that does not support pattern matching. The idea of quasiquotation was picked up in a statically-typed context by MetaML [Taha and Sheard 2000] (and subsequently MetaOCaml [Taha 2004]) to enable Multi-Stage Programming (MSP).…”

Section: Type-safe and Hygienic Macros For Scalamentioning

confidence: 99%

Squid: type-safe, hygienic, and reusable quasiquotes

Parreaux

Shaikhha

Koch

2017

Proceedings of the 8th ACM SIGPLAN International Symposium on Scala

View full text Add to dashboard Cite

Quasiquotes have been shown to greatly simplify the task of metaprogramming. This is in part because they hide the data structures of the intermediate representation (IR), instead allowing metaprogrammers to use the concrete syntax of the language they manipulate. Scala has had "syntactic" quasiquotes for a long time, but still misses a statically-typed version like in MetaOCaml, Haskell and F#. This safer flavor of quasiquotes has been particularly useful for staging and domain-specific languages. In this paper we present Squid, a metaprogramming system for Scala that fills this gap. Squid quasiquotes are novel in three ways: they are the first statically-typed quasiquotes we know that allow code inspection (via pattern matching); they are implemented purely as a macro library, without modifications to the compiler; and they are reusable in the sense that they can manipulate different IRs. Adapting (or binding) a new IR to Squid is done simply by implementing a well-defined interface in the style of object algebras (i.e., tagless-final). We detail how Squid is implemented, leveraging the metaprogramming tools already offered by Scala, and show three application examples: the definition of a binding for a DSL in the style of LMS; a safe ANF conversion; and the introduction of type-safe, hygienic macros as an alternative to the current macro system.

show abstract

Hygienic quasiquotation in scheme

Cited by 3 publications

References 16 publications

Code staging in GNU Guix

Code staging in GNU Guix

Unifying analytic and statically-typed quasiquotes

Squid: type-safe, hygienic, and reusable quasiquotes

Contact Info

Product

Resources

About