Scala-virtualized

Moors, Adriaan; Rompf, Tiark; Haller, Philipp; Odersky, Martin

doi:10.1145/2103746.2103769

Cited by 30 publications

(18 citation statements)

References 11 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…For this purpose, Squid defines a small library of virtualized constructs [Jovanovic et al 2014;Moors et al 2012]. For example: variables are represented using a Var data type supporting operations .!…”

Section: Language Virtualizationmentioning

confidence: 99%

“…Note that IRs that rely on virtualized constructs [Jovanovic et al 2014;Moors et al 2012] will typically refine the behavior of the reinterpret method in case the target is a subclass of ScalaAST, so that these constructs are correctly de-virtualized. For example, without de-virtualization we might observe the following behavior: scala > code " if ( true ) 1 else 0" reinterpretIn ( new ScalaAST ) result : universe .…”

Section: One Interface To Rule Them Allmentioning

confidence: 99%

See 1 more Smart Citation

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

Section: Language Virtualizationmentioning

confidence: 99%

Section: One Interface To Rule Them Allmentioning

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

show abstract

“…Moreover, type-inference-based techniques help to hide staging annotations to some extent [35], which can be further improved by language virtualization [23,28], but the added complexity and fundamental limitations are still there: DSL designers have to write the entire library with staging in mind, define IR nodes for all constructs meant to be supported by the DSL, and interact directly with details of the compiler's IR (especially when defining rewritings [34]). Figure 1b presents a rewriting that optimizes calls to Math .…”

Section: Limitations Of Stagingmentioning

confidence: 99%

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

2017

View full text Add to dashboard Cite

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.

show abstract

“…This is done by transforming these constructs into calls to methods provided by the programmer or by the LMS framework. Currently, lifting is done using a custom version of the compiler, dubbed scalavirtualized [45] or using Yin-Yang [34], a macro-based frontend that allows selectively lifting parts of a program.…”

Section: Case Study 3: Stagingmentioning

confidence: 99%

“…Miniboxing uses a custom transformation implemented as a Scala compiler plugin [5,75], aimed at only the miniboxed representation. Finally, the Lightweight Modular Staging framework [55] in Scala relies on a custom fork of the main compiler, dubbed ScalaVirtualized [45], which is specifically retrofitted to support lifting language constructs.…”

Section: Introductionmentioning

confidence: 99%