Remove two unused modules

compiler/Transform/LetBoundVars.hs

@@ -1,54 +0,0 @@
-module LetBoundVars (letBoundVars) where
-
-import Context
-import Ast
-
-class LetBoundVars a where
-  letBoundVars :: a -> [String]
-
-instance LetBoundVars a => LetBoundVars [a] where
-  letBoundVars = concatMap letBoundVars
-
-instance LetBoundVars Statement where
-  letBoundVars stmt =
-    case stmt of
-      Definition d -> letBoundVars d
-      Datatype _ _ tcs -> []
-      ImportEvent _ e _ _ -> letBoundVars e
-      ExportEvent _ _ _ -> []
-      TypeAnnotation _ _ -> []
-      TypeAlias _ _ _ -> []
-
-instance LetBoundVars Def where
-  letBoundVars (FnDef n _ e) = n : letBoundVars e
-  letBoundVars (OpDef _ _ _ e) = letBoundVars e
-  letBoundVars _ = []
-
-instance LetBoundVars e => LetBoundVars (Context e) where
-  letBoundVars (C _ _ e) = letBoundVars e
-
-instance LetBoundVars Expr where
-  letBoundVars expr =
-    let f = letBoundVars in
-    case expr of
-      IntNum _ -> []
-      FloatNum _ -> []
-      Chr _ -> []
-      Str _ -> []
-      Boolean _ -> []
-      Range e1 e2 -> f e1 ++ f e2
-      Access e _ -> []
-      Remove e _ -> []
-      Insert e1 _ e2 -> f e1 ++ f e2
-      Modify e ps -> f e ++ concatMap (f . snd) ps
-      Record trps -> concatMap (\(_,_,e) -> f e) trps
-      Binop op e1 e2 -> f e1 ++ f e2
-      Lambda x e -> f e
-      App e1 e2 -> f e1 ++ f e2
-      If e1 e2 e3 -> concatMap f [e1,e2,e3]
-      MultiIf ps -> concatMap (\(b,e) -> f b ++ f e) ps
-      Let defs e -> concatMap letBoundVars defs ++ f e
-      Var x -> []
-      Data name es -> concatMap f es
-      Case e cases -> f e ++ concatMap (f . snd) cases
-      Markdown _ -> []

compiler/Transform/Replace.hs

@@ -1,60 +0,0 @@
-module Replace (replace, depth) where
-
-import Ast
-import Control.Arrow ((***))
-import Data.Set (singleton,empty,unions,member, Set)
-
-replace :: String -> Expr -> Expr -> Expr
-replace y v expr =
-    let f = replace y v in
-    case expr of
-      Range e1 e2 -> Range (f e1) (f e2)
-      Access e x -> Access (f e) x
-      Binop op e1 e2 -> Binop op (f e1) (f e2)
-      App e1 e2 -> App (f e1) (f e2)
-      If e1 e2 e3 -> If (f e1) (f e2) (f e3)
-      Guard ps -> map (f *** f) ps
-      Lift e es -> Lift (f e) (map f es)
-      Fold e1 e2 e3 -> Fold (f e1) (f e2) (f e3)
-      Async e -> Async (f e)
-      Let defs e -> if y `elem` vs then Let defs e else Let (zip vs (map f es)) (f e)
-              where (vs,es) = unzip defs
-      Var x -> if x == y then v else Var x
-      ExplicitList es -> ExplicitList (map f es)
-      Data name es -> Data name (map f es)
-      Case e cases -> Case (f e) $ map (caseReplace y v) cases
-      _ -> expr
-
-caseReplace :: String -> Expr -> (Pattern, Expr) -> (Pattern, Expr)
-caseReplace y v (p,e) =
-    if member y (patternVars p) then (p,e) else (p, replace y v e)
-
-patternVars :: Pattern -> Set String
-patternVars pattern =
-    case pattern of
-      PData _ ps -> unions (map patternVars ps)
-      PVar x     -> singleton x
-      PAsVar x p -> insert x (patternVars p)
-      PAnything  -> empty
-      PLiteral _ -> empty
-
-depth :: Expr -> Integer
-depth = depth' 0
-depth' d expr =
-    let f = depth' (d+1) in
-    case expr of
-      Range e1 e2 -> max (f e1) (f e2)
-      Access e x -> f e
-      Binop op e1 e2 -> max (f e1) (f e2)
-      Lambda x e -> f e
-      App e1 e2 -> max (f e1) (f e2)
-      If e1 e2 e3 -> maximum [f e1, f e2, f e3]
-      Guard ps -> maximum (map (uncurry max . f *** f) ps)
-      Lift e es -> maximum $ f e : map f es
-      Fold e1 e2 e3 -> maximum [f e1, f e2, f e3]
-      Async e -> f e
-      Let defs e -> let (_,es) = unzip defs in maximum $ f e : map f es
-      Data "::" es -> maximum $ map (depth' d) es
-      Data name es -> maximum $ 1 : map f es
-      Case e cases -> maximum $ f e : map (f . snd) cases
-      _ -> d