Yin-yang: concealing the deep embedding of DSLs

JovanovicVojin,; ShaikhhaAmir,; StuckiSandro,; NikolaevVladimir,; KochChristoph,; OderskyMartin,

doi:10.1145/2775053.2658771

Cited by 3 publications

(3 citation statements)

References 30 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Non-problem: Rep types Sometimes Rep types themselves are pointed out as an issue, or the fact that they show up in type errors even though they might have been inferred in the source (see e.g. [37]). We do not consider this an actual problem, but rather a symptom of unfamiliarity.…”

Section: Practical Issuesmentioning

confidence: 99%

Reflections on LMS: exploring front-end alternatives

Rompf

2016

Proceedings of the 2016 7th ACM SIGPLAN Symposium on Scala

View full text Add to dashboard Cite

Metaprogramming techniques to generate code at runtime in a general-purpose meta-language have seen a surge of interest in recent years, driven by the widening performance gap between high-level languages and emerging hardware platforms. In the context of Scala, the LMS (Lightweight Modular Staging) framework has contributed to "abstraction without regret"-high-level programming without performance penalty-in a number of challenging domains, through runtime code generation and embedded compiler pipelines based on stacks of DSLs. Based on this experience, this paper crystallizes some of the design decisions of LMS and discusses potential alternatives, which maintain the underlying spirit but differ in implementation choices: specifically, strategies for realizing more flexible front-end embeddings using type classes instead of higher-kinded types, and strategies for type-safe metaprogramming with untyped intermediate representations.

show abstract

Section: Practical Issuesmentioning

confidence: 99%

Reflections on LMS: exploring front-end alternatives

Rompf

2016

Proceedings of the 2016 7th ACM SIGPLAN Symposium on Scala

View full text Add to dashboard Cite

show abstract

“…Instead, the transformation scope is closed and nothing is assumed to be part of the interface. Hopefully, this will be improved by techniques such as the Yin-Yang staging front-end [30], based on Scala macros [19]. Another type-directed transformation in the Scala compiler is the pickling framework [33], also based on macros.…”

Section: Related Workmentioning

confidence: 99%

Automating ad hoc data representation transformations

Ureche

Biboudis

Smaragdakis

et al. 2015

Proceedings of the 2015 ACM SIGPLAN International Conference on Object-Oriented Programming, Systems, Languages, and Applicatio

View full text Add to dashboard Cite

To maximize run-time performance, programmers often specialize their code by hand, replacing library collections and containers by custom objects in which data is restructured for efficient access. However, changing the data representation is a tedious and error-prone process that makes it hard to test, maintain and evolve the source code.We present an automated and composable mechanism that allows programmers to safely change the data representation in delimited scopes containing anything from expressions to entire class definitions. To achieve this, programmers define a transformation and our mechanism automatically and transparently applies it during compilation, eliminating the need to manually change the source code.Our technique leverages the type system in order to offer correctness guarantees on the transformation and its interaction with object-oriented language features, such as dynamic dispatch, inheritance and generics.We have embedded this technique in a Scala compiler plugin and used it in four very different transformations, ranging from improving the data layout and encoding, to retrofitting specialization and value class status, and all the way to collection deforestation. On our benchmarks, the technique obtained speedups between 1.8x and 24.5x.

show abstract

Section: Related Workmentioning

confidence: 99%

Automating ad hoc data representation transformations

UrecheVlad¹,

BiboudisAggelos

SmaragdakisYannis

et al. 2015

SIGPLAN Not.

View full text Add to dashboard Cite

To maximize run-time performance, programmers often specialize their code by hand, replacing library collections and containers by custom objects in which data is restructured for efficient access. However, changing the data representation is a tedious and error-prone process that makes it hard to test, maintain and evolve the source code. We present an automated and composable mechanism that allows programmers to safely change the data representation in delimited scopes containing anything from expressions to entire class definitions. To achieve this, programmers define a transformation and our mechanism automatically and transparently applies it during compilation, eliminating the need to manually change the source code. Our technique leverages the type system in order to offer correctness guarantees on the transformation and its interaction with object-oriented language features, such as dynamic dispatch, inheritance and generics. We have embedded this technique in a Scala compiler plugin and used it in four very different transformations, ranging from improving the data layout and encoding, to retrofitting specialization and value class status, and all the way to collection deforestation. On our benchmarks, the technique obtained speedups between 1.8x and 24.5x.

show abstract

Yin-yang: concealing the deep embedding of DSLs

Cited by 3 publications

References 30 publications

Reflections on LMS: exploring front-end alternatives

Reflections on LMS: exploring front-end alternatives

Automating ad hoc data representation transformations

Automating ad hoc data representation transformations

Contact Info

Product

Resources

About