SlideShare a Scribd company logo

Declarative Semantics Definition - Term Rewriting

Guido Wachsmuth, profile picture
Guido Wachsmuth

This document discusses term rewriting and its applications in compiler construction. It covers term rewriting systems, rewrite rules that transform terms, and rewrite strategies that control rule application. Examples are provided for desugaring code using rewrite rules and constant folding arithmetic expressions using rewrite rules and strategies. Stratego is presented as a domain-specific language for program transformation based on term rewriting.

EducationTechnology
1 of 142
Downloaded 61 times
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
Challenge the future Delft University of Technology Course IN4303 2013/14 Compiler Construction Guido Wachsmuth Declarative Semantics Definition Term Rewriting
today’s lecture Term Rewriting Overview manual implementation • static analysis & error checking • code generation • semantic editor services domain-specific language • Stratego • transform ASTs • working on ATerms • declarative style 2
Term Rewriting overview I 3
architecture Term Rewriting Modern Compilers in IDEs 4 Source Code
architecture Term Rewriting Modern Compilers in IDEs 4 Source Code parse
architecture Term Rewriting Modern Compilers in IDEs 4 Source Code parse check
architecture Term Rewriting Modern Compilers in IDEs 4 Source Code parse check
architecture Term Rewriting Modern Compilers in IDEs 4 Source Code parse generate Machine Code check
manual implementation Term Rewriting Traditional Compiler Compilers 5 Language Implementation compile Compiler
compilation + compilation Term Rewriting Traditional Compiler Compilers 6 Language Implementation compile Compiler Language Definition compile
compilation + interpretation Term Rewriting Traditional Compiler Compilers 7 interpret Interpreter Language Definition compile Language Implementation
compilation + interpretation Term Rewriting Spoofax Language Workbench 8 interpret Generic Parser Syntax Definition compile Parse Table
manual implementation Term Rewriting Spoofax Language Workbench Stratego • declarative DSL • domain: program transformation • means to manipulate ASTs • working on ATerms • compiles to C or Java Stratego in Spoofax • static analysis & error checking • code generation • semantic editor services 9
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
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
Term Rewriting signatures II 12
context-free syntax "-" Exp -> Exp {cons("Uminus")} Exp "+" Exp -> Exp {cons("Plus")} Exp "-" Exp -> Exp {cons("Minus")} Exp "*" Exp -> Exp {cons("Times")} Exp "/" Exp -> Exp {cons("Divide")} Exp "=" Exp -> Exp {cons("Eq")} Exp "<>" Exp -> Exp {cons("Neq")} Exp ">" Exp -> Exp {cons("Gt")} Exp "<" Exp -> Exp {cons("Lt")} Exp ">=" Exp -> Exp {cons("Geq")} Exp "<=" Exp -> Exp {cons("Leq")} Exp "&" Exp -> Exp {cons("And")} Exp "|" Exp -> Exp {cons("Or")} Term Rewriting Signatures signature constructors Uminus : Exp -> Exp Plus : Exp * Exp -> Exp Minus : Exp * Exp -> Exp Times : Exp * Exp -> Exp Divide : 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 And : Exp * Exp -> Exp Or : Exp * Exp -> Exp 13
signature Term Rewriting signature constructors Constructor : Cons -> Term Application : Cons * List(Term) -> Term List : List(Term) -> Term Tuple : List(Term) -> Term signature constructors Nil : -> List(a) Cons : a * List(a) -> List(a) Conc : List(a) * List(a) -> List(a) 14 ATerms in Stratego
Term Rewriting rewrite rules III 15
Term Rewriting Desugaring if x then printint(x) 16 if x then printint(x) else ()
Term Rewriting Desugaring if x then printint(x) 16 if x then printint(x) else () IfThen( Var("x") , Call( "printint" , [Var("x")] ) ) IfThenElse( Var("x") , Call( "printint" , [Var("x")] ) , NoVal() )
desugar: IfThen(e1, e2) -> IfThenElse(e1, e2, NoVal()) Term Rewriting Desugaring if x then printint(x) 16 if x then printint(x) else () IfThen( Var("x") , Call( "printint" , [Var("x")] ) ) IfThenElse( Var("x") , Call( "printint" , [Var("x")] ) , NoVal() )
desugar: IfThen(e1, e2) -> IfThenElse(e1, e2, NoVal()) Term Rewriting Desugaring if x then printint(x) 16 if x then printint(x) else () IfThen( Var("x") , Call( "printint" , [Var("x")] ) ) IfThenElse( Var("x") , Call( "printint" , [Var("x")] ) , NoVal() ) pattern matching
desugar: IfThen(e1, e2) -> IfThenElse(e1, e2, NoVal()) Term Rewriting Desugaring if x then printint(x) 16 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
desugar: IfThen(e1, e2) -> IfThenElse(e1, e2, NoVal()) Term Rewriting Desugaring if x then printint(x) 16 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
desugar: IfThen(e1, e2) -> IfThenElse(e1, e2, NoVal()) Term Rewriting Desugaring if x then printint(x) 16 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
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 17
Term Rewriting Constant Folding x := 21 + 21 + x 18 x := 42 + x
Term Rewriting Constant Folding x := 21 + 21 + x 18 x := 42 + x Assign( Var("x") , Plus( Plus( Int("21") , Int("21") ) , Var("x") ) ) Assign( Var("x") , Plus( Int("42") , Var("x") ) )
eval: Bop(PLUS(), Int(i1), Int(i2)) -> Int(i3) where <addS> (i1, i2) => i3 Term Rewriting Constant Folding x := 21 + 21 + x 18 x := 42 + x Assign( Var("x") , Plus( Plus( Int("21") , Int("21") ) , Var("x") ) ) Assign( Var("x") , Plus( Int("42") , Var("x") ) )
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 19
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 20
example: map Term Rewriting Rules with Parameters 21 [ 1 , 2 , 3 ] [ 2 , 3 , 4 ] map(inc)
example: map Term Rewriting Rules with Parameters 21 [ 1 , 2 , 3 ] [ 2 , 3 , 4 ] map(inc) inc 1 2 3 2 3 4inc inc
example: map Term Rewriting Rules with Parameters map(s): [] -> [] map(s): [x|xs] -> [<s> x | <map(s)> xs] 21 [ 1 , 2 , 3 ] [ 2 , 3 , 4 ] map(inc) inc 1 2 3 2 3 4inc inc
example: zip Term Rewriting Rules with Parameters 22 [ 1 , 2 , 3 ] [ (1,4) , (2,5) , (3,6) ] [ 4 , 5 , 6 ]zip
example: zip Term Rewriting Rules with Parameters 22 [ 1 , 2 , 3 ] [ (1,4) , (2,5) , (3,6) ] [ 4 , 5 , 6 ]zip [ 1 , 2 , 3 ] [ 5 , 7 , 9 ] [ 4 , 5 , 6 ]zip(add)
example: zip Term Rewriting Rules with Parameters 22 [ 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)
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) 22 [ 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)
example: fold Term Rewriting Rules with Parameters 23 [1,2,3] foldr(!0,add) 6
example: fold Term Rewriting Rules with Parameters 23 [1,2,3] foldr(!0,add) 6 [] 0 [3] 3 [2,3] 56 [1,2,3]
example: fold Term Rewriting Rules with Parameters foldr(s1,s2): [] -> <s1> foldr(s1,s2): [x|xs] -> <s2> (x,<foldr(s1,s2)> xs) 23 [1,2,3] foldr(!0,add) 6 [] 0 [3] 3 [2,3] 56 [1,2,3]
example: inverse Term Rewriting Rules with Parameters 24 [1,2,3] inverse(|[]) [3,2,1]
example: inverse Term Rewriting Rules with Parameters 24 [1,2,3] inverse(|[]) [3,2,1] [2,3] [1][] [1,2,3] [3] [2,1] [3,2,1] []
example: inverse Term Rewriting Rules with Parameters inverse(|is): [] -> is inverse(|is): [x|xs] -> <inverse(|[x|is])> xs 24 [1,2,3] inverse(|[]) [3,2,1] [2,3] [1][] [1,2,3] [3] [2,1] [3,2,1] []
Term Rewriting 25 coffee break
Term Rewriting rewrite strategies IV 26
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 27
example Term Rewriting Stratego module desugar imports include/Tiger operators strategies desugar-all = innermost(desugar) rules desugar: IfThen(e1, e2) -> IfThenElse(e1, e2, NoVal()) 28
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 29
Term Rewriting Strategy Combinators identity id 30
Term Rewriting Strategy Combinators identity id failure fail 30
Term Rewriting Strategy Combinators identity id failure fail sequential composition s1 ; s2 30
Term Rewriting Strategy Combinators identity id failure fail sequential composition s1 ; s2 deterministic choice s1 <+ s2 30
Term Rewriting Strategy Combinators identity id failure fail sequential composition s1 ; s2 deterministic choice s1 <+ s2 non-deterministic choice s1 + s2 30
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 30
variables Term Rewriting Strategy Combinators pattern matching ?t 31
variables Term Rewriting Strategy Combinators pattern matching ?t pattern instantiation !t 31
variables Term Rewriting Strategy Combinators pattern matching ?t pattern instantiation !t strategy application <s> t ≣ !t ; s 31
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 31
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} 31
rules and strategies Term Rewriting Strategy Combinators named rewrite rule l: t1 -> t2 where s ≣ l = ?t1 ; s ; !t2 32
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 32
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 32
examples Term Rewriting Strategy Combinators try(s) = s <+ id repeat(s) = try(s ; repeat(s)) 33
examples Term Rewriting Strategy Combinators try(s) = s <+ id repeat(s) = try(s ; repeat(s)) topdown(s) = s ; all(topdown(s)) 33
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)) 33
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) 33
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) 33
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) 33
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) 33
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) 33
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) 34 Const Mul Const 3 4 5 Const Add
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) 34 Const Mul Const 3 4 5 Const Add1
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) 35 Mul Const 3 Const 4 5 Const Add1
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) 35 Mul Const 3 Const 4 5 Const Add1 2
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) 36 Mul Const 3 Const 5 4 Const Add1 2
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) 36 Mul Const 3 Const 5 4 Const Add1 2 3
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)) 37 Const Mul Const 3 4 5 Const Add
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)) 37 Const Mul Const 3 4 5 Const Add1
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)) 38 Mul Const 3 Const 4 5 Const Add1
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)) 38 Mul Const 3 Const 4 5 Const Add1 2
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)) 39 Mul Const 3 Const 5 4 Const Add1 2
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)) 39 Mul Const 3 Const 5 4 Const Add1 2 3
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)) 39 Mul Const 3 Const 5 4 Const Add1 2 3 4
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)) 39 Mul Const 3 Const 5 4 Const Add1 2 3 4 5
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)) 39 Mul Const 3 Const 5 4 Const Add1 2 3 4 5 6
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)) 39 Mul Const 3 Const 5 4 Const Add1 2 3 4 5 6 7
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)) 39 Mul Const 3 Const 5 4 Const Add1 2 3 4 5 6 7 8
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) 40 Const Mul Const 3 4 5 Const Add
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) 40 Const Mul Const 3 4 5 Const Add1
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) 41 Mul Const 3 Const 4 5 Const Add1
example Term Rewriting Stratego switch: Mul(e1, e2) -> Mul(e2, e1) alltd(s) = s <+ all(alltd(s)) alltd(switch) 42 Const Mul Const 3 4 5 Const Add
example Term Rewriting Stratego switch: Mul(e1, e2) -> Mul(e2, e1) alltd(s) = s <+ all(alltd(s)) alltd(switch) 42 Const Mul Const 3 4 5 Const Add1
example Term Rewriting Stratego switch: Mul(e1, e2) -> Mul(e2, e1) alltd(s) = s <+ all(alltd(s)) alltd(switch) 42 Const Mul Const 3 4 5 Const Add1 2
example Term Rewriting Stratego switch: Mul(e1, e2) -> Mul(e2, e1) alltd(s) = s <+ all(alltd(s)) alltd(switch) 42 Const Mul Const 3 4 5 Const Add1 2 3
example Term Rewriting Stratego switch: Mul(e1, e2) -> Mul(e2, e1) alltd(s) = s <+ all(alltd(s)) alltd(switch) 42 Const Mul Const 3 4 5 Const Add1 2 3 4
example Term Rewriting Stratego switch: Mul(e1, e2) -> Mul(e2, e1) alltd(s) = s <+ all(alltd(s)) alltd(switch) 43 Const Mul Const 3 5 4 Const Add1 2 3 4
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) 44 Const Mul Const 3 4 5 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(switch) 44 Const Mul Const 3 4 5 Const Add1
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) 44 Const Mul Const 3 4 5 Const Add1 2
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) 44 Const Mul Const 3 4 5 Const Add1 2 3
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)) 45 Const Mul Const 3 4 5 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)) 45 Const Mul Const 3 4 5 Const Add1
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)) 45 Const Mul Const 3 4 5 Const Add1 2
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)) 45 Const Mul Const 3 4 5 Const Add1 2 3
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)) 45 Const Mul Const 3 4 5 Const Add1 2 3 4
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)) 45 Const Mul Const 3 4 5 Const Add1 2 3 4 5
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)) 45 Const Mul Const 3 4 5 Const Add1 2 3 4 5 6
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)) 45 Const Mul Const 3 4 5 Const Add1 2 3 4 5 6 7
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)) 45 Const Mul Const 3 4 5 Const Add1 2 3 4 5 6 7 8
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)) 46 Const Mul Const 3 4 5 Const Add1 2 3 4
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)) 47 Const Mul Const 3 5 4 Const Add1 2 3 4
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)) 48 Const Mul Const 3 5 4 Const Add1
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)) 49 1
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) 50 Const Mul Const 3 4 5 Const Add
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) 50 Const Mul Const 3 4 5 Const Add1
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) 50 Const Mul Const 3 4 5 Const Add1 2
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) 50 Const Mul Const 3 4 5 Const Add1 2 3
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) 50 Const Mul Const 3 4 5 Const Add1 2 3 4
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) 50 Const Mul Const 3 4 5 Const Add1 2 3 4 5
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) 50 Const Mul Const 3 4 5 Const Add1 2 3 4 5 6
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) 50 Const Mul Const 3 4 5 Const Add1 2 3 4 5 6 7
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) 50 Const Mul Const 3 4 5 Const Add1 2 3 4 5 6 7 8
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) 51 Const Mul Const 3 4 5 Const Add1 2 3 4
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) 52 Const Mul Const 3 5 4 Const Add1 2 3 4
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) 52 Const Mul Const 3 5 4 Const Add1 2 3 4 9
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) 52 Const Mul Const 3 5 4 Const Add1 2 3 4 9 10
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) 52 Const Mul Const 3 5 4 Const Add1 2 3 4 9 10 11
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) 52 Const Mul Const 3 5 4 Const Add1 2 3 4 9 10 11 12
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) 53 Const Mul Const 3 5 4 Const Add1 2 3 4
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
Term Rewriting summary V 55
lessons learned Term Rewriting Summary 56
lessons learned Term Rewriting Summary How do you define AST transformations in Stratego? • signatures • rewrite rules • rewrite strategies • strategy combinators 56
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 56
learn more Term Rewriting Literature 57
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 57
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 57
coming next Term Rewriting Outlook declarative semantics definition • Lecture 5: Static Analysis and Error Checking • Lecture 6: Code Generation Assignment Oct 2: MiniJava grammar in SDF • submit on Blackboard Lab Oct 03 • syntactic editor services • pretty-printer for MiniJava 58
Term Rewriting 59
attribution & copyrights Term Rewriting Pictures Slides 1, 9, 10, 20, 27: Stratego by Kendrick Arnett, some rights reserved Slides 23-26, 28, 31, 37-39, 41-43: PICOL icons by Melih Bilgil, some rights reserved Slide 14: Thesaurus by Enoch Lau, some rights reserved Slide 21: Google Maps Street View Camera by Ian Britton, some rights reserved Slide 22: Zipper by Rabensteiner, some rights reserved Slide 23: Fold by Kim Piper Werker, some rights reserved Slide 24: Inverse by lanchongzi, some rights reserved Slide 25: Maxwell's by Dominica Williamson, some rights reserved Slide 58: Reichstag by Wolfgang Staudt, some rights reserved 60

