De presentatie wordt gedownload. Even geduld aub

De presentatie wordt gedownload. Even geduld aub

Zelfgemaakt datatype voor bomen nMet functies data Tree a = Bin (Tree a) (Tree a) | Leaf a foldTree :: Tree a  b foldTree (b,lf) (Bin le ri) = b (foldTree.

Verwante presentaties


Presentatie over: "Zelfgemaakt datatype voor bomen nMet functies data Tree a = Bin (Tree a) (Tree a) | Leaf a foldTree :: Tree a  b foldTree (b,lf) (Bin le ri) = b (foldTree."— Transcript van de presentatie:

1 Zelfgemaakt datatype voor bomen nMet functies data Tree a = Bin (Tree a) (Tree a) | Leaf a foldTree :: Tree a  b foldTree (b,lf) (Bin le ri) = b (foldTree (b,lf) le) (foldTree (b,lf) ri) foldTree (b,lf) (Leaf x) = lf x bbbbbb (, )  abab foldTree :: (b  b  b, a  b)  Tree a  b foldTree (b,lf) = f where f (Bin le ri) = b (f le) (f ri) f (Leaf x) = lf x

2 Voorbeelden van algebras data Tree a = Bin (Tree a) (Tree a) | Leaf a type TreeAlgebra a b = ( b  b  b, a  b ) data Expr = Add Expr Expr | Mul Expr Expr | Con Int type ExprAlgebra b = ( b  b  b, b  b  b, Int  b ) data Expr = Add Expr Expr | Mul Expr Expr | Con Int | Var String type ExprAlgebra b = ( b  b  b, b  b  b, Int  b, String  b )

3 Definitie “een algebra” nEen algebra bestaat uit ueen type ufuncties in een tupel countLeafsFuns :: TreeAlgebra a Int countLeafsFuns = ( (+), \x  1 ) nEen algebra bestaat uit ueen type dat het resultaat is van een fold, die ufuncties in een tupel neerzet in plaats van constructorfuncties nEen algebra voor een datatype bestaat uit ueen type dat het resultaat is van een fold, die ufuncties in een tupel neerzet in plaats van constructorfuncties van dat datatype “carrier set” “semantiek”

4 Algebras voor wederzijds recursieve datatypes data Stat a = Assign String (Expr a) | Print (Expr a) | Block [Stat a] data Expr a = Con a | Var String | Add (Expr a) (Expr a) type StatExprAlgebra a s e = ( ( String  e  s, e  s, [ s ]  s ), ( a  e, String  e, e  e  e ) ) foldStatExpr :: StatExprAlgebra a s e  Stat a  s foldStatExpr ((f1,f2,f3),(g1,g2,g3)) = f where f (Assign x e)= f1 x (g e) f (Print e)= f2 (g e) f (Block ss)= f3 (map f ss) g (Con c)= g1 c g (Var x)= g2 x g (Add e1 e2)= g3 (g e1) (g e2)

5 Definitie van foldExpr data Expr = Add Expr Expr | Mul Expr Expr | Con Int type ExprAlgebra b = ( b  b  b, b  b  b, Int  b ) foldExpr :: ExprAlgebra b  Expr  b foldExpr (a,m,c)= f where f (Add e1 e2)= a(f e1) (f e2) f (Mul e1 e2)= m(f e1) (f e2) f (Con n)= c n

6 Gebruik van ExprAlgebra data Expr = Add Expr Expr | Mul Expr Expr | Con Int type ExprAlgebra b = ( b  b  b, b  b  b, Int  b ) evalExpr :: Expr  Int evalExpr = foldExpr evalExprAlgebra evalExprAlgebra :: ExprAlgebra Int evalExprAlgebra = ( (+), (*), id )

7 Taal: syntax en semantiek “ * 5 ” Add (Con 3) (Mul (Con 4) (Con 5)) parseExpr evalExpr 23 = start p where p = … … … = fold a where a = (…,…,…,…)

8 Compositionaliteit nEen semantiek is compositioneel als de betekenis van een geheel een functie is van de betekenissen van de delen eval (Add x y) = add (eval x) (eval y) nEen compositionele semantiek kun je schrijven als fold over de expressie waarbij een algebra vervangingen geeft voor de constructoren

9 Verschillende semantieken “ * 5 ” Add (Con 3) (Mul (Con 4) (Con 5)) 23 evalExpr compileExpr Push 3 Push 4 Push 5 Apply (*) Apply (+) runExpr parseExpr :: String :: Expr :: Int:: Code = fold a where a = (…,…,…,…) a::ExprAlgebra Int = fold a where a = (…,…,…,…) a::ExprAlgebra Code

10 De compileer-semantiek nWat is “machinecode” ? nWat is een “machine-instructie” ? type Code = [ Instr ] data Instr = Push Int | Apply (Int  Int  Int)

11 Compiler: genereren van Code data Expr = Add Expr Expr | Mul Expr Expr | Con Int type ExprAlgebra b = ( b  b  b, b  b  b, Int  b ) evalExpr :: Expr  Int evalExpr = foldExpr evalExprAlgebra where evalExprAlgebra :: ExprAlgebra Int evalExprAlgebra = ( (+), (*), id ) compExpr :: Expr  Code compExpr = foldExpr compExprAlgebra where compExprAlgebra :: ExprAlgebra Code compExprAlgebra = ( add, mul, con ) mul :: Code  Code  Code mul c1 c2 = c1 ++ c2 ++ [Apply (*)] con n = [ Push n ]

12 Verschillende semantieken “ * 5 ” Add (Con 3) (Mul (Con 4) (Con 5)) 23 evalExpr compileExpr Push 3 Push 4 Push 5 Apply (*) Apply (+) runExpr parseExpr :: String :: Expr :: Int:: Code = fold a where a = (…,…,…,…) a::ExprAlgebra Int = fold a where a = (…,…,…,…) a::ExprAlgebra Code

13 Runner: simulatie van processor run :: Code  Stack  Stack run [ ] stack = stack run (instr:rest) stack = exec instr stack run rest ( ) exec :: Instr  Stack  Stack exec (Push x) stack= x : stack exec (Apply f) (y:x:stack)= f x y : stack runExpr :: Code  Int runExpr prog = run prog [ ] head ( )

14 Compiler correctheid evalExpr “ * 5 ” Add (Con 3) (Mul (Con 4) (Con 5)) 23 compileExpr Push 3 Push 4 Push 5 Apply (*) Apply (+) runExpr parseExpr runExpr (compileExpr e) = evalExpr e

15 Uitrekenen van expressies met variabelen data Expr = Add Expr Expr | Mul Expr Expr | Con Int type ExprAlgebra b = ( b  b  b, b  b  b, Int  b ) evalExpr :: Expr  Int evalExpr = foldExpr eAlgebra where eAlgebra :: ExprAlgebra Int eAlgebra = ( (+), (*), id ) data Expr = Add Expr Expr | Mul Expr Expr | Con Int | Var String type ExprAlgebra b = ( b  b  b, b  b  b, Int  b, String  b ), ???? ) evalExpr :: Env  Expr  Int evalExpr env = foldExpr eAlgebra where eAlgebra :: ExprAlgebra Int eAlgebra = ( (+), (*), id, ???? ), (env ?) ) BAD !!!

