This document summarizes a conference on designing and implementing domain-specific languages in F# that was held from August 31st to September 1st 2018 in Osijek, Croatia. It thanks the organizers, partners, community, supporters and media partners. It then provides information on grammar vocabulary including associativity, precedence, Backus-Naur form, shift/reduce conflicts, and internal vs external DSL implementation. Finally, it demonstrates parsing techniques using active patterns and FsYacc.

1. 31.08 – 01.09.2018.
OSIJEK

2. Big thanks to:
ORGANIZERS PARTNERS
COMMUNITY SUPPORTERS MEDIA PARTNERS

3. Designing and implementing DSLs
in F#

4. Grammar vocabulary
Associativity
1+2+3 = 1+(2+3) = (1+2)+3 Addition is both left or right associative
1*2*3 = 1*(2*3) = (1*2)*3 Multiplication too
1-2-3 ≠ 1–(2-3) = (1-2)-3 Subtraction is left associative
1/2/3 ≠ 1/(2/3) = (1/2)/3 Division is left associative

5. Grammar vocabulary
Precedence
1+2*3/4-5 = (1+((2*3)/4))-5

6. Grammar vocabulary
Backus-Naur form (BNF)
Named after John Backus and Peter Naur
::= : definition
| : choice operator
<abc>: non-terminal symbol
ABC: terminal symbol
Related and useful:
Kleene star – e* - zero or many

7. Grammar vocabulary
Shift/reduce conflicts
Reduce/reduce conflicts
"Dangling else" problem
Exists when "else" is optional
if e1 then if e2 then e3 else e4 ->
if e1 then (if e2 then e3) else e4 or
if e1 then (if e2 then e3 else e4)

8. Grammar vocabulary
Internal vs External
Internal
via Workflows/Computation expressions
via custom operators/combinators
via augmentations
Excellent resource: dungpa's DSL cheatsheet
https://github.com/dungpa/dsls-in-action-
fsharp/blob/master/DSLCheatsheet.md

9. Grammar
<term> ::=
| <factor> * <term>
| <factor> / <term>
| <factor>
<e> ::=
| <term> + <expr>
| <term> – <expr>
| <term>
<factor> ::=
| i // 12
| f() // foo()
| f(<e>(, <e>)*) // foo(arg1, …, argn)
| v // x
| (<e>) // (1+2)
foo(x, (1+2)*3/4)

10. Abstract syntax trees
type var = string
type Expr =
| Num of float
| Add of Expr * Expr
| Sub of Expr * Expr
| Mul of Expr * Expr
| Div of Expr * Expr
| Var of var
| Call of var * Expr list

11. Parsing
• Active patterns
• FsYacc

12. Parsing with active patterns
let matchToken patt s =
Regex.Match(s, sprintf "A(%s)((?s).*)" patt, RegexOptions.Multiline)
|> fun m ->
if m.Success then
Some (m.Groups.[1].Value, m.Groups.[2].Value)
else
None
// val matchToken: string -> string -> (string * string) option

13. Parsing with active patterns
let (|WS|_|) = matchToken "[ |t|n|rn]+"
let (|COMMENT|_|) = matchToken "#.*[n|rn]"
let (|WHITESPACE|_|) s =
match s with
| WS rest -> Some rest
| COMMENT rest -> Some rest
| _ -> None

14. Parsing with active patterns
let rec (|Star|_|) f acc s =
match f s with
| Some (res, rest) ->
(|Star|_|) f (res :: acc) rest
| None ->
Some (List.rev acc, s)

15. Parsing with active patterns
… Demo …

16. Parsing with active patterns - limitations
• Right associative by default
• Left associativity is tricky
• Need to refactor grammar rules -> gets pretty complicated
• A ::= A B | A C | D | E
• A ::= (D | E) (B | C)*
• Otherwise end up with 1/2/3/4/5 -> 1/(2/(3/(4/5)))

17. FsLex+FsYacc
Explicit precedences
Explicit associativity
A more powerful class of grammars (LALR(k) vs LL(k))

18. FsYacc - lists
expr_list_rev:
| expr {
[$1]
}
| expr_list_rev COMMA expr {
$3 :: $1
}

19. FsYacc – optional values
expr_list_opt:
| {
[]
}
| expr_list {
$1
}

20. FsYacc - lists
expr_list:
| expr_list_rev {
List.rev $1
}

21. FsLex + FsYacc
… Demo …

22. Thanks for listening! Questions?
Get in touch
Adam Granicz
@granicz

23. Where are the instructions?
https://aka.ms/ms-docs
 Docs.microsoft.com
https://aka.ms/intldocs
Do you like Open Source?
https://aka.ms/msossloc
in your language,
today!
VS Code
SQL on Linux
SQL Ops Studio
Team Explorer Everywhere
… and more!