More Related Content

PDF
Term Rewriting
Eelco Visser
 
PDF
Introduction - Imperative and Object-Oriented Languages
Guido Wachsmuth
 
PDF
Declarative Semantics Definition - Static Analysis and Error Checking
Guido Wachsmuth
 
PDF
Static Analysis
Eelco Visser
 
PDF
Pure and Declarative Syntax Definition: Paradise Lost and Regained
Guido Wachsmuth
 
PDF
Static name resolution
Eelco Visser
 
PDF
Declarative Syntax Definition - Grammars and Trees
Guido Wachsmuth
 
PDF
Lexical Analysis
Eelco Visser
 
Term Rewriting
Eelco Visser
 
Introduction - Imperative and Object-Oriented Languages
Guido Wachsmuth
 
Declarative Semantics Definition - Static Analysis and Error Checking
Guido Wachsmuth
 
Static Analysis
Eelco Visser
 
Pure and Declarative Syntax Definition: Paradise Lost and Regained
Guido Wachsmuth
 
Static name resolution
Eelco Visser
 
Declarative Syntax Definition - Grammars and Trees
Guido Wachsmuth
 
Lexical Analysis
Eelco Visser
 

What's hot (20)

PDF
Syntax Definition
Guido Wachsmuth
 
PDF
Dynamic Semantics
Eelco Visser
 
