Everything old is new again: quoted domain-specific languages

Klonatos

Proceedings of the 2016 International Conference on Management of Data

et al. 2016

This paper studies architecting query compilers. The state of the art in query compiler construction is lagging behind that in the compilers field. We attempt to remedy this by exploring the key causes of technical challenges in need of well founded solutions, and by gathering the most relevant ideas and approaches from the PL and compilers communities for easy digestion by database researchers. All query compilers known to us are more or less monolithic template expanders that do the bulk of the compilation task in one large leap. Such systems are hard to build and maintain. We propose to use a stack of multiple DSLs on different levels of abstraction with lowering in multiple steps to make query compilers easier to build and extend, ultimately allowing us to create more convincing and sustainable compiler-based data management systems. We attempt to derive our advice for creating such DSL stacks from widely acceptable principles. We have also re-created a well-known query compiler following these ideas and report on this effort.

Section: Dsl Stackmentioning

confidence: 99%

How to Architect a Query Compiler

Klonatos

Proceedings of the 2016 International Conference on Management of Data

et al. 2016

“…Staging has been successfully applied to optimizing domain specific languages (DSL), especially Embedded DSLs (EDSL) [17] which are DSLs that are defined within a more expressive host language such as Haskell [1,17,29] or Scala [26,30,35,39]. In this context, staging has been used to facilitate the definition of extensible compilers for performanceoriented DSLs and heterogeneous target platforms [1,9,26,30,33].…”

Section: Staging and Extensible Compilersmentioning

confidence: 99%

Quoted staged rewriting: a practical approach to library-defined optimizations

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

Koch

2017

Staging has proved a successful technique for programmatically removing code abstractions, thereby allowing for faster program execution while retaining a high-level interface for the programmer. Unfortunately, techniques based on staging suffer from a number of problems -ranging from practicalities to fundamental limitations -which have prevented their widespread adoption. We introduce Quoted Staged Rewriting (QSR), an approach that uses type-safe, pattern matchingenabled quasiquotes to define optimizations. The approach is "staged" in two ways: first, rewrite rules can execute arbitrary code during pattern matching and code reconstruction, leveraging the power and flexibility of staging; second, library designers can orchestrate the application of successive rewriting phases (stages). The advantages of using quasiquote-based rewriting are that library designers never have to deal directly with the intermediate representation (IR), and that it allows for non-intrusive optimizations -in contrast with staging, it is not necessary to adapt the entire library and user programs to accommodate optimizations.We show how Squid, a Scala macro-based framework, enables QSR and renders library-defined optimizations more practical than ever before: library designers write domainspecific optimizers that users invoke transparently on delimited portions of their code base. As a motivating example we describe an implementation of stream fusion (a well-known deforestation technique) that is both simpler and more powerful than the state of the art, and can readily be used by Scala programmers with no knowledge of metaprogramming.

“…Quasiquotes in MetaML [Sheard et al 1999], Haskell [Najd et al 2016], F# [Syme 2006] and others were used to facilitate the implementation of embedded DSLs such as languageintegrated queries [Cheney et al 2013]. Earlier approaches such as LINQ [Meijer et al 2006] also provided some level of language-integrated domain-specific program reification.…”

Section: Quasiquotes For Domain-specific Languagesmentioning

confidence: 99%

“…Earlier approaches such as LINQ [Meijer et al 2006] also provided some level of language-integrated domain-specific program reification. [Najd et al 2016] use TTH to build DSL programs for their alternative embedding of Feldspar [Axelsson et al 2010], an approach they call Quoted DSLs (QDSL). In this approach, a particular DSL is implemented using the quasiquotation abilities of a host language, which requires significant heavy lifting behind the scenes (for example, retrieving type information [Najd et al 2016]).…”

Section: Quasiquotes For Domain-specific Languagesmentioning

confidence: 99%

“…[Najd et al 2016] use TTH to build DSL programs for their alternative embedding of Feldspar [Axelsson et al 2010], an approach they call Quoted DSLs (QDSL). In this approach, a particular DSL is implemented using the quasiquotation abilities of a host language, which requires significant heavy lifting behind the scenes (for example, retrieving type information [Najd et al 2016]). Najd et al propose that "Rather than building a special-purpose tool for each QDSL, it should be possible to design a single tool for each host language."…”

Section: Quasiquotes For Domain-specific Languagesmentioning

confidence: 99%

See 1 more Smart Citation

Squid: type-safe, hygienic, and reusable quasiquotes

Proceedings of the 8th ACM SIGPLAN International Symposium on Scala

Koch

2017

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.