The document discusses parsing and Scala parser combinators. It provides an example of using parser combinators to define a parser that parses a line of text into a WordFreq case class with a string and integer field. The parser combinators approach allows defining parsing functions that are combined to parse more complex structures. This provides a robust yet easier way to define parsers compared to other options like hand-written parsers.

2. Why? How?
- DSLs Everywhere
- Also parsing in general
- Internal vs. External
Lots of options for parsing
- String.split
- RegEx
- Hand-Written
- Parser Generators
From simple and fragile to
robust and complex
Goal: Robust, but easier to create (and in Scala…)

3. Parser Combinators
The “functional way” of writing a parser
A parsing function:
Character Stream → Result[Character Stream, T]
Combine functions into more complicated patterns
- Sequence
- Choice
- ...
Not only in Scala; but we’ll focus on the standard Scala Parser Combinators.

4. Scala Parser Combinators - Simple Example
Input: A line consisting of a word (string) and its count (number), e.g. “johnny 12”
case class WordFreq(word: String, count: Int) {
override def toString = "Word <" + word + "> " +
"occurs with frequency " + count
}
And we’d like to use it in a program:
object TestSimpleParser extends SimpleParser {
def main(args: Array[String]) = {
parse(freq, "johnny 12") match {
case Success(matched,_) => println(matched)
case Failure(msg,_) => println("FAILURE: " + msg)
case Error(msg,_) => println("ERROR: " + msg)
}
}
}

5. Scala Parser Combinators - Simple Example
Then a possible parser is:
class SimpleParser extends RegexParsers {
def word: Parser[String] = """[a-z]+""".r ^^ { _.toString }
def number: Parser[Int] = """(0|[1-9]d*)""".r ^^ { _.toInt }
def freq: Parser[WordFreq] = word ~ number ^^ { case wd ~ fr => WordFreq(wd,fr) }
}
The basic pattern:
- Defining functions for parsing simple strings
- Map matched strings into more meaningful object model
- Combine results into more complex structures

6. Actimize Profiling Language
Context:
- A data profiling engine
- Aggregations, functions, metadata
- Highly customizable by clients,
professional services, etc.
- Existing interface: XML
configuration files

7. Defining a Profile

8. Model
How a profile object model should
“ideally” look like.
POSOs

9. Parser
Defines the whole
syntax in one class
~200 lines

10. Summary
Where? Parsing – DSLs and Beyond
Why? Building a robust parser is complicated
How? Scala Parser Combinators