PDF
Syntax Definition
Eelco Visser
 
PDF
Formal Grammars
Eelco Visser
 
PDF
Declare Your Language: Syntactic (Editor) Services
Eelco Visser
 
PDF
LL Parsing
Eelco Visser
 
PDF
Compiler Components and their Generators - Traditional Parsing Algorithms
Guido Wachsmuth
 
PDF
Declare Your Language: Syntax Definition
Eelco Visser
 
KEY
Compiler Components and their Generators - Lexical Analysis
Guido Wachsmuth
 
PDF
Declare Your Language: Type Checking
Eelco Visser
 
PDF
Declare Your Language: Transformation by Strategic Term Rewriting
Eelco Visser
 
PDF
Declare Your Language: Name Resolution
Eelco Visser
 
PDF
Compiler Construction | Lecture 8 | Type Constraints
Eelco Visser
 
PDF
Compiler Construction | Lecture 5 | Transformation by Term Rewriting
Eelco Visser
 
PDF
CS4200 2019 | Lecture 5 | Transformation by Term Rewriting
Eelco Visser
 
PDF
Programming languages
Eelco Visser
 
PDF
Compiler Construction | Lecture 9 | Constraint Resolution
Eelco Visser
 
PDF
Dynamic Semantics Specification and Interpreter Generation
Eelco Visser
 