16 Uitrekenen van expressies met variabelen data Expr = Add Expr Expr | Mul Expr Expr | Con Int | Var String type ExprAlgebra b = ( b  b  b, b  b  b, Int  b, String  b ) evalExpr :: Expr  Env  Int evalExpr env = foldExpr eAlgebra where eAlgebra :: ExprAlgebra Int eAlgebra = ( (+), (*), id, (env?) ) evalExpr :: Expr  (Env  Int) evalExpr = foldExpr eAlgebra where eAlgebra :: ExprAlgebra Int eAlgebra = ( add, mul, con, var ) (Env  Int) evalExpr’ :: Expr  Int evalExpr’ expr = evalExpr expr [ ]

17 Uitrekenen van expressies met definities evalExpr :: Expr  Env  Int evalExpr env = foldExpr eAlgebra where eAlgebra :: ExprAlgebra (Env  Int) eAlgebra = ( add, mul, con, var ) data Expr = Add Expr Expr | Mul Expr Expr | Con Int | Var String type ExprAlgebra b = ( b  b  b, b  b  b, Int  b, String  b ), def ) data Expr = Add Expr Expr | Mul Expr Expr | Con Int | Var String | Def String Expr Expr type ExprAlgebra b = ( b  b  b, b  b  b, Int  b, String  b, String  b  b  b )

18 Uitrekenen van expressies met definities add :: b  b  b (Env  Int) Env  Int mul :: b  b  b (Env  Int) Env  Int con :: Int  b Env  Int var :: String  b Env  Int def :: String  b  b  b (Env  Int) Env  Int mul f g e = f e * g e con n e =n var x e =e ? x def x fd fb e =fb e(x, )( : )fd e con = const var = flip (?) def = ( ) add f g e =f e + g e

19 Verschillende semantieken “ * 5 ” Add (Con 3) (Mul (Con 4) (Con 5)) 23 evalExpr compileExpr Push 3 Push 4 Push 5 Apply (*) Apply (+) runExpr parseExpr :: String :: Expr :: Int:: Code = fold a where a = (…,…,…,…) a::ExprAlgebra Int = fold a where a = (…,…,…,…) a::ExprAlgebra Code

20 add :: b  b  b mul :: b  b  b con :: Int  b var :: String  b def :: String  b  b  b Compileren van expressies met definities mul f g e = con n e =[ Push n ] var x e =e ? x def x fd fb e =fb ( (x, fd e) : e ) add f g e = f e ++ g e ++ [Apply (+)] (Env  Code) Env  Code (Env  Code) Env  Code (Env  Code) Env  Code f e ++ g e ++ [Apply (*)]

