Internal DSLs in Scala allows creating domain-specific languages within Scala by leveraging Scala's features like lightweight syntax, implicit conversions, by-name parameters, and advanced type system. The presentation provides examples of internal DSLs in Scala for tasks automation (Baysick), date/time manipulation (Time DSL), and message processing (Spring Integration DSL). It also recommends some books and links for further reading on implementing internal DSLs in Scala.

1. Internal DSLs in Scala
Andrey Adamovich
Aestas/IT

2. What’s in this
presentation?
 Definition and usage of DSLs
 Overview of Scala features that
can be used to create internal
DSL
 Examples of Scala-based DSLs
 Some links and reading
material
 Questions

3. WORLD OF DSLS

4. What is DSL?
Domain-Specific Language
” A Domain-Specific Language is a programming
language or executable specification language that
offers, through appropriate notations and
abstractions, expressive power focused on, and
usually restricted to, a particular problem
domain.
” The opposite is:
• a general-purpose programming language, such
as C, Java or Python,
• or a general-purpose modeling language such as
the Unified Modeling Language (UML).

5. Examples of DSL
” 


Examples of domain-specific languages include:
HTML,
Logo for children,
 Verilog and VHDL hardware description
languages,
 Mata for matrix programming,
 Mathematica and Maxima for symbolic
mathematics,
 spreadsheet formulas and macros,
 SQL for relational database queries,
 YACC grammars for creating parsers,
 regular expressions for specifying lexers,
 the Generic Eclipse Modeling System for creating
diagramming languages,
 Csound for sound and music synthesis,
 and the input languages of GraphViz and GrGen,
software packages used for graph layout and
graph rewriting.

6. Goals of DSL
”  Use a more expressive language than a
general-purpose one
 Share a common metaphor of
understanding between developers and
subject matter experts
 Have domain experts help with the design of
the business logic of an application
 Avoid cluttering business code with too
much boilerplate technical code thanks to
a clean separation
 Let business rules have their own lifecycle
Guillaume Laforge
Groovy Project Manager

7. What is internal DSL?
” Internal DSLs are particular
ways of using a host language
to give the host language the
feel of a particular language
Martin Fowler

8. Library vs. DSL
 Is there any difference between
a well-structured library or
API and an internal DSL?
 Not much, except for the
following:
• Internal DSL does not look like
code in host language
• It’s more readable in general and
is much closer to natural language

9. Fluent API
” In software engineering, a fluent
interface (as first coined by Eric Evans
and Martin Fowler) is an
implementation of an object oriented
API that aims to provide for more
readable code.
” A fluent interface is normally
implemented by using method
chaining to relay the instruction
context of a subsequent call (but a
fluent interface entails more than
just method chaining).

10. Fluent API examples
Mockito http://code.google.com/p/mockito/
Guava http://code.google.com/p/guava-libraries/

11. SCALA

12. Features of Scala
 Lightweight syntax
 Combines functional and object-
oriented aproaches
 Advanced type system:
everything has a type
 Strong type inference
 Performance comparable to
Java
 Fully interoperable with Java

13. What makes internal DSL
possible in Scala?
 ”Dot-free”, infix and postfix
operator notation
 ”Bracket-free” function calls
 (Almost) any character can be
used in method names
 Implicit conversions
 Advanced type system
 By-name parameters and
currying

14. Lightweight syntax
val numbers = List(1, 2, 3)
numbers map { x => x + 1 }
numbers sortWith { (x, y) => x > y }
numbers map { _ + 1 } sortWith { _ > _ }
numbers size

15. Implicit conversions
Map( "first" -> "Test", "second" -> "Code" )
/* Defines a new method 'sort' for array objects */
object implicits extends Application {
implicit def arrayWrapper[A : ClassManifest](x: Array[A]) =
new {
def sort(p: (A, A) => Boolean) = {
util.Sorting.stableSort(x, p); x
}
}
val x = Array(2, 3, 1, 4)
println("x = "+ x.sort((x: Int, y: Int) => x < y))
}

16. By-name parameters
debug("This" + " is" + " very" + " costly!")
def debug(msg: => String): Unit =
if (isDebugEnabled()) println(msg)
spawn(println("I run in different thread!"))
def spawn(p: => Unit) = {
val t = new Thread() { override def run() = p }
t.start()
}

17. Curryng I
” In mathematics and computer
science, currying is the technique
of transforming a function that
takes multiple arguments (or an
n-tuple of arguments) in such a
way that it can be called as a
chain of functions each with a
single argument (partial
application).

18. Curryng II
using(new BufferedReader(new FileReader("file"))) { r =>
var count = 0
while (r.readLine != null) count += 1
println(count)
}
def using[T <: { def close() }]
(resource: T)
(block: T => Unit)
{
try {
block(resource)
} finally {
if (resource != null) resource.close()
}
}

19. Advanced type system

20. DSL EXAMPLES

21. Baysick
ScalaBasicRunner.scala:
object ScalaBasicRunner extends Baysick with Application {
10 PRINT "Scala"
20 LET ('number := 1)
30 IF 'number > 0 THEN 50
40 PRINT "Java"
50 PRINT "rulez!"
60 END
RUN
}

22. Time DSL
import org.scala_tools.time.Imports._
DateTime.now
DateTime.now.hour(2).minute(45).second(10)
DateTime.now + 2.months
DateTime.nextMonth < DateTime.now + 2.months
DateTime.now to DateTime.tomorrow
(DateTime.now to DateTime.nextSecond).millis
2.hours + 45.minutes + 10.seconds
(2.hours + 45.minutes + 10.seconds).millis
2.months + 3.days

23. Spring Integration DSL
val messageFlow =
filter using
{ payload: String => payload == "World" } -->
transform using
{ payload: String => "Hello " + payload } -->
handle using
{ payload: String => println(payload) }
messageFlow.send("World")

24. READING MATERIAL

25. Books
Programming in Scala, Second Edition
Martin Odersky, Lex Spoon, and Bill
Venners
DSLs in Action
Debasish Ghosh

26. Links
 http://www.scala-lang.org/
 https://github.com/jorgeortiz85/scala-
time
 http://blog.springsource.org/2012/03/05/i
ntroducing-spring-integration-scala-dsl/
 http://blog.fogus.me/2009/03/26/baysick-
a-scala-dsl-implementing-basic/
 http://habrahabr.ru/post/98288/

27. QUESTIONS