PDF
Ch04
Hankyo
 
PDF
Declarative Type System Specification with Statix
Eelco Visser
 
Syntax Definition
Guido Wachsmuth
 
Dynamic Semantics
Eelco Visser
 
Syntax Definition
Eelco Visser
 
Formal Grammars
Eelco Visser
 
Declare Your Language: Syntactic (Editor) Services
Eelco Visser
 
LL Parsing
Eelco Visser
 
Compiler Components and their Generators - Traditional Parsing Algorithms
Guido Wachsmuth
 
Declare Your Language: Syntax Definition
Eelco Visser
 
Compiler Components and their Generators - Lexical Analysis
Guido Wachsmuth
 
Declare Your Language: Type Checking
Eelco Visser
 
Declare Your Language: Transformation by Strategic Term Rewriting
Eelco Visser
 
Declare Your Language: Name Resolution
Eelco Visser
 
Compiler Construction | Lecture 8 | Type Constraints
Eelco Visser
 
Compiler Construction | Lecture 5 | Transformation by Term Rewriting
Eelco Visser
 
CS4200 2019 | Lecture 5 | Transformation by Term Rewriting
Eelco Visser
 
Programming languages
Eelco Visser
 
Compiler Construction | Lecture 9 | Constraint Resolution
Eelco Visser
 
