fp2/week45/camil/RefactorX.icl

   1 implementation module RefactorX
   2
   3 import StdEnv
   4
   5 Start = map eval [E1,E2,E3,E4,E5]
   6
   7 E1 = OP (LET "x" (OP (NR 42) MIN (NR 3)) (OP (VAR "x") DIV (NR 0)))
   8         PLUS
   9         (LET "y" (NR 6) (OP (VAR "y") MUL (VAR "y")))
  10 E2 = LET "x" (NR 42) (OP (VAR "x") PLUS (LET "x" (NR 58) (VAR "x")))
  11 E3 = LET "x" (NR 1) (LET "y" (NR 2) (LET "x" (NR 3) (NR 4)))
  12 E4 = LET "x" (NR 1) (OP (VAR "x") PLUS (VAR "y"))
  13 E5 = OP (LET "x" (NR 1) (VAR "x")) MUL (VAR "x")
  14
  15 ::      Expr                                                    = NR   Int
  16                                                                         | VAR  Name
  17                                                                         | OP   Expr Operator Expr
  18                                                                         | LET  Name     Expr Expr
  19 ::      Name                                                    :== String
  20 ::      Operator                                                = PLUS | MIN | MUL | DIV
  21 ::      Val                                                             = Result Int | Undef
  22
  23 (<+) infixl 9 :: String a -> String | toString a
  24 (<+) str a = str +++ toString a
  25
  26 instance toString Operator where
  27         toString PLUS = "+"
  28         toString MIN = "-"
  29         toString MUL = "*"
  30         toString DIV = "/"
  31
  32 //  expressies afdrukken:
  33 instance toString Expr where
  34         toString (NR n) = toString n
  35         toString (VAR s) = s
  36         toString (LET s e1 e2) = "let " <+ s <+ " = " <+ e1 <+ " in " <+ e2
  37         toString (OP e1 o e2) = bracket e1 <+ o <+ bracket e2
  38         where
  39                 bracket :: Expr -> String
  40                 bracket (OP e1 o e2) = "(" <+ e1 <+ o <+ e2 <+ ")"
  41                 bracket (LET s e1 e2) = "(" <+ (LET s e1 e2) <+ ")"
  42                 bracket x = toString x
  43
  44 //      vrije variabelen:
  45 free                                                            :: Expr -> [Name]
  46 free (NR _) = []
  47 free (VAR s) = [s]
  48 free (LET s _ e2) = [n \\ n <- free e2 | n <> s]
  49 free (OP e1 _ e2) = removeDup ((free e1) ++ (free e2))
  50
  51 //      verwijder deelexpressies met ongebruikte let-variabelen:
  52 remove_unused_lets                                      :: Expr -> Expr
  53 remove_unused_lets (LET s e1 e2)
  54 | isMember s (free e2) = (LET s (remove_unused_lets e1) (remove_unused_lets e2))
  55 | otherwise = remove_unused_lets e2
  56 remove_unused_lets (OP e1 o e2) = OP (remove_unused_lets e1) o (remove_unused_lets e2)
  57 remove_unused_lets x = x
  58
  59 //      evaluator met tabel van naam-waarde paren:
  60 eval                                                            :: Expr -> Val
  61 eval e = fst (eval` e [])
  62 where
  63         eval` :: Expr [(Name, Val)] -> (Val, [(Name, Val)])
  64         eval` (NR n) vs = (Result n, [])
  65         eval` (VAR s) vs = (find s vs, [])
  66         where
  67                 find :: Name [(Name, Val)] -> Val
  68                 find _ [] = Undef
  69                 find s [(t,v):vs]
  70                 | s == t = v
  71                 | otherwise = find s vs
  72         eval` (LET s e1 e2) vs = eval` e2 [(s,fst (eval` e1 vs)):vs]
  73         eval` (OP e1 o e2) vs = (op o (fst (eval` e1 vs)) (fst (eval` e2 vs)), [])
  74         where
  75                 op :: Operator Val Val -> Val
  76                 op _ Undef _ = Undef
  77                 op _ _ Undef = Undef
  78                 op PLUS (Result x) (Result y) = Result (x + y)
  79                 op MIN (Result x) (Result y) = Result (x - y)
  80                 op MUL (Result x) (Result y) = Result (x * y)
  81                 op DIV _ (Result 0) = Undef
  82                 op DIV (Result x) (Result y) = Result (x / y)