The document discusses Domain-Specific Languages (DSLs), which are tailored programming languages focused on particular problem domains. It highlights Scala's strengths for creating DSLs, including concise syntax, functional capabilities, and built-in parser support. Examples of internal and external DSLs in Scala are provided, along with code snippets demonstrating how to implement such languages effectively.

1. Domain Specific Languages #DUSE-3

2. Peter Maas ~ Developer at Ebay Classifieds, working at the Marktplaats.nl migration. Likes programming languages. whoami

3. Agenda What is a DSL?

4. What makes Scala a good language for DSLs

5. Internal DSL

6. External DSL ACTUAL CODE!

7. Questions? Feel free to interrupt!

8. So, what is a DSL a D omain- S pecific L anguage (DSL) is a programming language or specification language dedicated to a particular problem domain, a particular problem representation technique, and/or a particular solution technique.

9. A language which feels natural to a specialist in the targeted domain

10. Internal / External Internal DSLs are built using the language itself. Buildr

11. Gradle

12. Routing configuration in Apache Camel External DSLs are 'mini' programming languages with their own compiler/interpreter SQL

13. Velocity

14. Why is Scala good at that Concise and tolerant syntax

15. Function objects (closures, currying etc)

16. Default arguments

17. Operator overloading

18. Implicit conversions

19. Built-in support for building parsers

20. Due to it's functional nature it is good at handling syntax trees.

21. Concise? val toGreet = " Marktplaats developers" "Hello" . + ( toGreet ) "Hello" + toGreet "Hello" . concat ( toGreet ) "Hello" concat toGreet // methods are objects... val greetMethod = "hello %s".format(_:String) greetMethod(toGreet)

22. Implicit conversions class StringReducer(s:String) { def acronym = s.filter(_.isUpper) } implicit def string2StringReducer(s:String) = new StringReducer(s) "Sun Certified Java Programmer".acronym == "SCJP"

23. Or... case class Route(source:String, target:String) class RouteBuilder(s:String) { def --> (target:String) = Route(s, target) } implicit def string2Route(s:String) = new RouteBuilder(s) "a" --> "b" == Route( "a" , "b" )

24. Let's build a DSL we all know SQL http://github.com/p3t0r/scala-sql-dsl

25. Pure Scala // Simple query with sorting SQL select "*" from ("user") order Asc("name") // More complex query with and/or including precedence SQL select "*" from ("user") where (("name","peter") and (("active", true) or ("role", "admin"))) Overriding the '=' operator was a no-go ;-)

26. Syntax Tree

27. case class Where( val clauses: Clause*) trait Clause { def and (otherField: Clause): Clause = And(this, otherField) def or (otherField: Clause): Clause = Or(this, otherField) } case class StringEquals(val f: String, val value: String) extends Clause case class NumberEquals(val f: String, val value: Number) extends Clause case class BooleanEquals(val f: String, val value: Boolean) extends Clause case class In(val field: String, val values: String*) extends Clause case class And(val lClause:Clause, val rClause:Clause) extends Clause case class Or(val lClause:Clause, val rClause:Clause) extends Clause AST for the Where clause

28. Some Implicits & Helpers object QueryBuilder { implicit def tuple2field(t: (String, String)): StringEquals = StringEquals(t._1, t._2) implicit def tuple2field(t: (String, Int)): NumberEquals = NumberEquals(t._1, t._2) implicit def tuple2field(t: (String, Boolean)): BooleanEquals = BooleanEquals(t._1, t._2) implicit def from2query(f: From): Query = Query(f.operation.get, f, Option(Where())) /** entrypoint for starting a select query */ def select(fields:String*) = Select(fields:_*) def select(symbol: Symbol): Select = symbol match { case 'all => select("*") case _ => throw new RuntimeException("Only 'all allowed as symbol") } def in(field: String, values: String*) = In(field, values: _*) }

29. That looks like a lot of code :( The entire builder is only 54 lines, including whitespace and comments! >> CONTINUE IN IDEA <<

30. And external? class SQLParser extends JavaTokenParsers { def query:Parser[Query] = operation ~ from ~ opt(where) ~ opt(order) ^^ { case operation ~ from ~ where ~ order => Query(operation, from, where, order) } def operation:Parser[Operation] = { (&quot;select&quot; | &quot;update&quot; | &quot;delete&quot;) ~ repsep(ident, &quot;,&quot;) ^^ { case &quot;select&quot; ~ f => Select(f:_*) case _ => throw new IllegalArgumentException(&quot;Operation not implemented&quot;) } } def from:Parser[From] = &quot;from&quot; ~> ident ^^ (From(_)) def where:Parser[Where] = &quot;where&quot; ~> rep(clause) ^^ (Where(_:_*)) /* more in idea */ }