[get rid of unneeded FreeVars instances
John Meacham <john@repetae.net>**20060409093846] hunk ./DataConstructors.hs 27
-import qualified Data.Set as Set
hunk ./DataConstructors.hs 44
+import Name.Id
hunk ./DataConstructors.hs 55
-import Util.SetLike
+import Util.SetLike as S
hunk ./DataConstructors.hs 391
-            existentials = Set.toList $ freeVars (map getType ts') Set.\\ freeVars xs
+            existentials = melems $ freeVars (map getType ts') S.\\ (freeVars xs :: IdMap TVr)
hunk ./E/Eta.hs 23
-import Support.FreeVars
-import Util.NameMonad
-import E.E
-import E.Subst
+import DataConstructors
hunk ./E/Eta.hs 25
-import E.Program
+import E.E
hunk ./E/Eta.hs 27
+import E.Program
+import E.Subst
hunk ./E/Eta.hs 32
-import DataConstructors
-import Support.CanType
-import Stats
-import qualified Info.Info as Info
hunk ./E/Eta.hs 33
+import Name.Id
+import qualified Info.Info as Info
+import Stats
+import Support.CanType
+import Support.FreeVars
+import Util.NameMonad
+import Util.SetLike
hunk ./E/Eta.hs 135
-        f (ELam t (EAp x (EVar t'))) | t == t' && not (tvrIdent t `Set.member` freeVars x) = f x
+        f (ELam t (EAp x (EVar t'))) | t == t' && (tvrIdent t `notMember` (freeVars x :: IdSet)) = f x
hunk ./E/Eta.hs 144
-        f (ELam t (EAp x (EVar t'))) n | n `seq` True, t == t' && not (tvrIdent t `Set.member` freeVars x) = f x (n + 1)
+        f (ELam t (EAp x (EVar t'))) n | n `seq` True, t == t' && (tvrIdent t `notMember` (freeVars x :: IdSet)) = f x (n + 1)
hunk ./E/Eta.hs 152
-collectIds e = execWriter $ annotate mempty (\id nfo -> tell (Set.singleton id) >> return nfo) (\_ -> return) (\_ -> return) e
+collectIds :: E -> IdSet
+collectIds e = execWriter $ annotate mempty (\id nfo -> tell (singleton id) >> return nfo) (\_ -> return) (\_ -> return) e
hunk ./E/Eta.hs 158
-    fvs = foldr Set.insert (freeVars (b,map getType rs,tvrType t)) (map tvrIdent rs) `mappend` collectIds e
+    fvs = foldr insert (freeVars (b,map getType rs,tvrType t)) (map tvrIdent rs) `mappend` collectIds e
hunk ./E/Eta.hs 164
-    nameSupply = [ n |  n <- [2,4 :: Int ..], not $ n `Set.member` fvs  ]
+    nameSupply = [ n |  n <- [2,4 :: Int ..], n `notMember` fvs  ]
hunk ./E/FreeVars.hs 6
-import qualified Data.IntMap as IM
-import qualified Data.IntSet as IS
-import qualified Data.Set as Set
-import qualified Data.Map as Map
hunk ./E/FreeVars.hs 16
-
-getTyp tvr = tvrType tvr
hunk ./E/FreeVars.hs 19
-instance FreeVars (Alt E) (IM.IntMap TVr) where
-    freeVars as@(Alt l e) = IM.unions $ freeVars (getLitTyp l):(freeVars e IM.\\ IM.fromList [ (tvrIdent t,t) | t <- litBinds l]):( map (freeVars . getTyp) $ litBinds l)
-instance FreeVars E IS.IntSet where
-    freeVars e = IS.fromDistinctAscList (fsts . IM.toAscList $ freeVs e)
-instance FreeVars E (IM.IntMap TVr) where
-    freeVars = freeVs
-
hunk ./E/FreeVars.hs 20
-    freeVars x = IM.elems $ freeVars x
+    freeVars x = melems $ (freeVars x :: IdMap TVr)
hunk ./E/FreeVars.hs 22
-    freeVars e =  IM.keys $ freeVs e
+    freeVars e =  idSetToList (freeVars e)
hunk ./E/FreeVars.hs 25
-    freeVars tvr = freeVars (getTyp tvr :: E)
-
-instance FreeVars E (Map.Map Id TVr) where
-    freeVars e = freeVsMap e
-instance FreeVars E (Map.Map Id (Maybe E)) where
-    freeVars e = Map.map (const Nothing) (freeVsMap e)
-instance FreeVars E (Set.Set Id) where
-    freeVars e = Set.mapMonotonic tvrIdent (freeVsSet e)
-instance FreeVars E (Set.Set TVr) where
-    freeVars  = freeVsSet
+    freeVars tvr = freeVars (tvrType tvr :: E)
hunk ./E/FreeVars.hs 28
-    freeVars l =  mconcat $ freeVars (getLitTyp l :: E ):(map (freeVars . (getTyp :: TVr -> E) ) $ litBinds l)
-
-
-instance FreeVars (Alt E) (Map.Map Id TVr) where
-    freeVars as@(Alt l e) = Map.unions $ freeVars (getLitTyp l):(freeVars e Map.\\ Map.fromList [ (tvrIdent t,t) | t <- litBinds l]):( map (freeVars . getTyp) $ litBinds l)
+    freeVars l =  mconcat $ freeVars (getLitTyp l :: E ):(map (freeVars . (tvrType :: TVr -> E) ) $ litBinds l)
hunk ./E/FreeVars.hs 30
-instance FreeVars (Alt E) (Set.Set Id) where
-    freeVars as = Set.mapMonotonic tvrIdent $ (freeVars as :: Set.Set TVr)
-instance FreeVars (Alt E) (Set.Set TVr) where
-    freeVars as@(Alt l e) = Set.unions $ freeVars (getLitTyp l):(freeVars e Set.\\ Set.fromList (litBinds l)):(map (freeVars . getTyp) $ litBinds l)
hunk ./E/FreeVars.hs 32
-    freeVars as@(Alt l e) = mconcat $ freeVars (getLitTyp l):(freeVars e S.\\ fromList [ tvrIdent t | t <- litBinds l]):(map (freeVars . getTyp) $ litBinds l)
+    freeVars as@(Alt l e) = mconcat $ freeVars (getLitTyp l):(freeVars e S.\\ fromList [ tvrIdent t | t <- litBinds l]):(map (freeVars . tvrType) $ litBinds l)
hunk ./E/FreeVars.hs 37
-    freeVars as@(Alt l e) = mconcat $ freeVars (getLitTyp l):(freeVars e S.\\ fromList [ (tvrIdent t,t) | t <- litBinds l]):(map (freeVars . getTyp) $ litBinds l)
+    freeVars as@(Alt l e) = mconcat $ freeVars (getLitTyp l):(freeVars e S.\\ fromList [ (tvrIdent t,t) | t <- litBinds l]):(map (freeVars . tvrType) $ litBinds l)
hunk ./E/FreeVars.hs 43
-freeVs ::  E -> IM.IntMap TVr
-freeVs =   fv where
-    (<>) = IM.union
-    delete = IM.delete
-    fv (EAp e1 e2) = fv e1 <> fv e2
-    fv (EVar tvr@(TVr { tvrIdent =  ( i), tvrType =  t })) = IM.insert i tvr (fv t)
-    fv (ELam (TVr { tvrIdent = i, tvrType = t}) e) =  (delete i $ fv e <> fv t)
-    fv (EPi (TVr { tvrIdent =  i, tvrType = t}) e) =  (delete i $ fv e <> fv t)
-    fv (ELetRec dl e) =  ((tl <> bl <> fv e) IM.\\ IM.fromList ll)  where
-        (ll,tl,bl) = liftT3 (id,IM.unions,IM.unions) $ unzip3 $
-            map (\(tvr@(TVr { tvrIdent = j, tvrType =  t}),y) -> ((j,tvr), fv t, fv y)) dl
-    fv (EError _ e) = fv e
-    fv (ELit l) = fvLit l
-    fv (EPrim _ es e) = IM.unions $ fv e : map fv es
-    fv ECase { eCaseScrutinee = e, eCaseBind = b, eCaseAlts = as, eCaseDefault = d, eCaseType = ty } = IM.unions ( fv e:freeVars (getTyp  b):freeVars ty:(IM.delete (tvrIdent b) $ IM.unions (freeVars d:map freeVars as)  ):[])
-    fv Unknown = IM.empty
-    fv ESort {} = IM.empty
-    fvLit (LitCons _ es e) = IM.unions $ fv e:map fv es
-    fvLit l = freeVs (getLitTyp l)
-
-freeVsSet ::  E -> Set.Set TVr
-freeVsSet e = fv e where
-    (<>) = Set.union
-    delete = Set.delete
-    fv (EAp e1 e2) = fv e1 <> fv e2
-    fv (EVar tvr@(TVr { tvrType =  t })) = Set.insert tvr (fv t)
-    fv (ELam tvr@(TVr { tvrType = t}) e) =  (delete tvr $ fv e <> fv t)
-    fv (EPi  tvr@(TVr {  tvrType = t}) e) =  (delete tvr $ fv e <> fv t)
-    fv (ELetRec dl e) =  ((tl <> bl <> fv e) Set.\\ Set.fromList ll)  where
-        (ll,tl,bl) = liftT3 (id,Set.unions,Set.unions) $ unzip3 $
-            map (\(tvr@(TVr {  tvrType =  t}),y) -> (tvr, fv t, fv y)) dl
-    fv (EError _ e) = fv e
-    fv (ELit l) = fvLit l
-    fv (EPrim _ es e) = Set.unions $ fv e : map fv es
-    fv ECase { eCaseScrutinee = e, eCaseBind = b, eCaseAlts = as, eCaseDefault = d, eCaseType = ty } =Set.unions ( fv e:freeVars ty:freeVars (getTyp  b):(Set.delete b $ Set.unions (freeVars d:map freeVars as)  ):[])
-    fv Unknown = Set.empty
-    fv ESort {} = Set.empty
-    fvLit (LitCons _ es e) = Set.unions $ fv e:map fv es
-    fvLit l = freeVsSet (getLitTyp l)
-
-freeVsMap ::  E -> Map.Map Int TVr
-freeVsMap e = fv e where
-    (<>) = Map.union
-    delete = Map.delete
-    freeVars' = fv
-    fv (EAp e1 e2) = fv e1 <> fv e2
-    fv (EVar tvr@(TVr { tvrIdent =  ( i), tvrType =  t })) = Map.insert i tvr (fv t)
-    fv (ELam (TVr { tvrIdent = i, tvrType = t}) e) =  (delete i $ fv e <> fv t)
-    fv (EPi (TVr { tvrIdent =  i, tvrType = t}) e) =  (delete i $ fv e <> fv t)
-    fv (ELetRec dl e) =  ((tl <> bl <> fv e) Map.\\ Map.fromList ll)  where
-        (ll,tl,bl) = liftT3 (id,Map.unions,Map.unions) $ unzip3 $
-            map (\(tvr@(TVr { tvrIdent = j, tvrType =  t}),y) -> ((j,tvr), fv t, fv y)) dl
-    fv (EError _ e) = fv e
-    fv (ELit l) = fvLit l
-    fv (EPrim _ es e) = Map.unions $ fv e : map fv es
-    fv ECase { eCaseScrutinee = e, eCaseBind = b, eCaseAlts = as, eCaseDefault = d, eCaseType = ty } = Map.unions ( fv e:freeVars' ty:freeVars' (getTyp  b):(Map.delete (tvrIdent b) $ Map.unions (freeVars d:map freeVars as)  ):[])
-    fv Unknown = Map.empty
-    fv ESort {} = Map.empty
-    fvLit (LitCons _ es e) = Map.unions $ fv e:map fv es
-    fvLit l = freeVars' (getLitTyp l)
-
hunk ./E/FreeVars.hs 70
-    fv ECase { eCaseScrutinee = e, eCaseBind = b, eCaseAlts = as, eCaseDefault = d, eCaseType = ty } = mconcat ( fv e:freeVars (getTyp  b):freeVars ty:(delete (tvrIdent b) $ mconcat (freeVars d:map freeVars as)  ):[])
+    fv ECase { eCaseScrutinee = e, eCaseBind = b, eCaseAlts = as, eCaseDefault = d, eCaseType = ty } = mconcat ( fv e:freeVars (tvrType  b):freeVars ty:(delete (tvrIdent b) $ mconcat (freeVars d:map freeVars as)  ):[])
hunk ./E/FreeVars.hs 91
-    fv ECase { eCaseScrutinee = e, eCaseBind = b, eCaseAlts = as, eCaseDefault = d, eCaseType = ty } = mconcat ( fv e:freeVars (getTyp  b):freeVars ty:(mdelete (tvrIdent b) $ mconcat (freeVars d:map freeVars as)  ):[])
+    fv ECase { eCaseScrutinee = e, eCaseBind = b, eCaseAlts = as, eCaseDefault = d, eCaseType = ty } = mconcat ( fv e:freeVars (tvrType  b):freeVars ty:(mdelete (tvrIdent b) $ mconcat (freeVars d:map freeVars as)  ):[])
hunk ./E/PrimOpt.hs 19
+import Name.Id
hunk ./E/PrimOpt.hs 26
-import Util.NameMonad
+import Util.HasSize
+import Util.NameMonad(genNames)
+import Util.SetLike
hunk ./E/PrimOpt.hs 162
+
+-- | Generate an infinite list of names not present in the given set.
+freeNames :: IdSet -> [Id]
+freeNames s  = filter (not . (`member` s)) (genNames (size s))
+
hunk ./E/Rules.hs 118
-    --Just rs -> mconcat (map ruleFvs rs) -- (freeVars (map ruleBody rs) Set.\\ freeVars (map ruleArgs rs))
hunk ./E/Rules.hs 123
-    --Just rs -> mconcat (map ruleFvs rs) -- (freeVars (map ruleBody rs) Set.\\ freeVars (map ruleArgs rs))
hunk ./E/Rules.hs 129
-instance FreeVars Rule (Set.Set TVr) where
-    freeVars rule = freeVars (ruleBody rule) Set.\\ Set.fromList (ruleBinds rule)
-
-instance FreeVars Rule (Set.Set Id) where
-    freeVars rule = freeVars (ruleBody rule) Set.\\ Set.fromList (map tvrIdent $ ruleBinds rule)
-
hunk ./E/Rules.hs 131
+instance FreeVars Rule (IdMap TVr) where
+    freeVars rule = freeVars (ruleBody rule) S.\\ fromList [ (tvrIdent t,t) | t <- ruleBinds rule]
hunk ./E/Rules.hs 135
-    freeVars rule = Set.toList $ freeVars rule
+    freeVars rule = idSetToList $ freeVars rule
hunk ./E/Rules.hs 230
-rsubstMap :: Map.Map Id E -> E -> E
+rsubstMap :: IdMap E -> E -> E
hunk ./E/Rules.hs 240
-            let b = rsubstMap (Map.fromList [ (i,x) | (TVr { tvrIdent = i },x) <- concat ss ]) (ruleBody r)
+            let b = rsubstMap (fromList [ (i,x) | (TVr { tvrIdent = i },x) <- concat ss ]) (ruleBody r)
hunk ./E/SSimplify.hs 60
-collectOcc :: SimplifyOpts ->  E -> (E,Set.Set Int,Map.Map TVr Occurance)
+collectOcc :: SimplifyOpts ->  E -> (E,IdSet,Map.Map TVr Occurance)
hunk ./E/SSimplify.hs 94
-                fvs = Set.toList (Map.keysSet i `union` fv)
+                fvs = idSetToList (fromDistinctAscList (Map.keys i) `union` fv)
hunk ./E/SSimplify.hs 96
-            nn' = reachable gr (Set.toList fve ++ Map.keys se ++  topLevels)
+            nn' = reachable gr (idSetToList fve ++ Map.keys se ++  topLevels)
hunk ./E/SSimplify.hs 200
-        addNames (Set.toList fvs)
+        addNames (idSetToList fvs)
hunk ./E/SSimplify.hs 411
-    doCase scrut _ v [] (Just sc@ECase { eCaseScrutinee = EVar v'} ) sub inb | v == v', not $ tvrIdent v `Set.member` freeVars (caseBodies sc)  = do
+    doCase scrut _ v [] (Just sc@ECase { eCaseScrutinee = EVar v'} ) sub inb | v == v', tvrIdent v `notMember` (freeVars (caseBodies sc) :: IdSet)  = do
hunk ./E/Values.hs 24
+import Name.Id
hunk ./E/Values.hs 254
-whnfOrBot (EPi (TVr { tvrIdent =  j, tvrType =  x }) y) | not (j `Set.member` freeVars y) = isAtomic x && isAtomic y
+whnfOrBot (EPi (TVr { tvrIdent =  j, tvrType =  x }) y) | not (j `member` (freeVars y :: IdSet)) = isAtomic x && isAtomic y
hunk ./Main.hs 882
-        fvs = freeVars $ snds $ programDs prog :: Set.Set TVr
+        fvs = Set.fromList $ melems (freeVars $ snds $ programDs prog :: IdMap TVr)