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 bbbbbb (, ) abab 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
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 )
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”
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)
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
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 )
Taal: syntax en semantiek “ * 5 ” Add (Con 3) (Mul (Con 4) (Con 5)) parseExpr evalExpr 23 = start p where p = … … … = fold a where a = (…,…,…,…)
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
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
De compileer-semantiek nWat is “machinecode” ? nWat is een “machine-instructie” ? type Code = [ Instr ] data Instr = Push Int | Apply (Int Int Int)
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 ]
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
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 ( )
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
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 !!!
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 [ ]
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 )
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
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
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 (*)]
Wat zit er in het Env ? nevalExpr ncompExpr type Env = [ (String, Int) ] type Env = [ (String, Code) ]
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
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
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 (+)
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
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
Wat zit er in het Env ? nevalExpr ncompExpr nefficientCompExpr type Env = [ (String, Int) ] type Env = [ (String, Code) ] type Env = [ (String, Adres) ]
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 ( )
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 )
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
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)
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