Dynamic Semantics Specification and Interpreter Generation
Eelco Visser
 
Ch04
Hankyo
 
Declarative Type System Specification with Statix
Eelco Visser
 
Ad

Viewers also liked (16)

PDF
Declarative Semantics Definition - Code Generation
Guido Wachsmuth
 
KEY
Declarative Syntax Definition - Pretty Printing
Guido Wachsmuth
 
KEY
Compiling Imperative and Object-Oriented Languages - Activation Records
Guido Wachsmuth
 
KEY
Compiling Imperative and Object-Oriented Languages - Dataflow Analysis
Guido Wachsmuth
 
PDF
Domain-Specific Type Systems
Guido Wachsmuth
 
KEY
Compiling Imperative and Object-Oriented Languages - Register Allocation
Guido Wachsmuth
 
PDF
K to 12 TLE Curriculum Guide for Automotive
Dr. Joy Kenneth Sala Biasong
 
PDF
Compiler Components and their Generators - LR Parsing
Guido Wachsmuth
 
KEY
Compiling Imperative and Object-Oriented Languages - Garbage Collection
Guido Wachsmuth
 
PDF
Language
Guido Wachsmuth
 
PPT
Definition Of Terms
Patrice Aguillo
 
PDF
K to 12 automotive teachers guide
Noel Tan
 
PDF
K to 12 Automotive Learning Module
Dr. Joy Kenneth Sala Biasong
 
