This document discusses term rewriting and provides examples of how rewrite rules can be used to transform terms. Key points include: - Rewrite rules define pattern matching and substitution to transform terms from a left-hand side to a right-hand side. - Examples show desugaring language constructs like if-then statements, constant folding arithmetic expressions, and mapping/zipping lists with strategies as parameters to rules. - Terms can represent programming language syntax and semantics domains. Signatures define the structure of terms. - Rewriting systems provide a declarative way to define program transformations and semantic definitions through rewrite rules and strategies.

1. IN4303 2015-2017
Compiler Construction
Term Rewriting
language specification
Guido Wachsmuth, Eelco Visser

2. Software Languages 2
DynSem
Stratego
NaBL2
SDF3
ESV
editor
SPT
tests
syntax definition
concrete syntax
abstract syntax
static semantics
name binding
type system
dynamic semantics
translation
interpretation

3. Software Languages 3
DynSem
Stratego
NaBL2
SDF3
ESV
editor
SPT
tests
syntax definition
concrete syntax
abstract syntax
static semantics
name binding
type system
dynamic semantics
translation
interpretation

4. Software Languages 4
Language Software
compiler construction

5. Software Languages 5
meta language facility

6. Software Languages 6
traditional compiler compilers
manual implementation
language
implementation
compile
compiler

7. Software Languages 7
traditional compiler compilers
compilation + compilation
language
implementation
compile
compiler
language
definition
compile

8. Software Languages 8
traditional compiler compilers
compilation + interpretation
interpreter
language
definition
compile
language
implementation

9. manual implementation
Term Rewriting
Spoofax Language Workbench
Stratego
• declarative DSL
• domain: program transformation
• means to manipulate ASTs
• working on ATerms
• compiles to Java (or C)
Stratego in Spoofax
• static analysis & error checking
• code generation
• semantic editor services
9

10. manual implementation
Term Rewriting
Spoofax Language Workbench
Stratego
• declarative DSL
• domain: program transformation
• means to manipulate ASTs
• working on ATerms
• compiles to Java (or C)
Stratego in Spoofax
• static analysis & error checking
• code generation
• semantic editor services
9
Note: static analysis is
replaced by the higher-level
NaBL2 language

11. concepts
Term Rewriting
Stratego
signatures
rewrite rules
• transform term to term
• left-hand side
• pattern matching & variable binding
• right-hand side
• pattern instantiation & variable substitution
rewrite strategies
• algorithm for applying rewrite rules
10

12. example
Term Rewriting
Stratego
module desugar
imports
include/Tiger
operators
strategies
desugar-all = innermost(desugar)
rules
desugar: IfThen(e1, e2) -> IfThenElse(e1, e2, NoVal())
11

13. Software Languages 12
Terms

14. Term Rewriting
Terms
13
Let(
[ FunDec(
"fact"
, [FArg("n", Tp(Tid("int")))]
, Tp(Tid("int"))
, If(
Lt(Var("n"), Int("1"))
, Int("1")
, Seq(
[ Times(
Var("n")
, Call(
Var("fact")
, [Minus(Var("n"), Int("1"))]
)
)
]
)
)
)
]
, [Call(Var("fact"), [Int("10")])]
)
let function fact(n : int) : int =
if n < 1 then 1 else (n * fact(n - 1))
in fact(10)
end

15. Term Rewriting
Syntax of Terms
module Terms
sorts Cons Term
lexical syntax
Cons = [a-zA-Z][a-zA-Z0-9]*
context-free syntax
Term.App = <<Cons>(<{Term ","}*>)>
14
Zero()
Succ(Zero())
Cons(A(), Cons(B(), Nil()))

16. Term Rewriting
Syntax of Terms
module Terms
sorts Cons Term
lexical syntax
Cons = [a-zA-Z][a-zA-Z0-9]*
context-free syntax
Term.App = <<Cons>(<{Term ","}*>)>
Term.List = <[<{Term ","}*>]>
Term.Tuple = <(<{Term ","}*>)>
15
Zero()
Succ(Zero())
[A(), B()]

