Compiling a minimal functional Language.

1. FµN
FROM DEFINITION TO EXECUTION
20 septembre 2017
Software Craftsmanship Toulouse
&@dplaindoux @fcabestre
1
LIV
E
CO
D
E
LIV
E
CO
D
E
LIV
E
CO
D
E
LIV
E
CO
D
E
LIV
E
CO
D
E
FµN
inside

2. LANGUAGE DEFINITION
λ-Calculus: variable, abstraction and application
Constant: number and string
De nition: function and constant
Native: function and constant
2

3. LANGUAGE GRAMMAR
LL(1)?
exp ::= sexp sexp*
sexp ::= { (IDENT+ ->)? exp } -- à la Swift or Kotlin
| ( exp? )
| $ exp -- Infix application
| IDENT
| NUMBER
| STRING
| native STRING
def ::= def IDENT sexp
| exp
s0 ::= def*
3

4. SYNTAX HIGHLIGHTS
a (b (c d)) ≡ a $ b $ c d In x Application
{ a -> { b -> ... } } ≡ { a b -> ... } Curri ed form
{ a -> f a } ≡ { f _ } Implicit argument
{ f a } ≢ ( f a ) Abstraction vs. Application
{ a -> { b -> f a } } ≢ { { f _ } } Implicit variable scope
4

5. EXAMPLE :: FACTORIAL
def leq { l r t f in native "leq" } // l <= r ? t : f
def mult { l r -> native "mult" }
def minus { l r -> native "minus" }
def cond { c t f -> c t f () }
def fact { a ->
cond (leq a 1)
{ _ -> 1 }
{ _ -> mult a (fact (minus a 1)) }
}
fact 12
5

6. EXAMPLE :: FACTORIAL CONT'D
def leq { l r t f -> native "leq" } // l <= r ? t : f
def mult { l r -> native "mult" }
def minus { l r -> native "minus" }
def cond { c t f -> c t f () }
def fact { a ->
cond (leq a 1)
{ 1 }
{ mult a $ fact $ minus a 1 }
}
fact 12
6

7. EXAMPLE :: DSL
def do { f -> then () f }
def then { v f -> { v c -> c v } $ f v }
def yield { v f -> f v }
do { plus 20 2 }
then { minus _ 1 }
yield { mult _ 2 } // 42
7

8. ANALYZE
Sequence char → Try Ast
8

9. (PARSER CHAR TOKEN).CHAIN(PARSER TOKEN AST)
Generic lexer cf.
LL(1) or when k > 1 with try parser i.e. backtrack
Parser Combinators
OCaml Genlex
9

10. FROM CONCRETE SYNTAX TO ABSTRACT SYNTAX
[_] :: Sequence Token → Ast
[{ a -> b }] = Ast.abstraction(a, [b]))
[a b] = Ast.application([a],[b])
[i] = Ast.ident(i) if i ∈ IDENT
[n] = Ast.constant(n) if n ∈ NUMBER ∪ STRING
[native s] = Ast.native(s)
[( a )] = [a]
[$ a] = [a]
[()] = Ast.constant(unit)
10

11. TRANSFORM
Ast → AstDB
11

12. DE BRUIJN INDEX
Invariant with respect to α-conversion
Direct access in an environment
12

13. DETERMINE DE BRUIJN INDEXES
[_] :: Ast → List String → AstDB
[Ast.constant(c)]e = AstDB.constant(c)
[Ast.native(c)]e = AstDB.native(c)
[Ast.application(a,b)]e = AstDB.application([a]e, [b]e)
[Ast.abstraction(a,b)]e = AstDB.abstraction([b](a::e))
[Ast.ident(n)]e = AstDB.ident(n) if ∀ i / e[i]≠n
[Ast.ident(n)]e = AstDB.variable(i) if ∃ i / e[i]=n
∀ j<i / e[j]≠n
13

14. INTERPRET
AstDB → Result
14

15. ADVANCED INTERPRETER
No β-reduction based on term subtitution
Application interpretation is not tail recursive
type Result = NUMBER | STRING | (AstDB,Env)
and Env = List Result
[_] :: AstDB → Env → Result
[AstDB.constant(c)]e = c
[AstDB.variable(i)]e = e[i]
[AstDB.abstraction(b)]e = (b,e)
[AstDB.application(a,b)]e = [c]d::e' when [a]e =* (c,e')
and [b]e =* d
15

16. COMPILE
AstDB → Objcode
16

17. ABSTRACT MACHINE
J-L. Krivine's machine
X. Leroy's ZINC abstract machine
17

18. COMPILATION PROCESS
Standard call-by-value
[_] :: AstDB → Objcode
[AstDB.variable(i)] = Objcode.access(i)
[AstDB.application(a,b)] = [a];[b];Objcode.apply
[AstDB.abstraction(b)] = Objcode.closure([b];Objcode.returns)
[AstDB.ident(n)] = Objcode.ident(n)
[AstDB.constant(c)] = Objcode.constant(c)
[AstDB.native(c)] = Objcode.native(c)
18

19. EXECUTE
Objcode → Try Result
19

20. EXECUTION PROCESS :: CORE
type Result = NUMBER | STRING | (Objcode,Env)
and Env = List Result
and Stack = List (Result | Env | Objcode)
[_] :: Objcode → Env → Stack → Result
[Objcode.constant(n);c]e s = [c]e n::s
[Objcode.access(i);c]e s = [c]e e[i]::s
[Objcode.closure(c');c]e s = [c]e (c',e)::s
[Objcode.apply;c]e v::(c',e')::s = [c']v::e' c::e::s
[Objcode.returns;c]e v::c'::e'::s = [c']e' v::s
...
20

21. EXECUTION PROCESS :: EXTENSION
...
definition :: String -> Result
native :: String -> Env -> Result
[Objcode.ident(n);c]e s = [c]e (definition n)::s
[Objcode.native(n);c]e s = [c]e (native n e)::s
21

22. REPL
Sequence char → Try Result
22

23. S => PRINT(ANALYZE(S).MAP(TRANSFORM).MAP.(COMPILE).FLATMAP(EXECUTE))
23

24. FµN IN A BROWSER
fact <i id='val'>?</i> = <i id='res'>?</i>
<script type="application/mfun">
def compute_then_display { v ->
do { changeDom "val" v }
then { changeDom "res" $ fact v }
yield { () }
}
compute_then_display 100
</script>
24

25. WHAT'S NEXT?
Call-by-Name
Tail recursive
Type checker
G-Machine, SECD-Machine etc.
25