PPTX
Beginners' Guide to Powerpoint
Laura Hampton
 
PPSX
Research or Proposal Writing - DEFINITION OF TERMS
Jaime Alfredo Cabrera
 
PDF
K to 12 TLE Curriculum Guide
Dr. Joy Kenneth Sala Biasong
 
Declarative Semantics Definition - Code Generation
Guido Wachsmuth
 
Declarative Syntax Definition - Pretty Printing
Guido Wachsmuth
 
Compiling Imperative and Object-Oriented Languages - Activation Records
Guido Wachsmuth
 
Compiling Imperative and Object-Oriented Languages - Dataflow Analysis
Guido Wachsmuth
 
Domain-Specific Type Systems
Guido Wachsmuth
 
Compiling Imperative and Object-Oriented Languages - Register Allocation
Guido Wachsmuth
 
K to 12 TLE Curriculum Guide for Automotive
Dr. Joy Kenneth Sala Biasong
 
Compiler Components and their Generators - LR Parsing
Guido Wachsmuth
 
Compiling Imperative and Object-Oriented Languages - Garbage Collection
Guido Wachsmuth
 
Language
Guido Wachsmuth
 
Definition Of Terms
Patrice Aguillo
 
K to 12 automotive teachers guide
Noel Tan
 
K to 12 Automotive Learning Module
Dr. Joy Kenneth Sala Biasong
 
Beginners' Guide to Powerpoint
Laura Hampton
 
Research or Proposal Writing - DEFINITION OF TERMS
Jaime Alfredo Cabrera
 
K to 12 TLE Curriculum Guide
Dr. Joy Kenneth Sala Biasong
 
Ad

Similar to Declarative Semantics Definition - Term Rewriting (20)

PPT
Lex (lexical analyzer)
Sami Said
 
PPTX
R Language Introduction
Khaled Al-Shamaa
 
PDF
CS4200 2019 | Lecture 4 | Syntactic Services
Eelco Visser
 
PPT
Chapter Eight(3)
bolovv
 
PPT
Interm codegen
Anshul Sharma
 
PPT
LEX lexical analyzer for compiler theory.ppt
dralexpasion
 
PDF
Rcpp: Seemless R and C++
Romain Francois
 
PDF
Design Patterns - Compiler Case Study - Hands-on Examples
Ganesh Samarthyam
 
PDF
Rcpp: Seemless R and C++
Romain Francois
 
PPTX
HDL17_MIPS CPU Design using Verilog.pptx
das85271
 
PDF
ANSI C REFERENCE CARD
Tia Ricci
 
PDF
Compiler Construction | Lecture 14 | Interpreters
Eelco Visser
 
ODP
Scala as a Declarative Language
vsssuresh
 
PPT
Profiling and optimization
g3_nittala
 
PDF
[FT-11][suhorng] “Poor Man's” Undergraduate Compilers
Functional Thursday
 
PPTX
A Replay Approach to Software Validation
James Pascoe
 
PPTX
Learning C++ - Introduction to c++ programming 1
Ali Aminian
 
