week45 mandatory part finished

diff --git a/fp2/week3/mart/StdDynSet.icl b/fp2/week3/mart/StdDynSet.icl
index ffc2590..1202ce2 100644 (file)
--- a/fp2/week3/mart/StdDynSet.icl
+++ b/fp2/week3/mart/StdDynSet.icl
@@ -14,7 +14,10 @@ instance toString Set
 where toString (Set a) = abort "toString not implemented"\r
        \r
 instance == Set\r
-where == a b = abort "== instance voor Set nog niet geimplementeerd.\n"\r
+where \r
+       (==) (Set []) (Set []) = True\r
+       (==) (Set []) _ = False\r
+       (==) _ (Set []) = False\r
 \r
 toSet :: a -> Set | Set a\r
 toSet a = Set [dynamic a]\r

diff --git a/fp2/week45/mart/RefactorX b/fp2/week45/mart/RefactorX
new file mode 100755 (executable)
index 0000000..a700eaa
Binary files /dev/null and b/fp2/week45/mart/RefactorX differ

diff --git a/fp2/week45/mart/RefactorX.dcl b/fp2/week45/mart/RefactorX.dcl
new file mode 100644 (file)
index 0000000..e71f36b
--- /dev/null
+++ b/fp2/week45/mart/RefactorX.dcl
@@ -0,0 +1,15 @@
+definition module RefactorX\r
+\r
+import StdEnv\r
+\r
+:: Expr = NR Int | VAR Name | OP Expr Operator Expr | LET Name Expr Expr\r
+:: Name :== String\r
+:: Operator = PLUS | MIN | MUL | DIV\r
+:: Val = Result Int | Undef\r
+\r
+from StdClass import class toString\r
+\r
+instance toString Expr\r
+free :: Expr -> [Name]\r
+remove_unused_lets :: Expr -> Expr\r
+eval :: Expr -> Val\r

diff --git a/fp2/week45/mart/RefactorX.icl b/fp2/week45/mart/RefactorX.icl
new file mode 100644 (file)
index 0000000..3898c14
--- /dev/null
+++ b/fp2/week45/mart/RefactorX.icl
@@ -0,0 +1,71 @@
+implementation module RefactorX\r
+\r
+import StdEnv\r
+\r
+//Start = map toString [E1,E2,E3,E4,E5]\r
+//Start = map free [E1,E2,E3,E4,E5]\r
+//Start = map toString (map remove_unused_lets [E1,E2,E3,E4,E5])\r
+Start = map eval [E1,E2,E3,E4,E5]\r
+       where\r
+               E1 = OP (LET "x" (OP (NR 42) MIN (NR 3)) (OP (VAR "x") DIV (NR 0))) PLUS (LET "y" (NR 6) (OP (VAR "y") MUL (VAR "y")))\r
+               E2 = LET "x" (NR 42) (OP (VAR "x") PLUS (LET "x" (NR 58) (VAR "x")))\r
+               E3 = LET "x" (NR 1) (LET "y" (NR 2) (LET "x" (NR 3) (NR 4)))\r
+               E4 = LET "x" (NR 1) (OP (VAR "x") PLUS (VAR "y"))\r
+               E5 = OP (LET "x" (NR 1) (VAR "x")) MUL (VAR "x")\r
+\r
+(<+) infixl 9 :: String a -> String | toString a\r
+(<+) str a = str +++ toString a\r
+\r
+instance toString Operator where\r
+       toString PLUS = "+"\r
+       toString MIN = "-"\r
+       toString MUL = "*"\r
+       toString DIV = "/"\r
+ \r
+instance toString Expr where\r
+       toString (NR n) = toString n\r
+       toString (VAR v) = v\r
+       toString (LET n e1 e2) = "(let " <+ n <+ "=" <+ e1 <+ " in " <+ e2 <+ ")"\r
+       toString (OP e1 o e2) = bracket e1 <+ o <+ bracket e2\r
+               where\r
+                       bracket :: Expr -> String\r
+                       bracket (OP e1 o e2) = "(" <+ (OP e1 o e2) <+ ")"\r
+                       bracket e = toString e\r
+\r
+free:: Expr -> [Name]\r
+free (NR n) = [] \r
+free (VAR v) = [v]\r
+free (OP e1 o e2) = removeDup (free e1 ++ free e2)\r
+free (LET n e1 e2) = removeMember n (free e2)\r
+\r
+remove_unused_lets:: Expr -> Expr\r
+remove_unused_lets (LET n e1 e2)\r
+| isMember n (free e2) = (LET n (remove_unused_lets e1) (remove_unused_lets e2))\r
+| otherwise = remove_unused_lets e2\r
+remove_unused_lets (OP e1 o e2) = (OP (remove_unused_lets e1) o (remove_unused_lets e2))\r
+remove_unused_lets e = e\r
+\r
+apply:: Operator Val Val -> Val\r
+apply _ Undef _ = Undef\r
+apply _ _ Undef = Undef\r
+apply DIV _ (Result 0) = Undef\r
+apply o (Result e1) (Result e2) = Result (apply` o e1 e2)\r
+       where \r
+               apply`:: Operator -> Int Int -> Int\r
+               apply` PLUS = +\r
+               apply` MIN = -\r
+               apply` MUL = *\r
+               apply` DIV = /\r
+\r
+\r
+eval:: Expr -> Val\r
+eval e = eval` (remove_unused_lets e) []\r
+       where\r
+               eval`:: Expr [(Name, Val)] -> Val\r
+               eval` (NR n) _ = Result n\r
+               eval` (VAR v) [] = Undef\r
+               eval` (VAR v) [(n, e):xs]\r
+               | v == n = e\r
+               | otherwise = eval` (VAR v) xs\r
+               eval` (OP e1 o e2) xs = apply o (eval` e1 xs) (eval` e2 xs)\r
+               eval` (LET n e1 e2) xs = eval` e2 [(n, eval` e1 xs):xs]\r