List of Tables

Chapter 1. Learning to speak the language of the domain

Table 1.1. Commonly used DSLs

Table 1.2. Qualities of a well-designed abstraction

Chapter 2. The DSL in the wild

Table 2.1. Preliminary vocabulary for a DSL that processes orders

Table 2.2. Mapping issues reported against Java’s limitations

Table 2.3. Comparison of compile-time and runtime metaprogramming

Chapter 3. DSL-driven application development

Table 3.1. Integrating DSLs into your core application

Table 3.2. Integration points published by internal DSLs

Table 3.3. Integration points published by external DSLs

Table 3.4. What you need to know about errors and exceptions in DSLs

Chapter 4. Internal DSL implementation patterns

Table 4.1. Possible improvement areas for decorators in the Java DSL

Table 4.2. Builders and metaprogramming

Table 4.3. Iterative improvement of the DSL

Table 4.4. Implementing a generic groupBy

Chapter 5. Internal DSL design in Ruby, Groovy, and Clojure

Table 5.1. Ruby, Groovy, and Clojure features that make them great choices for your internal DSLs

Table 5.2. Dynamic languages and the Ruby DSL

Table 5.3. Think differently when you’re implementing a DSL in Clojure

Table 5.4. Dissecting a Clojure API

Table 5.5. Evolving our DSL

Chapter 6. Internal DSL design in Scala

Table 6.1. Idiomatic Scala in DSL design

Table 6.2. Features that make Scala syntax concise, with reference to listing 6.1

Table 6.3. Scala features checklist for trade-creation DSL

Table 6.4. Business rule to model with DSL: calculate tax and fees for a trade

Table 6.5. Dissecting a Scala DSL implementation model

Table 6.6. Dissecting the domain service TradingService in listing 6.10

Table 6.7. Composing DSLs hierarchically

Table 6.8. Advantages of using hierarchical composition for DSLs

Chapter 7. External DSL implementation artifacts

Table 7.1. Parser generators available today

Table 7.2. Recognizing the DSL syntax

Table 7.3. Building an external DSL with the ANTLR parser generator

Table 7.4. Xtext code generation template

Chapter 8. Designing external DSLs using Scala parser combinators

Table 8.1. Commonly used parser combinators

Table 8.2. Variations of the repetition combinator

Table 8.3. DSL implementation techniques

Table 8.4. Making your parser a packrat parser in Scala

Chapter 9. DSL design: looking forward

Table 9.1. Feature variation in DSL workbenches

Appendix C. A cheat sheet for Ruby’s DSL-friendly features

Table C.1. Ruby feature overview

Appendix D. A cheat sheet for Scala’s DSL-friendly features

Table D.1. Scala feature overview

Appendix E. A cheat sheet for Groovy’s DSL-friendly features

Table E.1. Groovy feature overview

Appendix F. A cheat sheet for Clojure’s DSL-friendly features

Table F.1. Clojure feature overview

Appendix G. Polyglot development

Table G.1. Steps for setting up a Groovy based DSL development environment

Table G.2. Polyglot IDEs