Embedding and Parsing Combined for Efficient Language Design

@inproceedings{Dvai2013EmbeddingAP,
  title={Embedding and Parsing Combined for Efficient Language Design},
  author={Gergely D{\'e}vai and D{\'a}niel Lesk{\'o} and M{\'a}t{\'e} Tejfel},
  booktitle={ICSOFT},
  year={2013}
}
One way to develop domain specific languages is to define their concrete syntax and create support for it using classical compiler technology (maybe with the support of language workbenches). A different way is to create an embedded language, which is implemented as a special library written in a host language. The first approach is usually too costly in the first phase of the language design when the language evolves and changes quickly. Embedded languages are more lightweight and support the… 

Figures from this paper

The EDSL's Struggle for Their Sources
Embedded Domain Specific Languages make language design and implementation easier, because lexical and syntactical analysis and part of the semantic checks can be completed by the compiler of the

References

SHOWING 1-10 OF 15 REFERENCES
Notable design patterns for domain-specific languages
Concrete syntax for objects: domain-specific language embedding and assimilation without restrictions
TLDR
MetaBorg is described, a method for providing concrete syntax for domain abstractions to application programmers by embedding domain-specific languages in a general purpose host language and assimilating the embedded domain code into the surrounding host code.
Experiences with Domain-Specific Language Embedding in Scala
TLDR
This paper explores tradeoffs in the context of the Kiama project that is investigating embedding of language processing DSLs in the Scala language, with particular attention paid to the novel features of Scala that assist with this effort.
Incremental Development of a Domain-Specific Language That Supports Multiple Application Styles
TLDR
This paper investigates taking the opposite route: Building a DSL incrementally based on a series of example applications in a domain, and suggests that this could be a viable approach provided certain careful design decisions are made upfront.
DSL Implementation in MetaOCaml, Template Haskell, and C++
TLDR
This paper reviews embedding, and summarizes how two alternative techniques – staged interpreters and templates – can be used to overcome the limitations of embedding.
Component-Based DSL Development
TLDR
To increase the poor evolvability of current day DSL development environments a new development environment Keyword based programming (KBP) is proposed where DSLs are built by using a language specification to compose and glue loosely coupled and independent language components (called keywords).
Efficient Code Generation from the High-level Domain-specific Language Feldspar for DSPs
TLDR
While Feldspar allows description of algorithms on specification level, it is shown that with the right set of abstractions and transformations this high level, functional specification can be transformed into C code that is comparable or better than reference, hand-crafted C language implementations.
MetaBorg in Action: Examples of Domain-Specific Language Embedding and Assimilation Using Stratego/XT
TLDR
This tutorial describes the MetaBorg method for embedding domain-specific languages, tailored syntactically and semantically to the application domain at hand, in a general-purpose language.
A DSL toolkit for deferring architectural decisions in DSL-based software design
  • U. Zdun
  • Computer Science
    Inf. Softw. Technol.
  • 2010
Lessons learned from real DSL experiments
  • D. Wile
  • Computer Science
    36th Annual Hawaii International Conference on System Sciences, 2003. Proceedings of the
  • 2003
TLDR
Where these language efforts succeeded and where they failed is elaborate, gleaning lessons for others who take the somewhat risky step of committing to develop a DSL for a particular user community.
...
...