JavaDay 2015

1. Parboiled2
explained

2. Covered
 Why Parboiled2
 Library basics
 Perfomance optimizations
 Best Practices
 Migration

3. Features
 PEG
 No lexer required
 Flexible typesfe EDSL
 Compile-time optimizations
 Decent error reporting
 scala.js support

4. When regex fail
Parse arbitrary HTML with regexes
is like asking Paris Hilton to write an
operating system (c)

5. When regex fail

6. Performance (regex)
Parsing
Warmup
620.38
621.95
Parboiled2
Regex
Data is taken from here:
http://bit.ly/1XHAJaA
Lower is better

7. Performance (json)
Parboiled1
Parboiled2
Argonaut
Json4SNative
Json4SJackson
85.64
13.17
7.01
8.06
4.09
Data is taken from here:
http://myltsev.name/ScalaDays2014/#/
Lower is better

8. Performance (json)
Parser combinators
Parboiled1
Parboiled2
Argonaut
Json4SNative
Json4SJackson
2385.78
85.64
13.17
7.01
8.06
4.09
Data is taken from here:
https://groups.google.com/forum/#!topic/parboiled-user/bGtdGvllGgU
Lower is better

9. Alternatives
● Grappa [java]
● ANTLR
● Regexps
● Parser-combinators
● Language Workbenches (xtext, MPS)

10. <dependency>
<groupId>org.parboiled</groupId>
<artifactId>parboiled_2.11</artifactId>
<version>2.1.0</version>
</dependency>

11. import org.parboiled2._
class MyParser (val input: ParserInput)
extends Parser {
// Your grammar
}

12. Rule DSL

13. Basic match
def CaseDoesntMatter = rule {
ignoreCase("string")
}
def MyCharRule = rule { 'a' }
def MyStringRule = rule { "string" }
def MyCharRule = rule { ch('a') }
def MyStringRule = rule { str("string") }

14. Basic match
def CaseDoesntMatter: Rule0 =
rule { ignoreCase("string") }
def MyCharRule: Rule0 =
rule {'a'}
def MyStringRule: Rule0 =
rule { "string" }

15. Syntactic predicates
● ANY – matches any character except EOI
● EOI – virtual chararter represents the end of
input
val EOI = 'uFFFF'
You must define EOI at the end of the
main/root rule

16. Syntactic predicates
● anyOf – at least one of the defined chars
● noneOf – everything except those chars
def Digit = rule {
anyOf("1234567890")
}
def Visible = rule {
noneOf(" nt")
}

17. Character ranges
def Digit = rule { '0' - '9' }
def AlphaLower = rule { 'a' - 'z' }
Good, but not flexible
(the main issue of parboiled1)
● Sometimes you don't need ANY character
● You have a range of characters

18. Character predicates
There is set of predifined char predicates:
● CharPredicate.All
● CharPredicate.Digit
● CharPredicate.Digit19
● CharPredicate.HexDigit
Of course you can defien your own

19. def AllButQuotes = rule {
CharPredicate.Visible -- """ -- "'"
}
def ValidIdentifier = rule {
CharPredicate.AlphaNum ++ "_"
}
CharPredicate from (_.isSpaceChar)
Character predicates

20. def ArithmeticOperation = rule {
anyOf("+-*/^")
}
def WhiteSpaceChar = rule {
noneOf(" tn")
}
anyOf/noneOf

21. def cows =
rule { 1000 times "cow" }
def PRI =
rule { 1 to 3 times Digit }
N times

22. def OptWs = rule {
zeroOrMore(Whitespace) // Whitespace.*
}
def UInt = rule {
oneOrMore(Digit) // Whitespace.+
}
def CommaSeparatedNumbers = rule {
oneOrMore(UInt).separatedBy(",")
}
0+/1+

23. import CharPredicate.Digit
// "yyyy-mm-dd"
def SimplifiedRuleForDate = rule {
Year ~ "-" ~ Month ~ "-" ~ Day
}
def Year = rule {
Digit ~ Digit ~ Digit ~ Digit
}
def Month = rule { Digit ~ Digit }
def Day = rule { Digit ~ Digit }
Sequence

24. // zeroOrOne
def Newline = rule {
optional('r') ~ 'n'
}
def Newline = rule {
'r'.? ~ 'n'
}
Optional

25. def Signum = rule { '+' | '-' }
def bcd = rule {
'b' ~ 'c' | 'b' ~ 'd'
}
Ordered choice

26. // why order matters
def Operator = rule {
"+=" | "-=" | "*=" | "++" |
"--" | "+" | "-" | "*" | "/" ...
}
def Operators = rule {
("+" ~ ("=" | "+").?) |
("-" ~ ("=" | "-").?) | ...
}
Order matters

27. Running the parser
class MyParser(val input: ParserInput)
extends Parser {
def MyStringRule: Rule0 = rule {
ignoreCase("match") ~ EOI
}
}

28. Running the parser
val p1 = new MyParser("match")
val p2 = new MyParser("much")
p1.MyStringRule.run() // Success
p2.MyStringRule.run() // Failure
Different delivery schemes are also available

29. Running the parser
val p1 = new MyParser("match")
val p2 = new MyParser("much")
p1.MyStringRule.run() // Success
p2.MyStringRule.run() // Failure
Different delivery schemes are also available

30. BKV
server.name = "webserver"
server {
port = "8080"
address = "192.168.88.88"
settings {
greeting_message = "Hello!n It's me!"
}
}

31. Performance

32. Unroll n.times for n <=4
// Slower
rule { 4 times Digit }
// Faster
rule { Digit ~ Digit ~ Digit ~ Digit }

33. Faster stack operations
// Much faster
def Digit4 = rule {
Digit ~ Digit ~ Digit ~ Digit ~
push(
#(charAt(-4))*1000 +
#(charAt(-3))*100 +
#(charAt(-2))*10 +
#(lastChar)
)
}

34. Do not recreate CharPredicate
class MyParser(val input: ParserInput)
extends Parser {
val Uppercase =
CharPredicate.from(_.isUpper)
…
}

35. Use predicates
def foo = rule {
capture(zeroOrMore(noneOf("n")))
}
def foo = rule {
capture(zeroOrMore(!'n')) //loop here
}
def foo = rule {
capture(zeroOrMore( !'n' ~ ANY ))
}

36. Best Practices

37. Best Practices
● Unit tests
● Small rules
● Decomposition
● Case objects instead of strings

38. Push case objects
def LogLevel = rule {
capture("info" | "warning" | "error")
}
def LogLevel = rule {
“info” ~ push(LogLevel.Info)
| “warning" ~ push(LogLevel.Warning)
| “error" ~ push(LogLevel.Error)
}

39. Simple syntax for object capture
case class Text(s: String)
def charsAST: Rule1[AST] = rule {
capture(Chars) ~> ((s: String) => Text(s))
}
def charsAST = rule {
capture(Chars) ~> Text
}

40. Named rules
def Header: Rule1[Header] =
rule("I am header") { ... }
def Header: Rule1[Header] = namedRule("header")
{...}
def UserName = rule {
Prefix ~ oneOrMore(NameChar).named("username")
}

41. Migration

42. Migration
● Separate classpath
org.parboiled vs org.parboiled2
● Grammar is hard to break
● Compotition: trait → abstract class
● Removing primitives library

43. Drawbacks

44. Drawbacks
● PEG (absence of lexer)
● No support for left recursive grammars
● No error recovery mechanism
● No IDE support
● No support for indentation based grammars
● Awful non informative error messages

46. Q/A