21 Wat zit er in het Env ? nevalExpr ncompExpr type Env = [ (String, Int) ] type Env = [ (String, Code) ]

22 Compiler correctheid expressies met definities evalExpr “ * 5 ” Add (Con 3) (Mul (Con 4) (Con 5)) 23 compileExpr Push 3 Push 4 Push 5 Apply (*) Apply (+) runExpr parseExpr hd (run (compileExpr e) s) = evalExpr e runExpr (compileExpr e env) = evalExpr e env

23 Voorbeeld compileren van expressie “ 3+4*5 ” Push 3 Push 4 Push 5 Apply (*) Apply (+) Push 3 Push 2 Apply (+) Push 5 Apply (*) Apply (+) parseExpr compileExpr “ let x=2+2 in 3+x*5 ” parseExpr compileExpr Push 2 Apply (+) x

24 Voorbeeld compileren van expressie Push 3 Push 2 Apply (+) Push 5 Apply (*) Apply (+) “ let x=2+2 in 3+x*5 ” parseExpr compileExpr Push 2 Apply (+) x “ let x=2+2 in 3+x*x ” parseExpr compileExpr Push 3 Push 2 Apply (+) Push 2 Apply (+) Apply (*) Apply (+)

25 De compileer-semantiek nWat is “machinecode” ? nWat is een “machine-instructie” ? type Code = [ Instr ] data Instr = Push Int | Apply (Int  Int  Int) data Instr = Push Int | Apply (Int  Int  Int) | Load Adres | Store Adres Aanpassing van

26 add :: b  b  b mul :: b  b  b con :: Int  b var :: String  b def :: String  b  b  b Efficient compileren van expressies met definities mul f g e = con n e =[ Push n ] var x e =e ? x def x fd fb e =fb ( (x, fd e) : e ) add f g e = f e ++ g e ++ [Apply (+)] (Env  Code) Env  Code (Env  Code) Env  Code (Env  Code) Env  Code f e ++ g e ++ [Apply (*)] [ Load (e?x) ] fd e ++ [Store a] ++ fb ((x,a):e) where a = length e

27 Wat zit er in het Env ? nevalExpr ncompExpr nefficientCompExpr type Env = [ (String, Int) ] type Env = [ (String, Code) ] type Env = [ (String, Adres) ]

28 Runner: simulatie van processor run :: Code  Stack  Stack run [ ] stack = stack run (instr:rest) stack = exec instr stack run rest ( ) exec :: Instr  Stack  Stack exec (Push x) stack= x : stack exec (Apply f) (y:x:stack)= f x y : stack runExpr :: Code  Int runExpr prog = run prog [ ] head ( )

29 Runner: aangepaste simulatie van processor run :: Code  (Mem,Stack)  (Mem,Stack) run [ ] ms = ms run (instr:rest) ms = exec instr ms run rest ( ) exec :: Instr  (Mem,Stack)  (Mem,Stack) exec (Push x) (m, st)= (m, x : st ) exec (Apply f) (m, y:x:st)= (m, f x y : st ) exec (Load a) (m, st)= (m, m!a : st ) exec (Store a) (m, x: st)= (update m a x, st )

30 Voorbeeld Blokgestructureerde talen “ use x ;dcl x ;{use z ;use y ;dcl x ;dcl z ;use x } ;dcl y ;use y ” Enter (0,2) Access(0,0) Enter (1,2) Access (1,1) Access (0,1) Access (1,0) Leave (1,2) Access(0,1) Leave (0,2) parsecompile

31 Definitie van Block-type, -algebra & -fold data Block = Cons Stat Block | Empty data Stat = Decl Naam | Use Naam | Blk Block type BlockAlgebra b s = ( ( s  b  b, b ), ( Naam  s, Naam  s, b  s ) foldBlock :: BlockAlgebra b s  Block  b foldBlock ((c,e),(d,u,b))= f where f (Cons (s:b))= c (g s) (f b) f Empty= e g (Decl x)= d x g (Use x)= u x g (Blk n)= b (f n)

32 Compileren van een Block compBlock :: Block  Code compBlock = foldBlock cAlg where cAlg :: BlockAlgebra Code cAlg = ( (c,e), (d,u,b)) where c = … e = … d = … u = … b = … (Env  Code) Env  Code (GEnv  LEnv  Code) (GEnv  LEnv  (LEnv,Code)) Inherited attribuut Synthesized attribuut


Download ppt "Zelfgemaakt datatype voor bomen nMet functies data Tree a = Bin (Tree a) (Tree a) | Leaf a foldTree :: Tree a  b foldTree (b,lf) (Bin le ri) = b (foldTree."

Verwante presentaties


Ads door Google