PDF
Data-Oriented Programming with Clojure and Jackdaw (Charles Reese, Funding Ci...
confluent
 
PDF
cel shading as PDF and Python description
MarcosLuis32
 
PDF
Faster Python, FOSDEM
Victor Stinner
 
Lex (lexical analyzer)
Sami Said
 
R Language Introduction
Khaled Al-Shamaa
 
CS4200 2019 | Lecture 4 | Syntactic Services
Eelco Visser
 
Chapter Eight(3)
bolovv
 
Interm codegen
Anshul Sharma
 
LEX lexical analyzer for compiler theory.ppt
dralexpasion
 
Rcpp: Seemless R and C++
Romain Francois
 
Design Patterns - Compiler Case Study - Hands-on Examples
Ganesh Samarthyam
 
Rcpp: Seemless R and C++
Romain Francois
 
HDL17_MIPS CPU Design using Verilog.pptx
das85271
 
ANSI C REFERENCE CARD
Tia Ricci
 
Compiler Construction | Lecture 14 | Interpreters
Eelco Visser
 
Scala as a Declarative Language
vsssuresh
 
Profiling and optimization
g3_nittala
 
[FT-11][suhorng] “Poor Man's” Undergraduate Compilers
Functional Thursday
 
A Replay Approach to Software Validation
James Pascoe
 
Learning C++ - Introduction to c++ programming 1
Ali Aminian
 
Data-Oriented Programming with Clojure and Jackdaw (Charles Reese, Funding Ci...
confluent
 
cel shading as PDF and Python description
MarcosLuis32
 
Faster Python, FOSDEM
Victor Stinner
 

Recently uploaded (20)

PPTX
Lesson notes of climatology university.
sgladness67
 
PDF
BÀI TẬP BỔ TRỢ 4 KỸ NĂNG TIẾNG ANH 9 GLOBAL SUCCESS - CẢ NĂM - BÁM SÁT FORM Đ...
Nguyen Thanh Tu Collection
 
PDF
TR - Agricultural Crops Production NC III.pdf
avgilmegino3
 
PPTX
1st Inaugural Professorial Lecture held on 19th February 2020 (Governance and...
kawisojames10
 
PPTX
GDM (1) (1).pptx small presentation for students
shrawanbpkihs
 
PDF
RMMM.pdf make it easy to upload and study
sajedul2
 
PDF
O5-L3 Freight Transport Ops (International) V1.pdf
labyankof
 
PPTX
Institutional Correction lecture only . . .
limvtheghins
 
PDF
Abdominal Access Techniques with Prof. Dr. R K Mishra
mohitsuren827
 
PDF
STATICS OF THE RIGID BODIES Hibbelers.pdf
pascualasturiaskaye4
 
PPTX
IMMUNITY IMMUNITY refers to protection against infection, and the immune syst...
shilpa939953
 
PDF
Microbial disease of the cardiovascular and lymphatic systems
KeyaSharma
 
PDF
01-Introduction-to-Information-Management.pdf
PrinceIbarra
 
PDF
Black Hat USA 2025 - Micro ICS Summit - ICS/OT Threat Landscape
Chris Sistrunk
 
PDF
Insiders guide to clinical Medicine.pdf
AbhishekPatil315128
 
PDF
Complications of Minimal Access Surgery at WLH
mohitsuren827
 
PDF
FourierSeries-QuestionsWithAnswers(Part-A).pdf
Raji Murugan
 
PDF
grade 11-chemistry_fetena_net_5883.pdf teacher guide for all student
banteamlakmebratu738
 
PPTX
Renaissance Architecture: A Journey from Faith to Humanism
DrMonicaSharma
 
PPTX
Introduction_to_Human_Anatomy_and_Physiology_for_B.Pharm.pptx
chetansingh379583
 
Lesson notes of climatology university.
sgladness67
 
BÀI TẬP BỔ TRỢ 4 KỸ NĂNG TIẾNG ANH 9 GLOBAL SUCCESS - CẢ NĂM - BÁM SÁT FORM Đ...
Nguyen Thanh Tu Collection
 
TR - Agricultural Crops Production NC III.pdf
avgilmegino3
 
1st Inaugural Professorial Lecture held on 19th February 2020 (Governance and...
kawisojames10
 
GDM (1) (1).pptx small presentation for students
shrawanbpkihs
 
RMMM.pdf make it easy to upload and study
sajedul2
 
O5-L3 Freight Transport Ops (International) V1.pdf
labyankof
 
Institutional Correction lecture only . . .
limvtheghins
 
Abdominal Access Techniques with Prof. Dr. R K Mishra
mohitsuren827
 
STATICS OF THE RIGID BODIES Hibbelers.pdf
pascualasturiaskaye4
 
IMMUNITY IMMUNITY refers to protection against infection, and the immune syst...
shilpa939953
 
Microbial disease of the cardiovascular and lymphatic systems
KeyaSharma
 
01-Introduction-to-Information-Management.pdf
PrinceIbarra
 
Black Hat USA 2025 - Micro ICS Summit - ICS/OT Threat Landscape
Chris Sistrunk
 
Insiders guide to clinical Medicine.pdf
AbhishekPatil315128
 
Complications of Minimal Access Surgery at WLH
mohitsuren827
 
FourierSeries-QuestionsWithAnswers(Part-A).pdf
Raji Murugan
 
grade 11-chemistry_fetena_net_5883.pdf teacher guide for all student
banteamlakmebratu738
 
Renaissance Architecture: A Journey from Faith to Humanism
DrMonicaSharma
 
Introduction_to_Human_Anatomy_and_Physiology_for_B.Pharm.pptx
chetansingh379583
 

Declarative Semantics Definition - Term Rewriting

Editor's Notes