17. Term Rewriting
Syntax of Terms
module ATerms
sorts Cons Term
lexical syntax
Cons = [a-zA-Z][a-zA-Z0-9]*
Cons = String
Int = [0-9]+
String = """ StringChar* """
StringChar = ~["n]
StringChar = "" ["]
context-free syntax
Term.Str = <<String>>
Term.Int = <<Int>>
Term.App = <<Cons>(<{Term ","}*>)>
Term.List = <[<{Term ","}*>]>
Term.Tuple = <(<{Term ","}*>)>
16
0
1
[A(), B()]
Var(“x”)
Let(
[ Decl(“x”, IntT()),
Decl(“y”, BoolT())
]
, Eq(Var(“x”), Int(0))
)

18. Term Rewriting
Syntax of A(nnotated)Terms
module ATerms
sorts Cons Term
lexical syntax
Cons = [a-zA-Z][a-zA-Z0-9]*
// more lexical syntax omitted
context-free syntax
Term.Anno = <<PreTerm>{<{Term “,"}*>}>
Term = <<PreTerm>>
PreTerm.Str = <<String>>
PreTerm.Int = <<Int>>
PreTerm.App = <<Cons>(<{Term ","}*>)>
PreTerm.List = <[<{Term ","}*>]>
PreTerm.Tuple = <(<{Term ","}*>)>
17
Var(“x”){Type(IntT())}

19. Software Languages 18
Signatures

20. context-free syntax
Exp.Uminus = [- [Exp]]
Exp.Power = [[Exp] ** [Exp]]
Exp.Times = [[Exp] * [Exp]]
Exp.Divide = [[Exp] / [Exp]]
Exp.Plus = [[Exp] + [Exp]]
Exp.Minus = [[Exp] - [Exp]]
Exp.CPlus = [[Exp] +i [Exp]]
Exp.CMinus = [[Exp] -i [Exp]]
Exp.Eq = [[Exp] = [Exp]]
Exp.Neq = [[Exp] <> [Exp]]
Exp.Gt = [[Exp] > [Exp]]
Exp.Lt = [[Exp] < [Exp]]
Exp.Geq = [[Exp] >= [Exp]]
Exp.Leq = [[Exp] <= [Exp]]
Exp.True = <true>
Exp.False = <false>
Exp.And = [[Exp] & [Exp]]
Exp.Or = [[Exp] | [Exp]]
Term Rewriting
Signatures
signature
constructors
Uminus : Exp -> Exp
Power : Exp * Exp -> Exp
Times : Exp * Exp -> Exp
Divide : Exp * Exp -> Exp
Plus : Exp * Exp -> Exp
Minus : Exp * Exp -> Exp
CPlus : Exp * Exp -> Exp
CMinus : Exp * Exp -> Exp
Eq : Exp * Exp -> Exp
Neq : Exp * Exp -> Exp
Gt : Exp * Exp -> Exp
Lt : Exp * Exp -> Exp
Geq : Exp * Exp -> Exp
Leq : Exp * Exp -> Exp
True : Exp
False : Exp
And : Exp * Exp -> Exp
Or : Exp * Exp -> Exp
19

21. Software Languages 20
Rewrite Rules

22. Term Rewriting
Desugaring
if x then
printint(x)
21
if x then
printint(x)
else
()

23. Term Rewriting
Desugaring
if x then
printint(x)
21
if x then
printint(x)
else
()
IfThen(
Var("x")
, Call(
"printint"
, [Var("x")]
)
)
IfThenElse(
Var("x")
, Call(
"printint"
, [Var("x")]
)
, NoVal()
)

24. desugar: IfThen(e1, e2) -> IfThenElse(e1, e2, NoVal())
Term Rewriting
Desugaring
if x then
printint(x)
21
if x then
printint(x)
else
()
IfThen(
Var("x")
, Call(
"printint"
, [Var("x")]
)
)
IfThenElse(
Var("x")
, Call(
"printint"
, [Var("x")]
)
, NoVal()
)

25. desugar: IfThen(e1, e2) -> IfThenElse(e1, e2, NoVal())
Term Rewriting
Desugaring
if x then
printint(x)
21
if x then
printint(x)
else
()
IfThen(
Var("x")
, Call(
"printint"
, [Var("x")]
)
)
IfThenElse(
Var("x")
, Call(
"printint"
, [Var("x")]
)
, NoVal()
)
pattern matching

26. desugar: IfThen(e1, e2) -> IfThenElse(e1, e2, NoVal())
Term Rewriting
Desugaring
if x then
printint(x)
21
if x then
printint(x)
else
()
IfThen(
Var("x")
, Call(
"printint"
, [Var("x")]
)
)
IfThenElse(
Var("x")
, Call(
"printint"
, [Var("x")]
)
, NoVal()
)
pattern matching
e1
e2

27. desugar: IfThen(e1, e2) -> IfThenElse(e1, e2, NoVal())
Term Rewriting
Desugaring
if x then
printint(x)
21
if x then
printint(x)
else
()
IfThen(
Var("x")
, Call(
"printint"
, [Var("x")]
)
)
IfThenElse(
Var("x")
, Call(
"printint"
, [Var("x")]
)
, NoVal()
)
pattern matching pattern instantiation
e1
e2

28. desugar: IfThen(e1, e2) -> IfThenElse(e1, e2, NoVal())
Term Rewriting
Desugaring
if x then
printint(x)
21
if x then
printint(x)
else
()
IfThen(
Var("x")
, Call(
"printint"
, [Var("x")]
)
)
IfThenElse(
Var("x")
, Call(
"printint"
, [Var("x")]
)
, NoVal()
)
pattern matching pattern instantiation
e1
e2

29. desugar: Uminus(e) -> Bop(MINUS(), Int("0"), e)
desugar: Plus(e1, e2) -> Bop(PLUS(), e1, e2)
desugar: Minus(e1, e2) -> Bop(MINUS(), e1, e2)
desugar: Times(e1, e2) -> Bop(MUL(), e1, e2)
desugar: Divide(e1, e2) -> Bop(DIV(), e1, e2)
desugar: Eq(e1, e2) -> Rop(EQ(), e1, e2)
desugar: Neq(e1, e2) -> Rop(NE(), e1, e2)
desugar: Leq(e1, e2) -> Rop(LE(), e1, e2)
desugar: Lt(e1, e2) -> Rop(LT(), e1, e2)
desugar: Geq(e1, e2) -> Rop(LE(), e2, e1)
desugar: Gt(e1, e2) -> Rop(LT(), e2, e1)
desugar: And(e1, e2) -> IfThenElse(e1, e2, Int("0"))
desugar: Or(e1, e2) -> IfThenElse(e1, Int("1"), e2)
Term Rewriting
More Desugaring
signature constructors
PLUS: BinOp
MINUS: BinOp
MUL: BinOp
DIV: BinOp
EQ: RelOp
NE: RelOp
LE: RelOp
LT: RelOp
Bop: BinOp * Expr * Expr -> Expr
Rop: RelOp * Expr * Expr -> Expr
22

30. Term Rewriting
Constant Folding
x := 21 + 21 + x
23
x := 42 + x

31. Term Rewriting
Constant Folding
x := 21 + 21 + x
23
x := 42 + x
Assign(
Var("x")
, Plus(
Plus(
Int("21")
, Int("21")
)
, Var("x")
)
)
Assign(
Var("x")
, Plus(
Int("42")
, Var("x")
)
)

32. eval: Bop(PLUS(), Int(i1), Int(i2)) -> Int(i3)
where <addS> (i1, i2) => i3
Term Rewriting
Constant Folding
x := 21 + 21 + x
23
x := 42 + x
Assign(
Var("x")
, Plus(
Plus(
Int("21")
, Int("21")
)
, Var("x")
)
)
Assign(
Var("x")
, Plus(
Int("42")
, Var("x")
)
)

33. eval: Bop(PLUS(), Int(i1), Int(i2)) -> Int(<addS> (i1, i2))
eval: Bop(MINUS(), Int(i1), Int(i2)) -> Int(<subtS> (i1, i2))
eval: Bop(MUL(), Int(i1), Int(i2)) -> Int(<mulS> (i1, i2))
eval: Bop(DIV(), Int(i1), Int(i2)) -> Int(<divS> (i1, i2))
eval: Rop(EQ(), Int(i), Int(i)) -> Int("1")
eval: Rop(EQ(), Int(i1), Int(i2)) -> Int("0") where not( <eq> (i1, i2) )
eval: Rop(NE(), Int(i), Int(i)) -> Int("0")
eval: Rop(NE(), Int(i1), Int(i2)) -> Int("1") where not( <eq> (i1, i2) )
eval: Rop(LT(), Int(i1), Int(i2)) -> Int("1") where <ltS> (i1, i2)
eval: Rop(LT(), Int(i1), Int(i2)) -> Int("0") where not( <ltS> (i1, i2) )
eval: Rop(LE(), Int(i1), Int(i2)) -> Int("1") where <leqS> (i1, i2)
eval: Rop(LE(), Int(i1), Int(i2)) -> Int("0") where not( <leqS> (i1, i2))
Term Rewriting
More Constant Folding
24

34. parameters
Term Rewriting
Rewrite Rules
f(x,y|a,b): lhs -> rhs
• strategy or rule parameters x,y
• term parameters a,b
• no matching
f(|a,b): lhs -> rhs
• optional strategy parameters
f(x,y): lhs -> rhs
• optional term parameters
f: lhs -> rhs
25

35. example: map
Term Rewriting
Rules with Parameters
26
[ 1
, 2
, 3
]
[ 2
, 3
, 4
]
map(inc)

36. example: map
Term Rewriting
Rules with Parameters
26
[ 1
, 2
, 3
]
[ 2
, 3
, 4
]
map(inc)
inc
1
2
3
2
3
4inc
inc

37. example: map
Term Rewriting
Rules with Parameters
map(s): [] -> []
map(s): [x|xs] -> [<s> x | <map(s)> xs]
26
[ 1
, 2
, 3
]
[ 2
, 3
, 4
]
map(inc)
inc
1
2
3
2
3
4inc
inc

38. example: zip
Term Rewriting
Rules with Parameters
27
[ 1
, 2
, 3
]
[ (1,4)
, (2,5)
, (3,6)
]
[ 4
, 5
, 6
]
zip

39. example: zip
Term Rewriting
Rules with Parameters
27
[ 1
, 2
, 3
]
[ (1,4)
, (2,5)
, (3,6)
]
[ 4
, 5
, 6
]
zip
[ 1
, 2
, 3
]
[ 5
, 7
, 9
]
[ 4
, 5
, 6
]
zip(add)

40. example: zip
Term Rewriting
Rules with Parameters
27
[ 1
, 2
, 3
]
[ (1,4)
, (2,5)
, (3,6)
]
[ 4
, 5
, 6
]
zip
[ 1
, 2
, 3
]
[ 5
, 7
, 9
]
[ 4
, 5
, 6
]
zip(add)
map(add)

41. example: zip
Term Rewriting
Rules with Parameters
zip(s): ([],[]) -> []
zip(s): ([x|xs],[y|ys]) -> [<s> (x,y) | <zip(s)> (xs,ys)]
zip = zip(id)
27
[ 1
, 2
, 3
]
[ (1,4)
, (2,5)
, (3,6)
]
[ 4
, 5
, 6
]
zip
[ 1
, 2
, 3
]
[ 5
, 7
, 9
]
[ 4
, 5
, 6
]
zip(add)
map(add)

42. example: fold
Term Rewriting
Rules with Parameters
28
[1,2,3] foldr(!0,add) 6

43. example: fold
Term Rewriting
Rules with Parameters
28
[1,2,3] foldr(!0,add) 6
[]
0
[3]
3
[2,3]
56
[1,2,3]

44. example: fold
Term Rewriting
Rules with Parameters
foldr(s1,s2): [] -> <s1>
foldr(s1,s2): [x|xs] -> <s2> (x,<foldr(s1,s2)> xs)
28
[1,2,3] foldr(!0,add) 6
[]
0
[3]
3
[2,3]
56
[1,2,3]

45. example: inverse
Term Rewriting
Rules with Parameters
29
[1,2,3] inverse(|[]) [3,2,1]

46. example: inverse
Term Rewriting
Rules with Parameters
29
[1,2,3] inverse(|[]) [3,2,1]
[2,3]
[1][]
[1,2,3] [3]
[2,1] [3,2,1]
[]

47. example: inverse
Term Rewriting
Rules with Parameters
inverse(|is): [] -> is
inverse(|is): [x|xs] -> <inverse(|[x|is])> xs
29
[1,2,3] inverse(|[]) [3,2,1]
[2,3]
[1][]
[1,2,3] [3]
[2,1] [3,2,1]
[]

48. Software Languages 30
Rewrite Strategies

49. rules and strategies
Term Rewriting
Transformation Definitions
rewrite rules
• term to term
• left-hand side matching
• right-hand side instantiation
• conditional
• partial transformation
rewrite strategies
• rule selection
• algorithm
• composition of transformations
31

50. example
Term Rewriting
Stratego
module desugar
imports
include/Tiger
operators
strategies
desugar-all = innermost(desugar)
rules
desugar: IfThen(e1, e2) -> IfThenElse(e1, e2, NoVal())
32

51. example
Term Rewriting
Stratego
module eval
imports
include/Tiger
operators
desugar
strategies
eval-all = innermost(desugar + eval)
rules
eval: Bop(PLUS(),Int(i1),Int(i2)) -> Int(i3)
where <addS> (i1, i2) => i3
33

52. Term Rewriting
Strategy Combinators
identity
id
34

53. Term Rewriting
Strategy Combinators
identity
id
failure
fail
34

54. Term Rewriting
Strategy Combinators
identity
id
failure
fail
sequential composition
s1 ; s2
34

55. Term Rewriting
Strategy Combinators
identity
id
failure
fail
sequential composition
s1 ; s2
deterministic choice
s1 <+ s2
34

56. Term Rewriting
Strategy Combinators
identity
id
failure
fail
sequential composition
s1 ; s2
deterministic choice
s1 <+ s2
non-deterministic choice
s1 + s2
34

57. Term Rewriting
Strategy Combinators
identity
id
failure
fail
sequential composition
s1 ; s2
deterministic choice
s1 <+ s2
non-deterministic choice
s1 + s2
guarded choice
s1 < s2 + s3
34

58. variables
Term Rewriting
Strategy Combinators
pattern matching
?t
35

59. variables
Term Rewriting
Strategy Combinators
pattern matching
?t
pattern instantiation
!t
35

60. variables
Term Rewriting
Strategy Combinators
pattern matching
?t
pattern instantiation
!t
strategy application
<s> t ≣ !t ; s
35

61. variables
Term Rewriting
Strategy Combinators
pattern matching
?t
pattern instantiation
!t
strategy application
<s> t ≣ !t ; s
result matching
s => t ≣ s ; ?t
<s> t1 => t2
t2 := <s> t1
35

62. variables
Term Rewriting
Strategy Combinators
pattern matching
?t
pattern instantiation
!t
strategy application
<s> t ≣ !t ; s
result matching
s => t ≣ s ; ?t
<s> t1 => t2
t2 := <s> t1
variable scope
{x,y: s}
35

63. rules and strategies
Term Rewriting
Strategy Combinators
named rewrite rule
l: t1 -> t2 where s ≣ l = ?t1 ; s ; !t2
36

64. rules and strategies
Term Rewriting
Strategy Combinators
named rewrite rule
l: t1 -> t2 where s ≣ l = ?t1 ; s ; !t2
unscoped rewrite rule
(t1 -> t2 where s) ≣ ?t1 ; s ; !t2
36

65. rules and strategies
Term Rewriting
Strategy Combinators
named rewrite rule
l: t1 -> t2 where s ≣ l = ?t1 ; s ; !t2
unscoped rewrite rule
(t1 -> t2 where s) ≣ ?t1 ; s ; !t2
strategy definition
f(x,y|a,b) = s
36

66. examples
Term Rewriting
Strategy Combinators
try(s) = s <+ id
37

67. examples
Term Rewriting
Strategy Combinators
try(s) = s <+ id
repeat(s) = try(s ; repeat(s))
37

68. examples
Term Rewriting
Strategy Combinators
try(s) = s <+ id
repeat(s) = try(s ; repeat(s))
topdown(s) = s ; all(topdown(s))
37

69. examples
Term Rewriting
Strategy Combinators
try(s) = s <+ id
repeat(s) = try(s ; repeat(s))
topdown(s) = s ; all(topdown(s))
alltd(s) = s <+ all(alltd(s))
37

70. examples
Term Rewriting
Strategy Combinators
try(s) = s <+ id
repeat(s) = try(s ; repeat(s))
topdown(s) = s ; all(topdown(s))
alltd(s) = s <+ all(alltd(s))
bottomup(s) = all(bottomup(s)) ; s
37

71. examples
Term Rewriting
Strategy Combinators
try(s) = s <+ id
repeat(s) = try(s ; repeat(s))
topdown(s) = s ; all(topdown(s))
alltd(s) = s <+ all(alltd(s))
bottomup(s) = all(bottomup(s)) ; s
innermost(s) = bottomup(try(s ; innermost(s)))
37

72. examples
Term Rewriting
Strategy Combinators
try(s) = s <+ id
repeat(s) = try(s ; repeat(s))
topdown(s) = s ; all(topdown(s))
alltd(s) = s <+ all(alltd(s))
bottomup(s) = all(bottomup(s)) ; s
innermost(s) = bottomup(try(s ; innermost(s)))
oncetd(s) = s <+ one(oncetd(s))
37

73. examples
Term Rewriting
Strategy Combinators
try(s) = s <+ id
repeat(s) = try(s ; repeat(s))
topdown(s) = s ; all(topdown(s))
alltd(s) = s <+ all(alltd(s))
bottomup(s) = all(bottomup(s)) ; s
innermost(s) = bottomup(try(s ; innermost(s)))
oncetd(s) = s <+ one(oncetd(s))
contains(|t) = oncetd(?t)
37

74. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
topdown(s) = s ; all(topdown(s))
topdown(switch)
38
Const
Mul
Const
3 4 5
Const
Add

75. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
topdown(s) = s ; all(topdown(s))
topdown(switch)
38
Const
Mul
Const
3 4 5
Const
Add1

76. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
topdown(s) = s ; all(topdown(s))
topdown(switch)
39
Mul
Const
3
Const
4 5
Const
Add1

77. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
topdown(s) = s ; all(topdown(s))
topdown(switch)
39
Mul
Const
3
Const
4 5
Const
Add1
2

78. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
topdown(s) = s ; all(topdown(s))
topdown(switch)
40
Mul
Const
3
Const
5 4
Const
Add1
2

79. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
topdown(s) = s ; all(topdown(s))
topdown(switch)
40
Mul
Const
3
Const
5 4
Const
Add1
2
3

80. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
topdown(s) = s ; all(topdown(s))
topdown(try(switch))
41
Const
Mul
Const
3 4 5
Const
Add

81. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
topdown(s) = s ; all(topdown(s))
topdown(try(switch))
41
Const
Mul
Const
3 4 5
Const
Add1

82. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
topdown(s) = s ; all(topdown(s))
topdown(try(switch))
42
Mul
Const
3
Const
4 5
Const
Add1

83. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
topdown(s) = s ; all(topdown(s))
topdown(try(switch))
42
Mul
Const
3
Const
4 5
Const
Add1
2

84. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
topdown(s) = s ; all(topdown(s))
topdown(try(switch))
43
Mul
Const
3
Const
5 4
Const
Add1
2

85. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
topdown(s) = s ; all(topdown(s))
topdown(try(switch))
43
Mul
Const
3
Const
5 4
Const
Add1
2
3

86. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
topdown(s) = s ; all(topdown(s))
topdown(try(switch))
43
Mul
Const
3
Const
5 4
Const
Add1
2
3
4

87. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
topdown(s) = s ; all(topdown(s))
topdown(try(switch))
43
Mul
Const
3
Const
5 4
Const
Add1
2
3
4
5

88. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
topdown(s) = s ; all(topdown(s))
topdown(try(switch))
43
Mul
Const
3
Const
5 4
Const
Add1
2
3
4
5
6

89. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
topdown(s) = s ; all(topdown(s))
topdown(try(switch))
43
Mul
Const
3
Const
5 4
Const
Add1
2
3
4
5
6
7

90. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
topdown(s) = s ; all(topdown(s))
topdown(try(switch))
43
Mul
Const
3
Const
5 4
Const
Add1
2
3
4
5
6
7
8

91. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
alltd(s) = s <+ all(alltd(s))
alltd(switch)
44
Const
Mul
Const
3 4 5
Const
Add

92. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
alltd(s) = s <+ all(alltd(s))
alltd(switch)
44
Const
Mul
Const
3 4 5
Const
Add1

93. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
alltd(s) = s <+ all(alltd(s))
alltd(switch)
45
Mul
Const
3
Const
4 5
Const
Add1

94. example
Term Rewriting
Stratego
switch: Mul(e1, e2) -> Mul(e2, e1)
alltd(s) = s <+ all(alltd(s))
alltd(switch)
46
Const
Mul
Const
3 4 5
Const
Add

95. example
Term Rewriting
Stratego
switch: Mul(e1, e2) -> Mul(e2, e1)
alltd(s) = s <+ all(alltd(s))
alltd(switch)
46
Const
Mul
Const
3 4 5
Const
Add1

96. example
Term Rewriting
Stratego
switch: Mul(e1, e2) -> Mul(e2, e1)
alltd(s) = s <+ all(alltd(s))
alltd(switch)
46
Const
Mul
Const
3 4 5
Const
Add1
2

97. example
Term Rewriting
Stratego
switch: Mul(e1, e2) -> Mul(e2, e1)
alltd(s) = s <+ all(alltd(s))
alltd(switch)
46
Const
Mul
Const
3 4 5
Const
Add1
2
3

98. example
Term Rewriting
Stratego
switch: Mul(e1, e2) -> Mul(e2, e1)
alltd(s) = s <+ all(alltd(s))
alltd(switch)
46
Const
Mul
Const
3 4 5
Const
Add1
2
3
4

99. example
Term Rewriting
Stratego
switch: Mul(e1, e2) -> Mul(e2, e1)
alltd(s) = s <+ all(alltd(s))
alltd(switch)
47
Const
Mul
Const
3 5 4
Const
Add1
2
3
4

100. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
bottomup(s) = all(bottomup(s)) ; s
bottomup(switch)
48
Const
Mul
Const
3 4 5
Const
Add

101. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
bottomup(s) = all(bottomup(s)) ; s
bottomup(switch)
48
Const
Mul
Const
3 4 5
Const
Add1

102. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
bottomup(s) = all(bottomup(s)) ; s
bottomup(switch)
48
Const
Mul
Const
3 4 5
Const
Add1
2

103. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
bottomup(s) = all(bottomup(s)) ; s
bottomup(switch)
48
Const
Mul
Const
3 4 5
Const
Add1
2
3

104. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
bottomup(s) = all(bottomup(s)) ; s
bottomup(try(switch))
49
Const
Mul
Const
3 4 5
Const
Add

105. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
bottomup(s) = all(bottomup(s)) ; s
bottomup(try(switch))
49
Const
Mul
Const
3 4 5
Const
Add1

106. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
bottomup(s) = all(bottomup(s)) ; s
bottomup(try(switch))
49
Const
Mul
Const
3 4 5
Const
Add1
2

107. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
bottomup(s) = all(bottomup(s)) ; s
bottomup(try(switch))
49
Const
Mul
Const
3 4 5
Const
Add1
2
3

108. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
bottomup(s) = all(bottomup(s)) ; s
bottomup(try(switch))
49
Const
Mul
Const
3 4 5
Const
Add1
2
3
4

109. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
bottomup(s) = all(bottomup(s)) ; s
bottomup(try(switch))
49
Const
Mul
Const
3 4 5
Const
Add1
2
3
4
5

110. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
bottomup(s) = all(bottomup(s)) ; s
bottomup(try(switch))
49
Const
Mul
Const
3 4 5
Const
Add1
2
3
4
5
6

111. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
bottomup(s) = all(bottomup(s)) ; s
bottomup(try(switch))
49
Const
Mul
Const
3 4 5
Const
Add1
2
3
4
5
6
7

112. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
bottomup(s) = all(bottomup(s)) ; s
bottomup(try(switch))
49
Const
Mul
Const
3 4 5
Const
Add1
2
3
4
5
6
7
8

113. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
bottomup(s) = all(bottomup(s)) ; s
bottomup(try(switch))
50
Const
Mul
Const
3 4 5
Const
Add1
2
3
4

114. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
bottomup(s) = all(bottomup(s)) ; s
bottomup(try(switch))
51
Const
Mul
Const
3 5 4
Const
Add1
2
3
4

115. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
bottomup(s) = all(bottomup(s)) ; s
bottomup(try(switch))
52
Const
Mul
Const
3 5 4
Const
Add1

116. Mul
Const
3
Const
5 4
Const
Add
example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
bottomup(s) = all(bottomup(s)) ; s
bottomup(try(switch))
53
1

117. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
innermost(s) = bottomup(try(s ; innermost(s)))
innermost(switch)
54
Const
Mul
Const
3 4 5
Const
Add

118. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
innermost(s) = bottomup(try(s ; innermost(s)))
innermost(switch)
54
Const
Mul
Const
3 4 5
Const
Add1

119. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
innermost(s) = bottomup(try(s ; innermost(s)))
innermost(switch)
54
Const
Mul
Const
3 4 5
Const
Add1
2

120. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
innermost(s) = bottomup(try(s ; innermost(s)))
innermost(switch)
54
Const
Mul
Const
3 4 5
Const
Add1
2
3

121. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
innermost(s) = bottomup(try(s ; innermost(s)))
innermost(switch)
54
Const
Mul
Const
3 4 5
Const
Add1
2
3
4

122. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
innermost(s) = bottomup(try(s ; innermost(s)))
innermost(switch)
54
Const
Mul
Const
3 4 5
Const
Add1
2
3
4
5

123. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
innermost(s) = bottomup(try(s ; innermost(s)))
innermost(switch)
54
Const
Mul
Const
3 4 5
Const
Add1
2
3
4
5
6

124. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
innermost(s) = bottomup(try(s ; innermost(s)))
innermost(switch)
54
Const
Mul
Const
3 4 5
Const
Add1
2
3
4
5
6
7

125. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
innermost(s) = bottomup(try(s ; innermost(s)))
innermost(switch)
54
Const
Mul
Const
3 4 5
Const
Add1
2
3
4
5
6
7
8

126. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
innermost(s) = bottomup(try(s ; innermost(s)))
innermost(switch)
55
Const
Mul
Const
3 4 5
Const
Add1
2
3
4

127. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
innermost(s) = bottomup(try(s ; innermost(s)))
innermost(switch)
56
Const
Mul
Const
3 5 4
Const
Add1
2
3
4

128. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
innermost(s) = bottomup(try(s ; innermost(s)))
innermost(switch)
56
Const
Mul
Const
3 5 4
Const
Add1
2
3
4
9

129. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
innermost(s) = bottomup(try(s ; innermost(s)))
innermost(switch)
56
Const
Mul
Const
3 5 4
Const
Add1
2
3
4
9
10

130. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
innermost(s) = bottomup(try(s ; innermost(s)))
innermost(switch)
56
Const
Mul
Const
3 5 4
Const
Add1
2
3
4
9
10
11

131. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
innermost(s) = bottomup(try(s ; innermost(s)))
innermost(switch)
56
Const
Mul
Const
3 5 4
Const
Add1
2
3
4
9
10
11
12

132. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
innermost(s) = bottomup(try(s ; innermost(s)))
innermost(switch)
57
Const
Mul
Const
3 5 4
Const
Add1
2
3
4

133. example
Term Rewriting
Stratego
switch: Add(e1, e2) -> Add(e2, e1)
switch: Mul(e1, e2) -> Mul(e2, e1)
innermost(s) = bottomup(try(s ; innermost(s)))
innermost(switch)
58
Const
Mul
Const
3 4 5
Const
Add1
2
3
4

134. lessons learned
Term Rewriting
Summary
59

135. lessons learned
Term Rewriting
Summary
How do you define AST transformations in Stratego?
• signatures
• rewrite rules
• rewrite strategies
• strategy combinators
59

136. lessons learned
Term Rewriting
Summary
How do you define AST transformations in Stratego?
• signatures
• rewrite rules
• rewrite strategies
• strategy combinators
What kind of strategies can you find in the Stratego library?
• arithmetics
• map, zip, foldr
• generic traversals
59

137. learn more
Term Rewriting
Literature
60

138. learn more
Term Rewriting
Literature
Spoofax
Lennart C. L. Kats, Eelco Visser: The Spoofax Language Workbench.
Rules for Declarative Specification of Languages and IDEs. OOPSLA
2010
http://www.spoofax.org
60

139. learn more
Term Rewriting
Literature
Spoofax
Lennart C. L. Kats, Eelco Visser: The Spoofax Language Workbench.
Rules for Declarative Specification of Languages and IDEs. OOPSLA
2010
http://www.spoofax.org
Stratego
Martin Bravenboer, Karl Trygve Kalleberg, Rob Vermaas, Eelco Visser:
Stratego/XT 0.17. A language and toolset for program transformation.
Science of Computer Programming, 72(1-2), 2008.
http://www.strategoxt.org
60

140. Software Languages 61
Except where otherwise noted, this work is licensed under

141. Software Languages 62
attribution
slide title author license
1, 35 Programming language textbooks K.lee public domain
2 The Bigger Picture F. Delventhal CC BY 2.0
5 Rose 2 des Kleinen Prinzen Antoine Saint-Exupéry public domain
11 Dog and owner on Ballykinler Beach Jonny Green CC BY 2.0
12 Fashionable melange of English words (1) trialsanderrors public domain
13 Gift asenat29 CC BY 2.0
13 Toxic John Morgan CC BY 2.0
14 Latin Grammar Anthony Nelzin
15 Ginkgo Biloba Johann Wolfgang von Goethe public domain
16 Sub-deb slang genibee CC BY-NC 2.0
17 Wednesday Michael Fawcett CC BY-NC-SA 2.0
19, 25, 67 Thesaurus Enoch Lau CC BY-SA 3.0
22
The captured Swiftsure, Seven Oaks, Loyal
George and Convertine brought through
Goeree Gat
Willem van de Velde the Younger public domain

142. Software Languages 63
Stra
slide title author license
23 Tower of Babel Pieter Bruegel the Elder public domain
26 The Ashtadhyayi translated by Srisa Chandra Vasu public domain
27 Buchdruckerduden public domain
28
Boeing 737-300 -400 -500 Manitenance
Manual Alaska Airlines
Bill Abbott CC BY-SA 2.0
30 Esperanto public domain
31 Quenya Juanma Pérez Rabasco CC BY 2.0
32 Klingon Dictionary Josh Bancroft CC BY-NC 2.0
33 Overweight Na'vi HARRY NGUYEN CC BY 2.0
36, 45, 46 IBM Electronic Data Processing Machine NASA public domain
41 Tiger Bernard Landgraf CC BY-SA 3.0
42 The C Programming Language Bill Bradford CC BY 2.0
43 Italian Java book cover
49-73 PICOL icons Melih Bilgil CC BY 3.0