[fix trailing whitespace
John Meacham <john@repetae.net>**20050811030247] hunk ./Atom.hs 33
-data Atom = Atom {-# UNPACK #-} !Int !PackedString 
+data Atom = Atom {-# UNPACK #-} !Int !PackedString
hunk ./Atom.hs 40
-    readsPrec p s = [ (fromString x,y) |  (x,y) <- readsPrec p s] 
+    readsPrec p s = [ (fromString x,y) |  (x,y) <- readsPrec p s]
hunk ./Atom.hs 83
-    
+
hunk ./Atom.hs 104
-        
-    
+
+
hunk ./Atom.hs 109
-    Nothing -> return $ fail $ "intToAtom: " ++ show i 
-    
+    Nothing -> return $ fail $ "intToAtom: " ++ show i
+
hunk ./Atom.hs 115
-        [] -> return $ fail $ "intToAtom: " ++ show i 
+        [] -> return $ fail $ "intToAtom: " ++ show i
hunk ./Atom.hs 123
-        
+
hunk ./Binary.hs 62
-import Control.Monad	 
+import Control.Monad	
hunk ./Binary.hs 144
-newtype Bin a = BinPtr Int 
+newtype Bin a = BinPtr Int
hunk ./Binary.hs 172
-openBinIO_ h = openBinIO h 
+openBinIO_ h = openBinIO h
hunk ./Binary.hs 197
-seekBin (BinIO  ix_r h) (BinPtr p) = do 
+seekBin (BinIO  ix_r h) (BinPtr p) = do
hunk ./Binary.hs 262
-    if (ix >= sz) 
-        then do 
+    if (ix >= sz)
+        then do
hunk ./Binary.hs 266
-        else do 
+        else do
hunk ./Binary.hs 330
-    return $! ((fromIntegral w1 `shiftL` 24) .|. 
-	       (fromIntegral w2 `shiftL` 16) .|. 
-	       (fromIntegral w3 `shiftL`  8) .|. 
+    return $! ((fromIntegral w1 `shiftL` 24) .|.
+	       (fromIntegral w2 `shiftL` 16) .|.
+	       (fromIntegral w3 `shiftL`  8) .|.
hunk ./Binary.hs 355
-    return $! ((fromIntegral w1 `shiftL` 56) .|. 
-	       (fromIntegral w2 `shiftL` 48) .|. 
-	       (fromIntegral w3 `shiftL` 40) .|. 
-	       (fromIntegral w4 `shiftL` 32) .|. 
-	       (fromIntegral w5 `shiftL` 24) .|. 
-	       (fromIntegral w6 `shiftL` 16) .|. 
-	       (fromIntegral w7 `shiftL`  8) .|. 
+    return $! ((fromIntegral w1 `shiftL` 56) .|.
+	       (fromIntegral w2 `shiftL` 48) .|.
+	       (fromIntegral w3 `shiftL` 40) .|.
+	       (fromIntegral w4 `shiftL` 32) .|.
+	       (fromIntegral w5 `shiftL` 24) .|.
+	       (fromIntegral w6 `shiftL` 16) .|.
+	       (fromIntegral w7 `shiftL`  8) .|.
hunk ./Binary.hs 427
-	month <- fmap toEnum $ get bh 
-	day <- get bh 
-	hour <- get bh 
-	min <- get bh 
-	sec <- get bh 
+	month <- fmap toEnum $ get bh
+	day <- get bh
+	hour <- get bh
+	min <- get bh
+	sec <- get bh
hunk ./Binary.hs 437
-    get bh = fmap PS $ get bh 
+    get bh = fmap PS $ get bh
hunk ./Binary.hs 443
---return $ PS (Data.Array.IArray.listArray (0,sz - 1) x) 
+--return $ PS (Data.Array.IArray.listArray (0,sz - 1) x)
hunk ./Binary.hs 445
---put_ bh ps = put_ bh (unpackPS ps) 
+--put_ bh ps = put_ bh (unpackPS ps)
hunk ./Binary.hs 447
---put_ bh ps = putNList_ bh (unpackPS ps) 
+--put_ bh ps = putNList_ bh (unpackPS ps)
hunk ./Binary.hs 449
-    
+
hunk ./Binary.hs 453
--- 
+--
hunk ./Binary.hs 500
-    get bh           = do 
+    get bh           = do
hunk ./Binary.hs 504
-            _ -> do 
-                x <- get bh 
+            _ -> do
+                x <- get bh
hunk ./Binary.hs 522
-        ix <- readFastMutInt ix_r 
+        ix <- readFastMutInt ix_r
hunk ./Binary.hs 533
-        ix <- readFastMutInt ix_r 
-        sz <- get bh 
+        ix <- readFastMutInt ix_r
+        sz <- get bh
hunk ./Binary.hs 536
-        hGetArray h ba sz 
+        hGetArray h ba sz
hunk ./Binary.hs 538
-        ba <- unsafeFreeze ba 
+        ba <- unsafeFreeze ba
hunk ./Binary.hs 541
-        sz <- get bh 
+        sz <- get bh
hunk ./Binary.hs 554
-        s <- get bh 
+        s <- get bh
hunk ./Binary.hs 559
--} 
+-}
hunk ./Binary.hs 570
-   
-    get bh = do 
+
+    get bh = do
hunk ./Binary.hs 583
-  where loop n# 
+  where loop n#
hunk ./Binary.hs 591
-  (MBA arr) <- newByteArray sz 
+  (MBA arr) <- newByteArray sz
hunk ./Binary.hs 595
-		w <- getByte bh 
+		w <- getByte bh
hunk ./Binary.hs 653
- 
+
hunk ./Binary.hs 666
-  
+
hunk ./Binary.hs 682
-    case getUserData bh of { 
+    case getUserData bh of {
hunk ./Binary.hs 696
-  get bh = do 
+  get bh = do
hunk ./Binary.hs 708
-        
+
hunk ./C/FromGrin.hs 32
-toType (TyTup []) = CTypeBasic "void" 
-toType (TyPtr TyNode) = toType TyNode  -- for now, we use pointers to nodes for everything 
+toType (TyTup []) = CTypeBasic "void"
+toType (TyPtr TyNode) = toType TyNode  -- for now, we use pointers to nodes for everything
hunk ./C/FromGrin.hs 41
-toStruct t = text $ 's':(show $ toCIdent $ t) 
-toTag t = text $ (show $ toCIdent $ t) 
+toStruct t = text $ 's':(show $ toCIdent $ t)
+toTag t = text $ (show $ toCIdent $ t)
hunk ./C/FromGrin.hs 44
-toStructT t = CTypeStruct (toStruct t) 
+toStructT t = CTypeStruct (toStruct t)
hunk ./C/FromGrin.hs 56
-data Todo = TodoReturn | TodoExp CExpr | TodoNothing 
+data Todo = TodoReturn | TodoExp CExpr | TodoNothing
hunk ./C/FromGrin.hs 77
--- cb (Fetch (Var n _) :>>= Var n' t :-> e ) = return [CSAuto (toType t) (toVName n'), CSAssign (CEIdent (] 
+-- cb (Fetch (Var n _) :>>= Var n' t :-> e ) = return [CSAuto (toType t) (toVName n'), CSAssign (CEIdent (]
hunk ./C/FromGrin.hs 81
-newNode (NodeC t _) | t == tagHole = do 
+newNode (NodeC t _) | t == tagHole = do
hunk ./C/FromGrin.hs 85
-    --let tmp = CEVar (CTypePointer (toStructT t)) "tmp" 
+    --let tmp = CEVar (CTypePointer (toStructT t)) "tmp"
hunk ./C/FromGrin.hs 104
-    
+
hunk ./C/FromGrin.hs 110
-cexp (Fetch v) = cVal v 
-cexp (Store n@NodeC {}) = newNode n 
+cexp (Fetch v) = cVal v
+cexp (Store n@NodeC {}) = newNode n
hunk ./C/FromGrin.hs 113
-cexp (Return x) = cVal x 
-cexp (Cast x t) = cVal x >>= return . CECast (toType t) 
+cexp (Return x) = cVal x
+cexp (Cast x t) = cVal x >>= return . CECast (toType t)
hunk ./C/FromGrin.hs 116
-    statement (CSExpr (CEFunCall "jhc_error" [CEDoc (show s)])) 
+    statement (CSExpr (CEFunCall "jhc_error" [CEDoc (show s)]))
hunk ./C/FromGrin.hs 119
-    vs' <- mapM cVal vs 
+    vs' <- mapM cVal vs
hunk ./C/FromGrin.hs 124
-convertPrim p vs 
+convertPrim p vs
hunk ./C/FromGrin.hs 166
---        (_,true) <- newConst vTrue 
+--        (_,true) <- newConst vTrue
hunk ./C/FromGrin.hs 176
---        return $ CETernary (CEOp ">" a' b') (ti gt)  (CETernary (CEOp "==" a' b') (ti eq) (ti lt)) 
+--        return $ CETernary (CEOp ">" a' b') (ti gt)  (CETernary (CEOp "==" a' b') (ti eq) (ti lt))
hunk ./C/FromGrin.hs 179
---        return $  (CEOp "-" (CEDoc "0") a') 
+--        return $  (CEOp "-" (CEDoc "0") a')
hunk ./C/FromGrin.hs 187
- --   | Just n <- lookup (primName p) bops, [a,b] <- vs = doBop n a b 
+ --   | Just n <- lookup (primName p) bops, [a,b] <- vs = doBop n a b
hunk ./C/FromGrin.hs 194
-    
+
hunk ./C/FromGrin.hs 206
-    
+
hunk ./C/FromGrin.hs 208
-    v' <- cVal v 
-    --let tmp = CECast (toStructTP t)  v' 
-    let tmp = CEIndirect v' (toStruct t) 
+    v' <- cVal v
+    --let tmp = CECast (toStructTP t)  v'
+    let tmp = CEIndirect v' (toStruct t)
hunk ./C/FromGrin.hs 217
-    v' <- cVal v 
-    --let tmp = CECast (toStructTP t)  v' 
-    let tmp = CEIndirect v' (toStruct t) 
+    v' <- cVal v
+    --let tmp = CECast (toStructTP t)  v'
+    let tmp = CEIndirect v' (toStruct t)
hunk ./C/FromGrin.hs 230
-    v' <- cVal v 
+    v' <- cVal v
hunk ./C/FromGrin.hs 235
-    v' <- cVal v 
+    v' <- cVal v
hunk ./C/FromGrin.hs 238
-            v'' <- cVal v 
-            e' <- cb e 
-            return $ (Nothing,[declVar v,CSAssign v'' v'] ++ e')  
+            v'' <- cVal v
+            e' <- cb e
+            return $ (Nothing,[declVar v,CSAssign v'' v'] ++ e')
hunk ./C/FromGrin.hs 243
-            e' <- cb e 
-            --let tmp = CECast (toStructTP t)  v' 
-            let tmp = CEIndirect v' (toStruct t) 
+            e' <- cb e
+            --let tmp = CECast (toStructTP t)  v'
+            let tmp = CEIndirect v' (toStruct t)
hunk ./C/FromGrin.hs 248
-            return $ (Just (toTag t), map declVar as ++ ass ++ e')  
-    ls' <- mapM da ls 
+            return $ (Just (toTag t), map declVar as ++ ass ++ e')
+    ls' <- mapM da ls
hunk ./C/FromGrin.hs 252
-    v' <- cVal v 
+    v' <- cVal v
hunk ./C/FromGrin.hs 255
-            v'' <- cVal v 
-            e' <- cb e 
-            return $ (Nothing,[declVar v,CSAssign v'' v'] ++ e')  
+            v'' <- cVal v
+            e' <- cb e
+            return $ (Nothing,[declVar v,CSAssign v'' v'] ++ e')
hunk ./C/FromGrin.hs 259
-            e' <- cb e 
-            return $ (Just (show i), e')  
-    ls' <- mapM da ls 
+            e' <- cb e
+            return $ (Just (show i), e')
+    ls' <- mapM da ls
hunk ./C/FromGrin.hs 263
-    
hunk ./C/FromGrin.hs 264
-    
+
+
hunk ./C/FromGrin.hs 268
-    (e,(ss',req)) <- runWriterT $ cexp e 
+    (e,(ss',req)) <- runWriterT $ cexp e
hunk ./C/FromGrin.hs 280
-include fn = text "#include <" <> text fn <> text ">" 
+include fn = text "#include <" <> text fn <> text ">"
hunk ./C/FromGrin.hs 285
-    et = text "typedef enum {" $$ nest 4 (P.fsep (punctuate P.comma (map (toTag . fst) tags))) $$ text  "} tag_t;" 
+    et = text "typedef enum {" $$ nest 4 (P.fsep (punctuate P.comma (map (toTag . fst) tags))) $$ text  "} tag_t;"
hunk ./C/FromGrin.hs 287
-    ans = vcat $ map include (snub $ reqIncludes req) ++ [text "",et,text ""] ++ map cs tags ++ [text "",cn,text "",so,text "",text "/* Begin CAFS */"] ++ map ccaf (grinCafs grin) ++ [text "", consts, text "",text  "/* Begin Functions */"] ++ map prettyFuncP funcs ++ (map prettyFunc funcs) 
+    ans = vcat $ map include (snub $ reqIncludes req) ++ [text "",et,text ""] ++ map cs tags ++ [text "",cn,text "",so,text "",text "/* Begin CAFS */"] ++ map ccaf (grinCafs grin) ++ [text "", consts, text "",text  "/* Begin Functions */"] ++ map prettyFuncP funcs ++ (map prettyFunc funcs)
hunk ./C/FromGrin.hs 289
-    cst (i,t) = (toType t, text $ 'a':show i) 
-    cn = text $  "union node {\n  struct { tag_t tag; } any;\n" <> mconcat (map cu (fsts tags)) <> text "};" 
+    cst (i,t) = (toType t, text $ 'a':show i)
+    cn = text $  "union node {\n  struct { tag_t tag; } any;\n" <> mconcat (map cu (fsts tags)) <> text "};"
hunk ./C/FromGrin.hs 300
-            cd = text "static struct " <> toStruct a <+> text "_c" <> tshow i <+> text "= {" <> hsep (punctuate P.comma (toTag a:rs)) <> text "};" 
+            cd = text "static struct " <> toStruct a <+> text "_c" <> tshow i <+> text "= {" <> hsep (punctuate P.comma (toTag a:rs)) <> text "};"
hunk ./C/FromGrin.hs 306
-            f (Left (Var n _)) _ =  toVName n 
+            f (Left (Var n _)) _ =  toVName n
hunk ./C/FromGrin.hs 309
-            
hunk ./C/FromGrin.hs 310
-    
+
+
hunk ./C/Gen.hs 25
-data CExpr = CEIdent String | CEFunCall String [CExpr] | CELiteral CLit | CEDot CExpr String | CEIndirect CExpr String | CESizeof CType | CECast CType CExpr | CEEval CExpr | CEDoc String | CEVar CType String | CETernary CExpr CExpr CExpr | CEOp String CExpr CExpr  | CEUOp String CExpr 
+data CExpr = CEIdent String | CEFunCall String [CExpr] | CELiteral CLit | CEDot CExpr String | CEIndirect CExpr String | CESizeof CType | CECast CType CExpr | CEEval CExpr | CEDoc String | CEVar CType String | CETernary CExpr CExpr CExpr | CEOp String CExpr CExpr  | CEUOp String CExpr
hunk ./C/Gen.hs 29
- 
+
hunk ./C/Gen.hs 39
-cfunction = CFunction { cFuncComments = "", cFuncName = "_unknown", cFuncReturnType = CTypeBasic "void", cFuncArgs = [], cFuncPublic = False, cFuncBody = [] } 
+cfunction = CFunction { cFuncComments = "", cFuncName = "_unknown", cFuncReturnType = CTypeBasic "void", cFuncArgs = [], cFuncPublic = False, cFuncBody = [] }
hunk ./C/Gen.hs 55
-    
hunk ./C/Gen.hs 56
+
hunk ./C/Gen.hs 87
-    
+
hunk ./C/Gen.hs 138
-	(_,_,z) <- get 
+	(_,_,z) <- get
hunk ./C/Gen.hs 196
-	f r (l,v)  = do 
+	f r (l,v)  = do
hunk ./C/Gen.hs 213
-	f r (l,v)  = do 
+	f r (l,v)  = do
hunk ./C/Gen.hs 223
-    (s,()) <- runSubCGen v 
+    (s,()) <- runSubCGen v
hunk ./C/Gen.hs 237
-    
+
hunk ./C/Gen.hs 263
-prettyC (cf) = render (header $$$ 
-    ((vcat $ map prettyDecl sts) $$$ (vcat $ map prettyProto fns) $$$ 
+prettyC (cf) = render (header $$$
+    ((vcat $ map prettyDecl sts) $$$ (vcat $ map prettyProto fns) $$$
hunk ./C/Gen.hs 275
-    header =  text "#include <malloc.h>" $$ 
-	text "#include \"jhc_rts.h\"" $$ text "" 
+    header =  text "#include <malloc.h>" $$
+	text "#include \"jhc_rts.h\"" $$ text ""
hunk ./C/Gen.hs 280
---a $+$ b = a $$ b 
+--a $+$ b = a $$ b
hunk ./C/Gen.hs 288
-prettyArgs args = hcat (punctuate (text ", ") (map (\(t,i) -> prettyType t <+> text i) $ args))  
+prettyArgs args = hcat (punctuate (text ", ") (map (\(t,i) -> prettyType t <+> text i) $ args))
hunk ./C/Gen.hs 310
-        md = if any isNothing (fsts ts) then empty else text "default: jhc_case_fell_off(__LINE__);" 
+        md = if any isNothing (fsts ts) then empty else text "default: jhc_case_fell_off(__LINE__);"
hunk ./C/Gen.hs 312
-    sa = collectAuto ss 
-    sb = filter (not . isAuto) ss 
+    sa = collectAuto ss
+    sb = filter (not . isAuto) ss
hunk ./C/Gen.hs 338
-prettyExpr (CESizeof t) = text "sizeof" <>(parens $ prettyType t) 
+prettyExpr (CESizeof t) = text "sizeof" <>(parens $ prettyType t)
hunk ./C/Prims.hs 9
-data Requires = Requires { 
+data Requires = Requires {
hunk ./C/Prims.hs 19
-data Prim = 
+data Prim =
hunk ./C/Prims.hs 21
-    | CConst String ExtType  -- C code which evaluates to a constant            
+    | CConst String ExtType  -- C code which evaluates to a constant
hunk ./C/Prims.hs 25
-    | AddrOf String                        -- address of linker name 
+    | AddrOf String                        -- address of linker name
hunk ./C/Prims.hs 33
-    ws@(_:_) <- return $ words s 
-    let v = case last ws of 
+    ws@(_:_) <- return $ words s
+    let v = case last ws of
hunk ./C/Prims.hs 40
-    
+
hunk ./C/Prims.hs 44
-data APrim = APrim Prim Requires 
+data APrim = APrim Prim Requires
hunk ./C/Prims.hs 53
-    pprint (CConst s t) = parens (text t) <> parens (text s) 
-    pprint (Operator s xs r) = parens (text r) <> text s <> tupled (map text xs) 
-    pprint (Func _ s xs r) = parens (text r) <> text s <> tupled (map text xs) 
-    pprint (IFunc xs r) = parens (text r) <> parens (char '*') <> tupled (map text xs) 
+    pprint (CConst s t) = parens (text t) <> parens (text s)
+    pprint (Operator s xs r) = parens (text r) <> text s <> tupled (map text xs)
+    pprint (Func _ s xs r) = parens (text r) <> text s <> tupled (map text xs)
+    pprint (IFunc xs r) = parens (text r) <> parens (char '*') <> tupled (map text xs)
hunk ./CharIO.hs 4
-    putErr, 
-    putErrLn, 
-    putErrDie, 
-    CharIO.readFile, 
-    CharIO.print, 
+    putErr,
+    putErrLn,
+    putErrDie,
+    CharIO.readFile,
+    CharIO.print,
hunk ./CharIO.hs 21
-toUTF8 s = (map (chr. fromIntegral) $ toUTF s) 
-fromUTF8 s = fromUTF (map (fromIntegral . ord) s) 
+toUTF8 s = (map (chr. fromIntegral) $ toUTF s)
+fromUTF8 s = fromUTF (map (fromIntegral . ord) s)
hunk ./CharIO.hs 26
-putStr = Prelude.putStr . toUTF8  
-putStrLn = Prelude.putStrLn . toUTF8  
+putStr = Prelude.putStr . toUTF8
+putStrLn = Prelude.putStrLn . toUTF8
hunk ./DDataUtil.hs 6
-import qualified Data.Map as Map 
+import qualified Data.Map as Map
hunk ./DDataUtil.hs 18
-    
+
hunk ./DDataUtil.hs 79
-    
+
hunk ./DDataUtil.hs 97
-    
+
hunk ./DDataUtil.hs 106
-    
+
hunk ./DerivingDrift/DataP.hs 3
--- 
+--
hunk ./DerivingDrift/DataP.hs 9
-where 
+where
hunk ./DerivingDrift/DataP.hs 17
-			constraints :: [(Class,Var)], 
+			constraints :: [(Class,Var)],
hunk ./DerivingDrift/DataP.hs 22
-		deriving (Eq,Show) 
+		deriving (Eq,Show)
hunk ./DerivingDrift/DataP.hs 25
-		    types :: [HsBangType]} deriving (Eq,Show) 
+		    types :: [HsBangType]} deriving (Eq,Show)
hunk ./DerivingDrift/Drift.hs 17
-driftDerive :: HsModule -> IO HsModule 
+driftDerive :: HsModule -> IO HsModule
hunk ./DerivingDrift/Drift.hs 20
-        | otherwise = do         
+        | otherwise = do
hunk ./DerivingDrift/Drift.hs 26
-    --hsMod = case parse (unlines ss) (SrcLoc (show $ hsModuleName hsModule) 1 1) 0 [] of 
-    hsMod = case runParser parse (unlines ss)  of 
+    --hsMod = case parse (unlines ss) (SrcLoc (show $ hsModuleName hsModule) 1 1) 0 [] of
+    hsMod = case runParser parse (unlines ss)  of
hunk ./DerivingDrift/Drift.hs 35
-        let d =  toData  name args condecls derives 
-        xs <- return $  map (derive d . show) derives 
+        let d =  toData  name args condecls derives
+        xs <- return $  map (derive d . show) derives
hunk ./DerivingDrift/Drift.hs 39
-        let d =  toData  name args [condecl] derives 
-        xs <- return $ map (derive d . show) derives 
+        let d =  toData  name args [condecl] derives
+        xs <- return $ map (derive d . show) derives
hunk ./DerivingDrift/Drift.hs 45
-toData :: HsName -> [HsName] -> [HsConDecl] -> [HsName] -> Data 
+toData :: HsName -> [HsName] -> [HsConDecl] -> [HsName] -> Data
hunk ./DerivingDrift/Drift.hs 47
-    f c = Body { constructor = pp (show $ hsConDeclName c), types = hsConDeclArgs c, labels = lb c } 
+    f c = Body { constructor = pp (show $ hsConDeclName c), types = hsConDeclArgs c, labels = lb c }
hunk ./DerivingDrift/Drift.hs 56
-derive d wh | Just fn <- Map.lookup wh rulesMap = render $ fn d 
+derive d wh | Just fn <- Map.lookup wh rulesMap = render $ fn d
hunk ./DerivingDrift/RuleFunctorM.hs 4
-import List 
-import DerivingDrift.RuleUtils 
+import List
+import DerivingDrift.RuleUtils
hunk ./DerivingDrift/RuleFunctorM.hs 16
-			constraints :: [(Class,Var)], 
+			constraints :: [(Class,Var)],
hunk ./DerivingDrift/RuleFunctorM.hs 23
-		deriving (Eq,Show) 
+		deriving (Eq,Show)
hunk ./DerivingDrift/RuleFunctorM.hs 27
-		    types :: [Type]} deriving (Eq,Show) 
+		    types :: [Type]} deriving (Eq,Show)
hunk ./DerivingDrift/RuleFunctorM.hs 43
-namesupply   = [text [x,y] | x <- ['a' .. 'z'], 
+namesupply   = [text [x,y] | x <- ['a' .. 'z'],
hunk ./DerivingDrift/RuleFunctorM.hs 48
-  in thisns: mknss cs rest 
+  in thisns: mknss cs rest
hunk ./DerivingDrift/RuleFunctorM.hs 81
-    fs = map f' $ body 
+    fs = map f' $ body
hunk ./DerivingDrift/RuleFunctorM.hs 87
-        g (List t,n)  = n <+> lArrow <+> text "mapM" <+> lf t <+> n <> semicolon  where 
+        g (List t,n)  = n <+> lArrow <+> text "mapM" <+> lf t <+> n <> semicolon  where
hunk ./DerivingDrift/RuleFunctorM.hs 91
-        g (Tuple ts,n) = n <+> lArrow <+> (parens $ text "do" <+> tuple (varNames ts) <+> lArrow <+> text "return" <+> n <> semicolon  <+> hcat (map g (zip ts (varNames ts))) <> text "return" <+> tuple (varNames ts)) <> semicolon  
+        g (Tuple ts,n) = n <+> lArrow <+> (parens $ text "do" <+> tuple (varNames ts) <+> lArrow <+> text "return" <+> n <> semicolon  <+> hcat (map g (zip ts (varNames ts))) <> text "return" <+> tuple (varNames ts)) <> semicolon
hunk ./DerivingDrift/RuleFunctorM.hs 102
-    tt = if null vars then Con name else LApply (Con name) (map Var vars) 
+    tt = if null vars then Con name else LApply (Con name) (map Var vars)
hunk ./DerivingDrift/RuleFunctorM.hs 106
-    fs = map f' $ body 
+    fs = map f' $ body
hunk ./DerivingDrift/RuleFunctorM.hs 112
-        g (List t,n)  = n <+> lArrow <+> text "mapM" <+> lf t <+> n <> semicolon  where 
+        g (List t,n)  = n <+> lArrow <+> text "mapM" <+> lf t <+> n <> semicolon  where
hunk ./DerivingDrift/RuleFunctorM.hs 116
-        g (Tuple ts,n) = n <+> lArrow <+> (parens $ text "do" <+> tuple (varNames ts) <+> lArrow <+> text "return" <+> n <> semicolon  <+> hcat (map g (zip ts (varNames ts))) <> text "return" <+> tuple (varNames ts)) <> semicolon  
+        g (Tuple ts,n) = n <+> lArrow <+> (parens $ text "do" <+> tuple (varNames ts) <+> lArrow <+> text "return" <+> n <> semicolon  <+> hcat (map g (zip ts (varNames ts))) <> text "return" <+> tuple (varNames ts)) <> semicolon
hunk ./DerivingDrift/RuleMonoid.hs 4
-import List 
-import DerivingDrift.RuleUtils 
+import List
+import DerivingDrift.RuleUtils
hunk ./DerivingDrift/RuleMonoid.hs 15
-			constraints :: [(Class,Var)], 
+			constraints :: [(Class,Var)],
hunk ./DerivingDrift/RuleMonoid.hs 22
-		deriving (Eq,Show) 
+		deriving (Eq,Show)
hunk ./DerivingDrift/RuleMonoid.hs 26
-		    types :: [Type]} deriving (Eq,Show) 
+		    types :: [Type]} deriving (Eq,Show)
hunk ./DerivingDrift/RuleMonoid.hs 67
-    ins = instanceheader "Monoid" dat $$ 
+    ins = instanceheader "Monoid" dat $$
hunk ./DerivingDrift/RuleMonoid.hs 70
-    me = text "mempty" <+> equals <+> text (constructor body) <+> hsep (replicate lt (text "mempty"))     
+    me = text "mempty" <+> equals <+> text (constructor body) <+> hsep (replicate lt (text "mempty"))
hunk ./DerivingDrift/RuleUtility.hs 3
-import List 
+import List
hunk ./DerivingDrift/RuleUtility.hs 12
-    cls = text "class" <+> text className <+> typeName <+> cargs <+> text "where" $$ block fs 
+    cls = text "class" <+> text className <+> typeName <+> cargs <+> text "where" $$ block fs
hunk ./DerivingDrift/RuleUtility.hs 14
-    cargs = if null $ vars d then empty else dargs <+> text "|" <+> typeName <+> text "->" <+> dargs 
-    dargs =  hsep (map text $ vars d) 
+    cargs = if null $ vars d then empty else dargs <+> text "|" <+> typeName <+> text "->" <+> dargs
+    dargs =  hsep (map text $ vars d)
hunk ./DerivingDrift/RuleUtility.hs 19
-    is Body{constructor = constructor, types = types} = fn $$ dfn $$ ffn where 
+    is Body{constructor = constructor, types = types} = fn $$ dfn $$ ffn where
hunk ./DerivingDrift/RuleUtility.hs 21
-        fromName = "from" ++ constructor  
-        fn = ot fnName $  typeName <+> rArrow <+> text "Bool"   
+        fromName = "from" ++ constructor
+        fn = ot fnName $  typeName <+> rArrow <+> text "Bool"
hunk ./DerivingDrift/RuleUtility.hs 24
-        ffn = ot (text fromName) $ text "Monad _m =>" <+> typeName <+> rArrow <+> text "_m" <+> tuple (map prettyType types) 
+        ffn = ot (text fromName) $ text "Monad _m =>" <+> typeName <+> rArrow <+> text "_m" <+> tuple (map prettyType types)
hunk ./DerivingDrift/RuleUtility.hs 28
-    fi Body{constructor = constructor, types = types} = fn $$ dfn where 
-        fromName = "from" ++ constructor  
+    fi Body{constructor = constructor, types = types} = fn $$ dfn where
+        fromName = "from" ++ constructor
hunk ./DerivingDrift/RuleUtils.hs 10
--- Rule Declarations 
+-- Rule Declarations
hunk ./DerivingDrift/RuleUtils.hs 43
-blockList = braces . fcat . sepWith semi 
+blockList = braces . fcat . sepWith semi
hunk ./DerivingDrift/RuleUtils.hs 62
-opt1 a f g = f a 
+opt1 a f g = f a
hunk ./DerivingDrift/RuleUtils.hs 74
-simpleInstance s d = hsep [text "instance" 
+simpleInstance s d = hsep [text "instance"
hunk ./DerivingDrift/RuleUtils.hs 85
--- functions are not related to one another.  A member function is generated 
+-- functions are not related to one another.  A member function is generated
hunk ./DerivingDrift/RuleUtils.hs 94
-instanceSkeleton s ii  d = (simpleInstance s d <+> text "where") 
+instanceSkeleton s ii  d = (simpleInstance s d <+> text "where")
hunk ./DerivingDrift/RuleUtils.hs 98
-	f (i,dflt) = map i (body d) ++ [dflt]      
+	f (i,dflt) = map i (body d) ++ [dflt]
hunk ./DerivingDrift/RuleUtils.hs 103
-   where names = [text [x,y] | x <- ['a' .. 'z'], 
+   where names = [text [x,y] | x <- ['a' .. 'z'],
hunk ./DerivingDrift/StandardRules.hs 4
-import List 
+import List
hunk ./DerivingDrift/StandardRules.hs 39
-	| null types = text "rnf" <+> 
+	| null types = text "rnf" <+>
hunk ./DerivingDrift/StandardRules.hs 41
-	| otherwise = let 
+	| otherwise = let
hunk ./DerivingDrift/StandardRules.hs 43
-   head = [pattern constructor vars, equals] 
+   head = [pattern constructor vars, equals]
hunk ./DerivingDrift/StandardRules.hs 50
--- 
+--
hunk ./DerivingDrift/StandardRules.hs 52
--- the corresponding update fn has type (a -> a) -> G -> G 
+-- the corresponding update fn has type (a -> a) -> G -> G
hunk ./DerivingDrift/StandardRules.hs 55
--- an example of what we want to generate 
+-- an example of what we want to generate
hunk ./DerivingDrift/StandardRules.hs 57
--- 
+--
hunk ./DerivingDrift/StandardRules.hs 64
-	| otherwise = commentLine $ 
-	text "Warning - can't derive `update' functions for non-record type: " 
-	<+> text name 
-	where 
+	| otherwise = commentLine $
+	text "Warning - can't derive `update' functions for non-record type: "
+	<+> text name
+	where
hunk ./DerivingDrift/StandardRules.hs 71
-    sets = map genset . nub . map fst $ labs 
-    f :: Body -> [(Name,Constructor)] 
+    sets = map genset . nub . map fst $ labs
+    f :: Body -> [(Name,Constructor)]
hunk ./DerivingDrift/StandardRules.hs 78
-        up c = hsep [text (n ++ "_u") , char 'f' 
-            , char 'r' <> char '@' <> text c <> braces (text n <+> text " = x") 
-            , equals , char 'r' <> braces (hsep [text n, text "= f x"])] 
+        up c = hsep [text (n ++ "_u") , char 'f'
+            , char 'r' <> char '@' <> text c <> braces (text n <+> text " = x")
+            , equals , char 'r' <> braces (hsep [text n, text "= f x"])]
hunk ./DerivingDrift/StandardRules.hs 86
-    genset n = hsep [text (n ++ "_s v = "), text (n ++ "_u"), text " (const v)"] 
+    genset n = hsep [text (n ++ "_s v = "), text (n ++ "_u"), text " (const v)"]
hunk ./DerivingDrift/StandardRules.hs 91
-	| otherwise = commentLine $ 
-	text "Warning - can't derive `get' functions for non-record type: " 
-	<+> text name 
-	where 
+	| otherwise = commentLine $
+	text "Warning - can't derive `get' functions for non-record type: "
+	<+> text name
+	where
hunk ./DerivingDrift/StandardRules.hs 97
-    updates = map genup labs 
-    sets = map genset . nub . map fst $ labs 
-    f :: Body -> [(Name,Constructor)] 
+    updates = map genup labs
+    sets = map genset . nub . map fst $ labs
+    f :: Body -> [(Name,Constructor)]
hunk ./DerivingDrift/StandardRules.hs 106
-        up c = hsep [text fn 
-            , char 'r' <> char '@' <> text c <> braces (text n <+> text " = x") 
-            , equals , text "return x"] 
+        up c = hsep [text fn
+            , char 'r' <> char '@' <> text c <> braces (text n <+> text " = x")
+            , equals , text "return x"]
hunk ./DerivingDrift/StandardRules.hs 114
-    genset n = hsep [text (n ++ "_s v = "), text (n ++ "_u"), text " (const v)"] 
+    genset n = hsep [text (n ++ "_s v = "), text (n ++ "_u"), text " (const v)"]
hunk ./DerivingDrift/StandardRules.hs 122
-	is Body{constructor=constructor,types=types} = let 
+	is Body{constructor=constructor,types=types} = let
hunk ./DerivingDrift/StandardRules.hs 124
-		fn = fnName <+> 
+		fn = fnName <+>
hunk ./DerivingDrift/StandardRules.hs 131
-    from Body{constructor=constructor,types=types} = fn $$ defaultFn where 
+    from Body{constructor=constructor,types=types} = fn $$ defaultFn where
hunk ./DerivingDrift/StandardRules.hs 134
-            fn = fnName' <+> 
+            fn = fnName' <+>
hunk ./DerivingDrift/StandardRules.hs 141
-	| otherwise = commentLine $ 
+	| otherwise = commentLine $
hunk ./DerivingDrift/StandardRules.hs 144
-	where     
+	where
hunk ./DerivingDrift/StandardRules.hs 149
-		in fsep[fnName, pattern, text "=", bool]     	    
-	labs = nub . concatMap (labels) $  body       
-		       
+		in fsep[fnName, pattern, text "=", bool]     	
+	labs = nub . concatMap (labels) $  body
+		
hunk ./DerivingDrift/StandardRules.hs 154
--- for newtype N = T a , unN :: T -> a 
+-- for newtype N = T a , unN :: T -> a
hunk ./DerivingDrift/StandardRules.hs 157
-unfn (D{body=body,name=name,statement=statement}) | statement == DataStmt 
-	= commentLine 
-	  $ text "Warning - can't derive 'un' function for data declaration " 
+unfn (D{body=body,name=name,statement=statement}) | statement == DataStmt
+	= commentLine
+	  $ text "Warning - can't derive 'un' function for data declaration "
hunk ./DerivingDrift/StandardRules.hs 165
-	      in fsep [fnName,pattern, equals, text "a"] 
+	      in fsep [fnName,pattern, equals, text "a"]
hunk ./DerivingDrift/StandardRules.hs 174
-dattest d =  commentBlock . vcat $ 
+dattest d =  commentBlock . vcat $
hunk ./DerivingDrift/StandardRules.hs 188
-eqfn = instanceSkeleton "Eq" [(makeEq,defaultEq)] 
+eqfn = instanceSkeleton "Eq" [(makeEq,defaultEq)]
hunk ./DerivingDrift/StandardRules.hs 195
-	v' = varNames' types 
+	v' = varNames' types
hunk ./DerivingDrift/StandardRules.hs 198
-	body = sepWith (text "&&") $ 
+	body = sepWith (text "&&") $
hunk ./DerivingDrift/StandardRules.hs 208
-ordfn d = let 
+ordfn d = let
hunk ./DerivingDrift/StandardRules.hs 213
-   f (b,n) (b',n') 
+   f (b,n) (b',n')
hunk ./DerivingDrift/StandardRules.hs 219
-		      head  = fsep [l,r, char '='] 
+		      head  = fsep [l,r, char '=']
hunk ./DerivingDrift/StandardRules.hs 238
--- 	won't work for infix constructors 
+-- 	won't work for infix constructors
hunk ./DerivingDrift/StandardRules.hs 241
--- Show 
+-- Show
hunk ./DerivingDrift/StandardRules.hs 243
-showfn = instanceSkeleton "Show" [(makeShow,empty)] 
+showfn = instanceSkeleton "Show" [(makeShow,empty)]
hunk ./DerivingDrift/StandardRules.hs 267
--- Read 
+-- Read
hunk ./DerivingDrift/StandardRules.hs 284
-	read = lambda . listComp (result rest) 
+	read = lambda . listComp (result rest)
hunk ./DerivingDrift/StandardRules.hs 297
-		in lambda . listComp (result rest) 
-			$ lexConstr ip : openB 
+		in lambda . listComp (result rest)
+			$ lexConstr ip : openB
hunk ./DerivingDrift/StandardRules.hs 302
-	listComp x (l:ll) = brackets . fsep . sepWith comma $  
+	listComp x (l:ll) = brackets . fsep . sepWith comma $
hunk ./DerivingDrift/StandardRules.hs 320
-enumfn d = let 
+enumfn d = let
hunk ./DerivingDrift/StandardRules.hs 325
-	   then commentLine $ text "Warning -- can't derive Enum for" 
+	   then commentLine $ text "Warning -- can't derive Enum for"
hunk ./DerivingDrift/StandardRules.hs 327
-	   else simpleInstance "Enum" d <+> text "where" 
+	   else simpleInstance "Enum" d <+> text "where"
hunk ./DerivingDrift/StandardRules.hs 334
-		texts [constructor , "=", show n])	 
+		texts [constructor , "=", show n])	
hunk ./DerivingDrift/StandardRules.hs 340
-		texts [show n , "=", constructor])    
+		texts [show n , "=", constructor])
hunk ./DerivingDrift/StandardRules.hs 343
-enumFromFn D{body=body} = let 
+enumFromFn D{body=body} = let
hunk ./DerivingDrift/StandardRules.hs 345
-	bodydoc = fsep [char 'e', char '=', text "drop", 
+	bodydoc = fsep [char 'e', char '=', text "drop",
hunk ./DerivingDrift/StandardRules.hs 363
-boundedfn d@D{name=name,body=body,derives=derives} 
+boundedfn d@D{name=name,body=body,derives=derives}
hunk ./DerivingDrift/StandardRules.hs 377
-		hsep . texts $ [ "minBound","=",constructor f] ++ 
+		hsep . texts $ [ "minBound","=",constructor f] ++
hunk ./DerivingDrift/UserRuleBinary.hs 15
-			constraints :: [(Class,Var)], 
+			constraints :: [(Class,Var)],
hunk ./DerivingDrift/UserRuleBinary.hs 22
-		deriving (Eq,Show) 
+		deriving (Eq,Show)
hunk ./DerivingDrift/UserRuleBinary.hs 26
-		    types :: [Type]} deriving (Eq,Show) 
+		    types :: [Type]} deriving (Eq,Show)
hunk ./DerivingDrift/UserRuleBinary.hs 41
-namesupply   = [text [x,y] | x <- ['a' .. 'z'], 
+namesupply   = [text [x,y] | x <- ['a' .. 'z'],
hunk ./DerivingDrift/UserRuleBinary.hs 46
-  in thisns: mknss cs rest 
+  in thisns: mknss cs rest
hunk ./DerivingDrift/UserRuleBinary.hs 72
-userRuleBinary dat = 
+userRuleBinary dat =
hunk ./DerivingDrift/UserRuleGhcBinary.hs 15
-			constraints :: [(Class,Var)], 
+			constraints :: [(Class,Var)],
hunk ./DerivingDrift/UserRuleGhcBinary.hs 22
-		deriving (Eq,Show) 
+		deriving (Eq,Show)
hunk ./DerivingDrift/UserRuleGhcBinary.hs 26
-		    types :: [Type]} deriving (Eq,Show) 
+		    types :: [Type]} deriving (Eq,Show)
hunk ./DerivingDrift/UserRuleGhcBinary.hs 41
-namesupply   = [text [x,y] | x <- ['a' .. 'z'], 
+namesupply   = [text [x,y] | x <- ['a' .. 'z'],
hunk ./DerivingDrift/UserRuleGhcBinary.hs 46
-  in thisns: mknss cs rest 
+  in thisns: mknss cs rest
hunk ./DerivingDrift/UserRuleGhcBinary.hs 72
-userRuleGhcBinary dat = 
+userRuleGhcBinary dat =
hunk ./DerivingDrift/UserRuleGhcBinary.hs 83
-putfn 1 _ [] c = 
+putfn 1 _ [] c =
hunk ./DerivingDrift/UserRuleGhcBinary.hs 85
-putfn 1 _ cv c = 
+putfn 1 _ cv c =
hunk ./DerivingDrift/UserRuleGhcBinary.hs 88
-    vcat (map (text "put_ bh" <+>) cv) 
+    vcat (map (text "put_ bh" <+>) cv)
hunk ./DerivingDrift/UserRuleGhcBinary.hs 100
-getfn _ _ [[]] [c] = 
+getfn _ _ [[]] [c] =
hunk ./DerivingDrift/UserRuleGhcBinary.hs 102
-getfn _ _ [vs] [c] = 
+getfn _ _ [vs] [c] =
hunk ./DerivingDrift/UserRuleXml.hs 14
-			constraints :: [(Class,Var)], 
+			constraints :: [(Class,Var)],
hunk ./DerivingDrift/UserRuleXml.hs 21
-		deriving (Eq,Show) 
+		deriving (Eq,Show)
hunk ./DerivingDrift/UserRuleXml.hs 25
-		    types :: [Type]} deriving (Eq,Show) 
+		    types :: [Type]} deriving (Eq,Show)
hunk ./DerivingDrift/UserRuleXml.hs 38
-userRuleXml dat = 
+userRuleXml dat =
hunk ./DerivingDrift/UserRuleXml.hs 66
-namesupply   = [text [x,y] | x <- ['a' .. 'z'], 
+namesupply   = [text [x,y] | x <- ['a' .. 'z'],
hunk ./DerivingDrift/UserRuleXml.hs 72
-  in thisns: mknss cs rest 
+  in thisns: mknss cs rest
hunk ./DerivingDrift/UserRules.hs 4
-import DerivingDrift.RuleUtils(RuleDef) -- gives some examples 
+import DerivingDrift.RuleUtils(RuleDef) -- gives some examples
hunk ./DerivingDrift/UserRules.hs 10
-import qualified DerivingDrift.RuleUtility 
+import qualified DerivingDrift.RuleUtility
hunk ./DerivingDrift/UserRulesGeneric.hs 26
-namesupply   = [text [x,y] | x <- ['a' .. 'z'], 
+namesupply   = [text [x,y] | x <- ['a' .. 'z'],
hunk ./DerivingDrift/UserRulesGeneric.hs 31
-  in thisns: mknss cs rest 
+  in thisns: mknss cs rest
hunk ./DerivingDrift/UserRulesGeneric.hs 58
-typeablefn  dat  
+typeablefn  dat
hunk ./DerivingDrift/UserRulesGeneric.hs 61
-	[ text "typeOf x = mkAppTy"  <+> 
-	  tcname <+> 
-	  text "[" <+> hcat (sepWith comma (map getV' (vars dat))) <+> text "]" $$ 
-	  wheres ]) 
+	[ text "typeOf x = mkAppTy"  <+>
+	  tcname <+>
+	  text "[" <+> hcat (sepWith comma (map getV' (vars dat))) <+> text "]" $$
+	  wheres ])
hunk ./DerivingDrift/UserRulesGeneric.hs 71
-      getV var 
+      getV var
hunk ./DerivingDrift/UserRulesGeneric.hs 75
-where_decls [] = empty 
+where_decls [] = empty
hunk ./DerivingDrift/UserRulesGeneric.hs 79
-dyntermfn dat = instanceheader "Term" dat $$ block [ 
+dyntermfn dat = instanceheader "Term" dat $$ block [
hunk ./DerivingDrift/UserRulesGeneric.hs 84
-	    g cv c = text "g" <+> ppCons underscores c <+> text "xs" <+> 
---		text "|" <+> mkList (vrs c cv) <+> text "<- TermRep.fArgs xs" <+> equals <+> text "toDyn" <+> parens (parens (text (constructor c) <+> hsep (map h (vrs c cv))) <> text "::a" ) 
+	    g cv c = text "g" <+> ppCons underscores c <+> text "xs" <+>
+--		text "|" <+> mkList (vrs c cv) <+> text "<- TermRep.fArgs xs" <+> equals <+> text "toDyn" <+> parens (parens (text (constructor c) <+> hsep (map h (vrs c cv))) <> text "::a" )
hunk ./DerivingDrift/UserRulesGeneric.hs 93
-    
+
hunk ./DerivingDrift/UserRulesGeneric.hs 95
--- begin observable 
+-- begin observable
hunk ./DerivingDrift/UserRulesGeneric.hs 98
-observablefn  dat = 
+observablefn  dat =
hunk ./DerivingDrift/UserRulesGeneric.hs 102
-  instanceheader "Observable" dat $$ 
+  instanceheader "Observable" dat $$
hunk ./DerivingDrift/UserRulesGeneric.hs 105
-observefn cv c = 
+observefn cv c =
hunk ./DerivingDrift/UserRulesGeneric.hs 114
--- begin of ATermConvertible derivation 
+-- begin of ATermConvertible derivation
hunk ./DerivingDrift/UserRulesGeneric.hs 118
-  = instanceSkeleton "ATermConvertible" 
+  = instanceSkeleton "ATermConvertible"
hunk ./DerivingDrift/UserRulesGeneric.hs 121
-      ] 
+      ]
hunk ./DerivingDrift/UserRulesGeneric.hs 126
-    in text "toATerm" <+> 
+    in text "toATerm" <+>
hunk ./DerivingDrift/UserRulesGeneric.hs 131
-       text "[" <+> 
-       hcat (intersperse (text ",") (map childToATerm cvs)) <+> 
+       text "[" <+>
+       hcat (intersperse (text ",") (map childToATerm cvs)) <+>
hunk ./DerivingDrift/UserRulesGeneric.hs 141
-    in text "fromATerm" <+> 
+    in text "fromATerm" <+>
hunk ./DerivingDrift/UserRulesGeneric.hs 144
-       text "[" <+> 
-       hcat (intersperse (text ",") cvs) <+> 
+       text "[" <+>
+       hcat (intersperse (text ",") cvs) <+>
hunk ./DerivingDrift/UserRulesGeneric.hs 158
--- begin of HFoldable derivation 
+-- begin of HFoldable derivation
hunk ./DerivingDrift/UserRulesGeneric.hs 162
-  = instanceSkeleton "HFoldable" 
+  = instanceSkeleton "HFoldable"
hunk ./DerivingDrift/UserRulesGeneric.hs 165
-      ] 
+      ]
hunk ./DerivingDrift/UserRulesGeneric.hs 170
-    in text "hfoldr'" <+> 
+    in text "hfoldr'" <+>
hunk ./DerivingDrift/UserRulesGeneric.hs 174
-       foldl (\rest var -> text "hcons alg" <+> var  <+> parens rest) 
+       foldl (\rest var -> text "hcons alg" <+> var  <+> parens rest)
hunk ./DerivingDrift/UserRulesGeneric.hs 176
-             cvs 
+             cvs
hunk ./DerivingDrift/UserRulesGeneric.hs 180
-  
+
hunk ./DerivingDrift/UserRulesGeneric.hs 183
-    in text "conOf" <+> 
+    in text "conOf" <+>
hunk ./E/CPR.hs 64
-        (e',v) -> f (envInsert t v env) rs ((tvrInfo_u (Info.insert v) t,e'):zs) 
+        (e',v) -> f (envInsert t v env) rs ((tvrInfo_u (Info.insert v) t,e'):zs)
hunk ./E/CPR.hs 67
-            nenv = Env (Map.fromList [ (t,b) | (t,(e,b)) <- mp]) `mappend` env 
+            nenv = Env (Map.fromList [ (t,b) | (t,(e,b)) <- mp]) `mappend` env
hunk ./E/CPR.hs 69
-            nenv = Env (Map.fromList [ (t,b) | (t,(e,b)) <- mp]) `mappend` env 
+            nenv = Env (Map.fromList [ (t,b) | (t,(e,b)) <- mp]) `mappend` env
hunk ./E/CPR.hs 73
-envInsert :: TVr -> Val -> Env -> Env 
+envInsert :: TVr -> Val -> Env -> Env
hunk ./E/CPR.hs 77
-cprAnalyze (Env mp) (EVar v) 
+cprAnalyze (Env mp) (EVar v)
hunk ./E/CPR.hs 82
-    (ds',env') = cprAnalyzeBinds env ds   
+    (ds',env') = cprAnalyzeBinds env ds
hunk ./E/CPR.hs 85
-    (e',val) = cprAnalyze (envInsert t Top env) e 
+    (e',val) = cprAnalyze (envInsert t Top env) e
hunk ./E/CPR.hs 88
-        (e',v) <- return $ cprAnalyze env e 
+        (e',v) <- return $ cprAnalyze env e
hunk ./E/CPR.hs 105
-    f e = error $ "cprAnalyze.f: " ++ show e 
+    f e = error $ "cprAnalyze.f: " ++ show e
hunk ./E/Diff.hs 11
-     
+
hunk ./E/Diff.hs 16
-    f (ELetRec ds e) (ELetRec ds' e') = (ELetRec (g ds ds') e, ELetRec (g ds' ds) e') 
+    f (ELetRec ds e) (ELetRec ds' e') = (ELetRec (g ds ds') e, ELetRec (g ds' ds) e')
hunk ./E/Diff.hs 24
-    
+
hunk ./E/Diff.hs 29
-    let f e@ELam {} = tick stats "lambda" >> emapE' f e 
-        f e@EVar {} = tick stats "var-use" >> return e 
+    let f e@ELam {} = tick stats "lambda" >> emapE' f e
+        f e@EVar {} = tick stats "var-use" >> return e
hunk ./E/Diff.hs 37
-            tick stats "case" 
+            tick stats "case"
hunk ./E/Diff.hs 43
-    
-    
+
+
hunk ./E/Eval.hs 35
-        f (Right _:_) _ = error $ "cannot eval recursive let" 
+        f (Right _:_) _ = error $ "cannot eval recursive let"
hunk ./E/Eval.hs 39
-    unwind t (t1:rest) = unwind (EAp t $ eval t1) rest 
+    unwind t (t1:rest) = unwind (EAp t $ eval t1) rest
hunk ./E/Eval.hs 50
-    un (EAp a b) (EAp a' b') mm c = do 
+    un (EAp a b) (EAp a' b') mm c = do
hunk ./E/Eval.hs 54
-        un t u mm c 
+        un t u mm c
hunk ./E/Eval.hs 58
-    un (ELam va ea) (ELam vb eb) mm c = lam va ea vb eb mm c  
-    un (EPi va ea) (EPi vb eb) mm c = lam va ea vb eb mm c  
+    un (ELam va ea) (ELam vb eb) mm c = lam va ea vb eb mm c
+    un (EPi va ea) (EPi vb eb) mm c = lam va ea vb eb mm c
hunk ./E/Eval.hs 61
-        sequence_ [ un x y mm c | x <- xs | y <- ys] 
-        un t t' mm c 
+        sequence_ [ un x y mm c | x <- xs | y <- ys]
+        un t t' mm c
hunk ./E/Eval.hs 68
-        sequence_ [ un x y mm c | x <- xs | y <- ys] 
-        un t t' mm c 
+        sequence_ [ un x y mm c | x <- xs | y <- ys]
+        un t t' mm c
hunk ./E/Eval.hs 75
-    
+
hunk ./E/Eval.hs 78
-        
+
hunk ./E/Eval.hs 90
-        let ds' = Map.delete v ds 
+        let ds' = Map.delete v ds
hunk ./E/Eval.hs 95
-        let ds' = Map.delete v ds 
+        let ds' = Map.delete v ds
hunk ./E/Eval.hs 102
-    eval' ds (ELit (LitCons n es t)) [] = do  
-        es' <- mapM (\e -> eval' ds e []) es 
+    eval' ds (ELit (LitCons n es t)) [] = do
+        es' <- mapM (\e -> eval' ds e []) es
hunk ./E/Eval.hs 105
-        return $ ELit $ LitCons n es' t' 
+        return $ ELit $ LitCons n es' t'
hunk ./E/Eval.hs 113
-    eval' ds t@(EVar v) stack  
+    eval' ds t@(EVar v) stack
hunk ./E/Eval.hs 118
-    eval' ds (ELetRec ds' e) stack = eval' (Map.fromList ds'  `mappend` ds) e  stack 
+    eval' ds (ELetRec ds' e) stack = eval' (Map.fromList ds'  `mappend` ds) e  stack
hunk ./E/Eval.hs 122
-    --    f (Right _:_) _ = error $ "cannot eval recursive let" 
+    --    f (Right _:_) _ = error $ "cannot eval recursive let"
hunk ./E/Eval.hs 124
---        e' <- eval' ds e [] 
+--        e' <- eval' ds e []
hunk ./E/Eval.hs 135
-        
+
hunk ./E/Eval.hs 141
-        unwind ds (EAp t $ e) rest 
+        unwind ds (EAp t $ e) rest
hunk ./E/Inline.hs 20
--- To decide whether to inline, we take a few things into account 
+-- To decide whether to inline, we take a few things into account
hunk ./E/Inline.hs 22
-                       
-baseInlinability e 
+
+baseInlinability e
hunk ./E/Inline.hs 25
-    | whnfOrBot e = 4 
+    | whnfOrBot e = 4
hunk ./E/Inline.hs 28
-basicDecompose :: 
+basicDecompose ::
hunk ./E/Inline.hs 36
-    cg zs =  newGraph zs (\ (_,x,_) -> x) ( \ (_,_,x) -> x) 
+    cg zs =  newGraph zs (\ (_,x,_) -> x) ( \ (_,_,x) -> x)
hunk ./E/Inline.hs 38
-    scc' = scc tg 
-    scc'' = case prune of 
+    scc' = scc tg
+    scc'' = case prune of
hunk ./E/Inline.hs 49
-inlineDecompose :: 
+inlineDecompose ::
hunk ./E/Inline.hs 56
-    cg zs =  newGraph zs (\ (_,x,_,_) -> x) ( \ (_,_,x,_) -> x) 
+    cg zs =  newGraph zs (\ (_,x,_,_) -> x) ( \ (_,_,x,_) -> x)
hunk ./E/Inline.hs 58
-    scc' = scc tg 
-    scc'' = case prune of 
+    scc' = scc tg
+    scc'' = case prune of
hunk ./E/Inline.hs 62
-    inlinability e = baseInlinability e - size (fst $ fromLam e)   
+    inlinability e = baseInlinability e - size (fst $ fromLam e)
hunk ./E/Inline.hs 70
- 
-    
+
+
hunk ./E/Inline.hs 75
-    --tg = newGraph zs (\ (_,x,_,_) -> x) ( \ (_,_,x,_) -> x) 
+    --tg = newGraph zs (\ (_,x,_,_) -> x) ( \ (_,_,x,_) -> x)
hunk ./E/Inline.hs 77
-    inlinability e = baseInlinability e - size (fst $ fromLam e)   
+    inlinability e = baseInlinability e - size (fst $ fromLam e)
hunk ./E/Inline.hs 97
-    as' <- mapmAlt as 
+    as' <- mapmAlt as
hunk ./E/Inline.hs 118
-    as' <- mapmAlt' as 
+    as' <- mapmAlt' as
hunk ./E/Inline.hs 125
-mapmTvr f (TVr x e) = f e >>= return . TVr x 
+mapmTvr f (TVr x e) = f e >>= return . TVr x
hunk ./E/Inline.hs 145
-emapE f = emapEG f f 
-emapE' f = emapEG f return 
+emapE f = emapEG f f
+emapE' f = emapEG f return
hunk ./E/Inline.hs 161
-        as' <- mapM mapmAlt as 
+        as' <- mapM mapmAlt as
hunk ./E/Inline.hs 182
-    mconcat = sum 
+    mconcat = sum
hunk ./E/Inline.hs 186
-    
+
hunk ./E/Inline.hs 189
-    (_, n) = runWriter (f e) 
+    (_, n) = runWriter (f e)
hunk ./E/LambdaLift.hs 33
-    ds' = [ (a,b,c) | (a,(c,b)) <- [ (t,fromLam e) | (t,e) <- ds ]] 
-eToSC dt (ELetRec ds e) = SC tvr ((tvr,as,e'):ds') where 
+    ds' = [ (a,b,c) | (a,(c,b)) <- [ (t,fromLam e) | (t,e) <- ds ]]
+eToSC dt (ELetRec ds e) = SC tvr ((tvr,as,e'):ds') where
hunk ./E/LambdaLift.hs 39
-    ds' = [ (a,b,c) | (a,(c,b)) <- [ (t,fromLam e) | (t,e) <- ds ]] 
+    ds' = [ (a,b,c) | (a,(c,b)) <- [ (t,fromLam e) | (t,e) <- ds ]]
hunk ./E/LambdaLift.hs 46
--- | pull lets from just in definitions to top level, as they can obscure lambdas. 
+-- | pull lets from just in definitions to top level, as they can obscure lambdas.
hunk ./E/LambdaLift.hs 49
-    f (t,[],ELetRec ds e) = fd (t,e):map fd ds 
+    f (t,[],ELetRec ds e) = fd (t,e):map fd ds
hunk ./E/LambdaLift.hs 63
-lambdaLift :: Stats -> DataTable -> SC -> IO SC 
+lambdaLift :: Stats -> DataTable -> SC -> IO SC
hunk ./E/LambdaLift.hs 72
-        f e@(ELetRec ds _)  = do 
+        f e@(ELetRec ds _)  = do
hunk ./E/LambdaLift.hs 76
-        f e = do 
-            st <- asks isStrict 
+        f e = do
+            st <- asks isStrict
hunk ./E/LambdaLift.hs 91
-            True <- asks isStrict 
-            d' <- fmapM f d 
+            True <- asks isStrict
+            d' <- fmapM f d
hunk ./E/LambdaLift.hs 94
-                    e' <- local (declEnv_u ((v,patToLitEE l):)) $ f e 
+                    e' <- local (declEnv_u ((v,patToLitEE l):)) $ f e
hunk ./E/LambdaLift.hs 96
-            as' <- mapM z as 
+            as' <- mapM z as
hunk ./E/LambdaLift.hs 102
-            let fvs = freeVars e 
+            let fvs = freeVars e
hunk ./E/LambdaLift.hs 107
-                f (s:ss) e x  
+                f (s:ss) e x
hunk ./E/LambdaLift.hs 110
-                fvs'' = reverse $ topSort $ newGraph fvs' tvrNum freeVars 
+                fvs'' = reverse $ topSort $ newGraph fvs' tvrNum freeVars
hunk ./E/LambdaLift.hs 119
-            let fvs =  freeVars e 
+            let fvs =  freeVars e
hunk ./E/LambdaLift.hs 124
-                _ ->  local (isStrict_s False) (f e) >>= \e'' -> h ds rest ((t,e''):ds') 
-        h ((t,e):ds) e' ds' = local (isStrict_s False) (f e) >>= \e'' -> h ds e' ((t,e''):ds') 
-        h [] e ds = f e >>= return . eLetRec ds 
+                _ ->  local (isStrict_s False) (f e) >>= \e'' -> h ds rest ((t,e''):ds')
+        h ((t,e):ds) e' ds' = local (isStrict_s False) (f e) >>= \e'' -> h ds e' ((t,e''):ds')
+        h [] e ds = f e >>= return . eLetRec ds
hunk ./E/LambdaLift.hs 133
-            let (e',ls) = fromLam e 
+            let (e',ls) = fromLam e
hunk ./E/LambdaLift.hs 142
-            return $ tVr (atomIndex (n `mappend` toAtom '$' `mappend` toAtom (show  un))) tt 
+            return $ tVr (atomIndex (n `mappend` toAtom '$' `mappend` toAtom (show  un))) tt
hunk ./E/LambdaLift.hs 148
-            let (e',ls) = fromLam e 
-            e'' <- local (isStrict_s True) $ f e' 
+            let (e',ls) = fromLam e
+            e'' <- local (isStrict_s True) $ f e'
hunk ./E/LambdaLift.hs 153
-            
+
hunk ./E/LambdaLift.hs 158
-    ncs <- readIORef fc 
+    ncs <- readIORef fc
hunk ./E/LambdaLift.hs 160
-            
-            
+
+
hunk ./E/LambdaLift.hs 166
-    f tv@(TVr { tvrType = ty} ) e = ELam nt (subst tv (EVar nt) e) where nt = tv { tvrType = (subst t v ty) }  
-    
+    f tv@(TVr { tvrType = ty} ) e = ELam nt (subst tv (EVar nt) e) where nt = tv { tvrType = (subst t v ty) }
+
hunk ./E/LambdaLift.hs 173
---            let fvs =  freeVars e 
+--            let fvs =  freeVars e
hunk ./E/LambdaLift.hs 176
---                fvs'' = reverse $ topSort $ newGraph fvs' tvrNum freeVars 
+--                fvs'' = reverse $ topSort $ newGraph fvs' tvrNum freeVars
hunk ./E/LambdaLift.hs 180
-    
+
hunk ./E/LambdaLift.hs 182
---        f e = do 
---            st <- asks isStrict 
+--        f e = do
+--            st <- asks isStrict
hunk ./E/LambdaLift.hs 185
---                let (fvs :: [TVr]) = freeVars e 
+--                let (fvs :: [TVr]) = freeVars e
hunk ./E/LambdaLift.hs 188
---                    fvs'' = reverse $ topSort $ newGraph fvs' tvrNum freeVars 
+--                    fvs'' = reverse $ topSort $ newGraph fvs' tvrNum freeVars
hunk ./E/PrimOpt.hs 23
-    runStatIO stats (primOpt' dataTable e)  
+    runStatIO stats (primOpt' dataTable e)
hunk ./E/PrimOpt.hs 26
-    te = typ e       
+    te = typ e
hunk ./E/PrimOpt.hs 35
-unbox :: DataTable -> E -> Int -> (TVr -> E) -> E 
-unbox dataTable e vn wtd = ECase e (tVr 0 te) [Alt (LitCons cna [tvra] te) (wtd tvra)] Nothing where 
-    te = typ e       
-    tvra = tVr vn sta 
+unbox :: DataTable -> E -> Int -> (TVr -> E) -> E
+unbox dataTable e vn wtd = ECase e (tVr 0 te) [Alt (LitCons cna [tvra] te) (wtd tvra)] Nothing where
+    te = typ e
+    tvra = tVr vn sta
hunk ./E/PrimOpt.hs 71
-                    unbox dataTable b varb $ \tvrb -> 
-                        eStrictLet (tVr varc sta) (EPrim (APrim (Operator "/" [ta,ta] ta) mempty) [EVar tvra, EVar tvrb] sta) (ELit (LitCons cna [EVar (tVr varc sta)] t)) 
+                    unbox dataTable b varb $ \tvrb ->
+                        eStrictLet (tVr varc sta) (EPrim (APrim (Operator "/" [ta,ta] ta) mempty) [EVar tvra, EVar tvrb] sta) (ELit (LitCons cna [EVar (tVr varc sta)] t))
hunk ./E/PrimOpt.hs 80
-            (cn,st,ct) <- case lookupCType' dataTable t of 
+            (cn,st,ct) <- case lookupCType' dataTable t of
hunk ./E/PrimOpt.hs 85
-            
-        
+
+
hunk ./E/PrimOpt.hs 151
-            
-        
+
+
hunk ./E/PrimOpt.hs 158
-            
+
hunk ./E/Rules.hs 2
-    Rules, 
+    Rules,
hunk ./E/Rules.hs 50
-emptyRule = Rule { 
-    ruleHead = error "ruleHead undefined", 
+emptyRule = Rule {
+    ruleHead = error "ruleHead undefined",
hunk ./E/Rules.hs 59
-newtype Rules = Rules (Map.Map TVr [Rule]) 
+newtype Rules = Rules (Map.Map TVr [Rule])
hunk ./E/Rules.hs 62
-mapBodies :: (E ->  E) -> Rules ->  Rules 
+mapBodies :: (E ->  E) -> Rules ->  Rules
hunk ./E/Rules.hs 68
-ruleAllFreeVars (Rules r) = freeVars (concatMap (map ruleBody) (Map.elems r)) 
+ruleAllFreeVars (Rules r) = freeVars (concatMap (map ruleBody) (Map.elems r))
hunk ./E/Rules.hs 73
-    --Just rs -> mconcat (map ruleFvs rs) -- (freeVars (map ruleBody rs) Set.\\ freeVars (map ruleArgs rs)) 
-    Just rs -> (freeVars (map ruleBody rs) Set.\\ freeVars (map ruleArgs rs)) 
+    --Just rs -> mconcat (map ruleFvs rs) -- (freeVars (map ruleBody rs) Set.\\ freeVars (map ruleArgs rs))
+    Just rs -> (freeVars (map ruleBody rs) Set.\\ freeVars (map ruleArgs rs))
hunk ./E/Rules.hs 78
-    --Just rs -> mconcat (map ruleFvs rs) -- (freeVars (map ruleBody rs) Set.\\ freeVars (map ruleArgs rs)) 
-    Just rs -> (freeVars (map ruleBody rs) Set.\\ freeVars (map ruleArgs rs)) 
+    --Just rs -> mconcat (map ruleFvs rs) -- (freeVars (map ruleBody rs) Set.\\ freeVars (map ruleArgs rs))
+    Just rs -> (freeVars (map ruleBody rs) Set.\\ freeVars (map ruleArgs rs))
hunk ./E/Rules.hs 82
-    putErrLn $ fromAtom (ruleName rule)  
-    putErr $ "    " ++ render (ePretty (foldl EAp (EVar $ ruleHead rule) (ruleArgs rule))) 
+    putErrLn $ fromAtom (ruleName rule)
+    putErr $ "    " ++ render (ePretty (foldl EAp (EVar $ ruleHead rule) (ruleArgs rule)))
hunk ./E/Rules.hs 90
-instance Monoid Rules where 
+instance Monoid Rules where
hunk ./E/Rules.hs 99
-    --fvs rule = (freeVars $ ruleBody rule) Set.\\ freeVars (ruleArgs rule) 
+    --fvs rule = (freeVars $ ruleBody rule) Set.\\ freeVars (ruleArgs rule)
hunk ./E/Rules.hs 103
-    z <- applyRule' stats rules tvr xs 
+    z <- applyRule' stats rules tvr xs
hunk ./E/Rules.hs 114
-        return $ Just ((EError ("Prelude.error: " ++ s') ty),rs)  
+        return $ Just ((EError ("Prelude.error: " ++ s') ty),rs)
hunk ./E/Rules.hs 125
-            return $ Just (b,(drop nArgs xs)) 
-    f (_:rs) = f rs 
-        
+            return $ Just (b,(drop nArgs xs))
+    f (_:rs) = f rs
+
hunk ./E/Rules.hs 130
-        return $ Just ((EError ("Prelude.error: " ++ s') ty),rs)  
+        return $ Just ((EError ("Prelude.error: " ++ s') ty),rs)
hunk ./E/Rules.hs 141
-            return $ Just (b,(drop nArgs xs)) 
-    f (_:rs) = f rs 
+            return $ Just (b,(drop nArgs xs))
+    f (_:rs) = f rs
hunk ./E/SSimplify.hs 31
-data Occurance = 
+data Occurance =
hunk ./E/SSimplify.hs 45
-data StrictInfo = NoStrict | Strict  
+data StrictInfo = NoStrict | Strict
hunk ./E/SSimplify.hs 50
-collectOcc sopts  e = (e',fvs,occ) where  
+collectOcc sopts  e = (e',fvs,occ) where
hunk ./E/SSimplify.hs 56
-    occ = foldl (Map.unionWithKey combineOccInfo) mempty (Seq.toList occ')  
+    occ = foldl (Map.unionWithKey combineOccInfo) mempty (Seq.toList occ')
hunk ./E/SSimplify.hs 66
-        (b',fvs,bs) <- f b 
+        (b',fvs,bs) <- f b
hunk ./E/SSimplify.hs 70
-        return (e,freeVars (t:xs), Map.singleton n Once `andOM` args xs) 
+        return (e,freeVars (t:xs), Map.singleton n Once `andOM` args xs)
hunk ./E/SSimplify.hs 73
-        (d',fvb,sb) <- case d of 
+        (d',fvb,sb) <- case d of
hunk ./E/SSimplify.hs 88
-            (lb,ds'') = findLoopBreakers (\ (_,(e,_,_)) -> loopFunc e) gr' 
-            cycNodes = Set.fromList $ [ v | (v,_) <- cyclicNodes gr'] 
-            calcStrictInfo t e 
+            (lb,ds'') = findLoopBreakers (\ (_,(e,_,_)) -> loopFunc e) gr'
+            cycNodes = Set.fromList $ [ v | (v,_) <- cyclicNodes gr']
+            calcStrictInfo t e
hunk ./E/SSimplify.hs 94
-        let dvars = map (tvrNum . fst) ds 
+        let dvars = map (tvrNum . fst) ds
hunk ./E/SSimplify.hs 99
-    f e@(EAp a b)  = case runIdentity $ app (fromAp e) of 
+    f e@(EAp a b)  = case runIdentity $ app (fromAp e) of
hunk ./E/SSimplify.hs 119
-            (lb,ds'') = findLoopBreakers (\ (_,(e,_,_)) -> loopFunc e) gr' 
-        let dvars = map (tvrNum . fst) ds 
+            (lb,ds'') = findLoopBreakers (\ (_,(e,_,_)) -> loopFunc e) gr'
+        let dvars = map (tvrNum . fst) ds
hunk ./E/SSimplify.hs 128
-loopFunc EVar {} = 0 
+loopFunc EVar {} = 0
hunk ./E/SSimplify.hs 133
-loopFunc ELam {} = 3 
+loopFunc ELam {} = 3
hunk ./E/SSimplify.hs 135
-        
+
hunk ./E/SSimplify.hs 154
-    so_boundVars :: Map.Map Int E, 
+    so_boundVars :: Map.Map Int E,
hunk ./E/SSimplify.hs 168
-type InScope = Map.Map Int Binding 
+type InScope = Map.Map Int Binding
hunk ./E/SSimplify.hs 189
-simplify sopts e = (e'',stat,occ) where 
+simplify sopts e = (e'',stat,occ) where
hunk ./E/SSimplify.hs 191
-    --(e',fvs,occ) = collectOcc (Set.toList exports) (so_rules sopts) (so_dataTable sopts)  e 
-    (e',fvs,occ) = collectOcc sopts  e 
+    --(e',fvs,occ) = collectOcc (Set.toList exports) (so_rules sopts) (so_dataTable sopts)  e
+    (e',fvs,occ) = collectOcc sopts  e
hunk ./E/SSimplify.hs 196
-    initialB = mempty { envInScope = Map.fromAscList [ (i,IsBoundTo Many e)  | (i,e) <- Map.toAscList $ so_boundVars sopts] } 
+    initialB = mempty { envInScope = Map.fromAscList [ (i,IsBoundTo Many e)  | (i,e) <- Map.toAscList $ so_boundVars sopts] }
hunk ./E/SSimplify.hs 199
-        let (e',_,_) = collectOcc sopts  e 
+        let (e',_,_) = collectOcc sopts  e
hunk ./E/SSimplify.hs 205
-        case Map.lookup (tvrNum v) sub of 
+        case Map.lookup (tvrNum v) sub of
hunk ./E/SSimplify.hs 212
-            -- Nothing -> error $ "Var with no subst: " ++ show e ++ "\n" ++  show  sub -- h (EVar v) xs' inb    
+            -- Nothing -> error $ "Var with no subst: " ++ show e ++ "\n" ++  show  sub -- h (EVar v) xs' inb
hunk ./E/SSimplify.hs 216
-        x'' <- coerceOpt return x' 
+        x'' <- coerceOpt return x'
hunk ./E/SSimplify.hs 219
-        h x xs' inb 
+        h x xs' inb
hunk ./E/SSimplify.hs 222
-        es' <- mapM (dosub sub) es 
+        es' <- mapM (dosub sub) es
hunk ./E/SSimplify.hs 226
-        es' <- mapM (dosub sub) es 
+        es' <- mapM (dosub sub) es
hunk ./E/SSimplify.hs 239
-    --g (EVar v) sub inb = do 
-    --    case Map.lookup (tvrNum v) sub of 
+    --g (EVar v) sub inb = do
+    --    case Map.lookup (tvrNum v) sub of
hunk ./E/SSimplify.hs 246
-    --        Nothing -> error $ "vvar with no subst: " ++ show (EVar v) -- h (EVar v) xs' inb    
+    --        Nothing -> error $ "vvar with no subst: " ++ show (EVar v) -- h (EVar v) xs' inb
hunk ./E/SSimplify.hs 249
-        e' <- f e sub inb 
+        e' <- f e sub inb
hunk ./E/SSimplify.hs 253
-        v' <- nname v sub inb 
-        e' <- f e (Map.insert (tvrNum v) (Done $ EVar v') sub) (envInScope_u (Map.insert (tvrNum v') NotKnown) inb) 
+        v' <- nname v sub inb
+        e' <- f e (Map.insert (tvrNum v) (Done $ EVar v') sub) (envInScope_u (Map.insert (tvrNum v') NotKnown) inb)
hunk ./E/SSimplify.hs 263
-                    Just Once -> return (tvrNum t,Once,error $ "Once: " ++ show t,e)   
-                    Just n -> return (tvrNum t,n,t',e)   
+                    Just Once -> return (tvrNum t,Once,error $ "Once: " ++ show t,e)
+                    Just n -> return (tvrNum t,n,t',e)
hunk ./E/SSimplify.hs 266
-                    -- Nothing -> error $ "No Occurance info for " ++ show t 
+                    -- Nothing -> error $ "No Occurance info for " ++ show t
hunk ./E/SSimplify.hs 275
-                        w rs (Map.insert t (Done e') sub) (envInScope_u (Map.insert (tvrNum t') (IsBoundTo n e')) inb) ((t',e'):ds) 
-                    -- False | worthStricting e', Strict <- Info.lookup (tvrInfo t') -> w rs sub 
-                    False -> w rs sub (if n /= LoopBreaker then (envInScope_u (Map.insert (tvrNum t') (IsBoundTo n e')) inb) else inb) ((t',e'):ds) 
+                        w rs (Map.insert t (Done e') sub) (envInScope_u (Map.insert (tvrNum t') (IsBoundTo n e')) inb) ((t',e'):ds)
+                    -- False | worthStricting e', Strict <- Info.lookup (tvrInfo t') -> w rs sub
+                    False -> w rs sub (if n /= LoopBreaker then (envInScope_u (Map.insert (tvrNum t') (IsBoundTo n e')) inb) else inb) ((t',e'):ds)
hunk ./E/SSimplify.hs 279
-        s' <- mapM z ds 
-        let 
+        s' <- mapM z ds
+        let
hunk ./E/SSimplify.hs 283
-        e' <- f e sub' inb' 
+        e' <- f e sub' inb'
hunk ./E/SSimplify.hs 286
-                mtick "E.Simplify.let-to-case" 
+                mtick "E.Simplify.let-to-case"
hunk ./E/SSimplify.hs 289
-                let fn ds (ELetRec ds' e) | not (hasRepeatUnder fst (ds ++ ds')) = fn (ds' ++ ds) e  
+                let fn ds (ELetRec ds' e) | not (hasRepeatUnder fst (ds ++ ds')) = fn (ds' ++ ds) e
hunk ./E/SSimplify.hs 291
-                        f ((t,ELetRec ds' e):rs) us ds b | all (not . (`Set.member` us)) (fsts ds') = f ((t,e):rs) (Set.fromList (fsts ds') `Set.union` us) (ds':ds) True 
+                        f ((t,ELetRec ds' e):rs) us ds b | all (not . (`Set.member` us)) (fsts ds') = f ((t,e):rs) (Set.fromList (fsts ds') `Set.union` us) (ds':ds) True
hunk ./E/SSimplify.hs 295
-                let (ds'',e'') = fn ds' e' 
+                let (ds'',e'') = fn ds' e'
hunk ./E/SSimplify.hs 302
-                    (ds''',ds'') = unzip (map z ds') 
+                    (ds''',ds'') = unzip (map z ds')
hunk ./E/SSimplify.hs 305
-                
+
hunk ./E/SSimplify.hs 314
-    nname tvr@(TVr { tvrIdent = n, tvrType =  t}) sub inb  = do 
-        t' <- dosub sub t 
+    nname tvr@(TVr { tvrIdent = n, tvrType =  t}) sub inb  = do
+        t' <- dosub sub t
hunk ./E/SSimplify.hs 317
-        n' <- uniqueName n 
+        n' <- uniqueName n
hunk ./E/SSimplify.hs 321
---                n' <- newName 
+--                n' <- newName
hunk ./E/SSimplify.hs 324
---                n' <- uniqueName n 
+--                n' <- uniqueName n
hunk ./E/SSimplify.hs 326
-        
+
hunk ./E/SSimplify.hs 333
-        
+
hunk ./E/SSimplify.hs 340
-        t' <- dosub sub t 
-        return $ prim_unsafeCoerce (EVar v) t' 
+        t' <- dosub sub t
+        return $ prim_unsafeCoerce (EVar v) t'
hunk ./E/SSimplify.hs 344
-        mtick (toAtom "E.Simplify.case-of-case") 
+        mtick (toAtom "E.Simplify.case-of-case")
hunk ./E/SSimplify.hs 346
-                e' <- doCase e b' as' d' sub (envInScope_u (Map.fromList [ (n,NotKnown) | TVr { tvrIdent = n } <- litBinds l ] `Map.union`) inb) 
+                e' <- doCase e b' as' d' sub (envInScope_u (Map.fromList [ (n,NotKnown) | TVr { tvrIdent = n } <- litBinds l ] `Map.union`) inb)
hunk ./E/SSimplify.hs 348
-            --g e >>= return . Alt l 
-            g x = doCase x b' as' d' sub (envInScope_u (Map.insert (tvrNum b) NotKnown) inb) 
-        as'' <- mapM f as 
+            --g e >>= return . Alt l
+            g x = doCase x b' as' d' sub (envInScope_u (Map.insert (tvrNum b) NotKnown) inb)
+        as'' <- mapM f as
hunk ./E/SSimplify.hs 356
-        t' <- dosub sub t 
-        return $ prim_unsafeCoerce e t' 
+        t' <- dosub sub t
+        return $ prim_unsafeCoerce e t'
hunk ./E/SSimplify.hs 366
-                con <- getConstructor n dt 
+                con <- getConstructor n dt
hunk ./E/SSimplify.hs 370
-                ts <- mapM g (slotTypes (so_dataTable sopts) n te) 
+                ts <- mapM g (slotTypes (so_dataTable sopts) n te)
hunk ./E/SSimplify.hs 372
-                return $ Alt (LitCons n ts te) (eLet b wtd d) 
+                return $ Alt (LitCons n ts te) (eLet b wtd d)
hunk ./E/SSimplify.hs 382
-        d' <- f d (Map.insert (tvrNum b) (Done (EVar b')) sub) (envInScope_u  (Map.insert (tvrNum b') (IsBoundTo Many e)) inb)  
-        return $ eLet b' e d' 
+        d' <- f d (Map.insert (tvrNum b) (Done (EVar b')) sub) (envInScope_u  (Map.insert (tvrNum b') (IsBoundTo Many e)) inb)
+        return $ eLet b' e d'
hunk ./E/SSimplify.hs 392
-                newinb = Map.fromList [ (n,na) | EVar (TVr { tvrIdent = n }) <- [e,EVar b']] 
+                newinb = Map.fromList [ (n,na) | EVar (TVr { tvrIdent = n }) <- [e,EVar b']]
hunk ./E/SSimplify.hs 394
-                t' <- dosub sub t 
+                t' <- dosub sub t
hunk ./E/SSimplify.hs 399
-                t' <- dosub sub t 
+                t' <- dosub sub t
hunk ./E/SSimplify.hs 409
-        d' <- fmapM dd d 
-        as' <- mapM da as 
+        d' <- fmapM dd d
+        as' <- mapM da as
hunk ./E/SSimplify.hs 414
-        (bs,e) <- match l as (b,d)      
+        (bs,e) <- match l as (b,d)
hunk ./E/SSimplify.hs 417
-        e' <- f e (Map.fromList [ (n,Done $ EVar nt) | (_,TVr { tvrIdent = n },nt) <- binds] `Map.union` sub)   (envInScope_u (Map.fromList [ (n,IsBoundTo Many e) | (e,_,TVr { tvrIdent = n }) <- binds] `Map.union`) inb) 
+        e' <- f e (Map.fromList [ (n,Done $ EVar nt) | (_,TVr { tvrIdent = n },nt) <- binds] `Map.union` sub)   (envInScope_u (Map.fromList [ (n,IsBoundTo Many e) | (e,_,TVr { tvrIdent = n }) <- binds] `Map.union`) inb)
hunk ./E/SSimplify.hs 419
-        
+
hunk ./E/SSimplify.hs 421
-        mtick (toAtom $ "E.Simplify.known-case." ++ show c ) 
+        mtick (toAtom $ "E.Simplify.known-case." ++ show c )
hunk ./E/SSimplify.hs 425
-        mtick (toAtom $ "E.Simplify.known-case." ++ show a) 
+        mtick (toAtom $ "E.Simplify.known-case." ++ show a)
hunk ./E/SSimplify.hs 428
-    match l [] (b,Just e) = do 
-        mtick (toAtom "E.Simplify.known-case._") 
+    match l [] (b,Just e) = do
+        mtick (toAtom "E.Simplify.known-case._")
hunk ./E/SSimplify.hs 431
-    match m [] (_,Nothing) = error $ "End of match: " ++ show m 
+    match m [] (_,Nothing) = error $ "End of match: " ++ show m
hunk ./E/SSimplify.hs 433
-        
+
hunk ./E/SSimplify.hs 436
-        
+
hunk ./E/SSimplify.hs 440
-        z <- applyRule'' (so_rules sopts) v xs' 
-        case z of 
+        z <- applyRule'' (so_rules sopts) v xs'
+        case z of
hunk ./E/SSimplify.hs 451
-                    didInline inb (e,xs') 
+                    didInline inb (e,xs')
hunk ./E/SSimplify.hs 454
-                    didInline inb (e,xs') 
+                    didInline inb (e,xs')
hunk ./E/SSimplify.hs 457
-                    didInline inb (e,xs') 
+                    didInline inb (e,xs')
hunk ./E/SSimplify.hs 463
-        app (e,xs') 
+        app (e,xs')
hunk ./E/SSimplify.hs 467
-        
-        
+
+
hunk ./E/SSimplify.hs 472
-    (b,as) = fromLam e 
-    nsize = size b + abs (length as - length xs) 
+    (b,as) = fromLam e
+    nsize = size b + abs (length as - length xs)
hunk ./E/SSimplify.hs 482
-    
+
hunk ./E/SSimplify.hs 498
-        p' <- primOpt dataTable stats p 
+        p' <- primOpt dataTable stats p
hunk ./E/SSimplify.hs 501
-        tick stats (toAtom "E.Simplify.case-of-bottom") 
+        tick stats (toAtom "E.Simplify.case-of-bottom")
hunk ./E/SSimplify.hs 503
-    f (ECase e b as (Just (ECase e' b' as' d')),[]) | e == e' = do 
-        tick stats (toAtom "E.Simplify.case-merging") 
-        let (nb,mdc)   
+    f (ECase e b as (Just (ECase e' b' as' d')),[]) | e == e' = do
+        tick stats (toAtom "E.Simplify.case-merging")
+        let (nb,mdc)
hunk ./E/SSimplify.hs 509
-            nas' = filter ( (`notElem` map altHead as) . altHead) as' 
+            nas' = filter ( (`notElem` map altHead as) . altHead) as'
hunk ./E/SSimplify.hs 512
-        tick stats (toAtom "E.Simplify.case-of-case") 
+        tick stats (toAtom "E.Simplify.case-of-case")
hunk ./E/SSimplify.hs 516
-        
+
hunk ./E/SSimplify.hs 519
-        tick stats (toAtom "E.Simplify.case-no-default") 
+        tick stats (toAtom "E.Simplify.case-no-default")
hunk ./E/SSimplify.hs 523
-        f (eLet b e d,[]) 
-        
-    f (ECase e (TVr 0 _) as (Just (ELetRec ds (ECase e' b' as' d'))),[]) | e == e' = do 
-        tick stats (toAtom "E.Simplify.case-merging") 
-        let nas' = filter ( (`notElem` map altHead as) . altHead) as' 
+        f (eLet b e d,[])
+
+    f (ECase e (TVr 0 _) as (Just (ELetRec ds (ECase e' b' as' d'))),[]) | e == e' = do
+        tick stats (toAtom "E.Simplify.case-merging")
+        let nas' = filter ( (`notElem` map altHead as) . altHead) as'
hunk ./E/SSimplify.hs 529
-        
+
hunk ./E/SSimplify.hs 531
-        tick stats (toAtom "E.Simplify.case-fully-const") 
+        tick stats (toAtom "E.Simplify.case-fully-const")
hunk ./E/SSimplify.hs 536
-        --liftM (mapFst $ eLet (eCaseBind ec) el) $ 
+        --liftM (mapFst $ eLet (eCaseBind ec) el) $
hunk ./E/SSimplify.hs 538
-        ticks stats (length xs) (toAtom "E.Simplify.error-application") 
+        ticks stats (length xs) (toAtom "E.Simplify.error-application")
hunk ./E/SSimplify.hs 542
-        case e of 
+        case e of
hunk ./E/SSimplify.hs 544
-            NotAmong na | ECase e b [] (Just d) <- ec { eCaseAlts =  filtAlts na $ eCaseAlts ec } ->  do 
-                tick stats (toAtom "E.Simplify.seq-evaled") 
-                f (eLet b e d,[]) 
+            NotAmong na | ECase e b [] (Just d) <- ec { eCaseAlts =  filtAlts na $ eCaseAlts ec } ->  do
+                tick stats (toAtom "E.Simplify.seq-evaled")
+                f (eLet b e d,[])
hunk ./E/SSimplify.hs 549
- --       tick stats (toAtom "E.Simplify.case-no-default") 
+ --       tick stats (toAtom "E.Simplify.case-no-default")
hunk ./E/SSimplify.hs 553
-        z <- applyRule' stats (so_rules sopts) v xs 
+        z <- applyRule' stats (so_rules sopts) v xs
hunk ./E/SSimplify.hs 563
-                        tick stats (toAtom "E.Simplify.inline.copy-propagate") 
+                        tick stats (toAtom "E.Simplify.inline.copy-propagate")
hunk ./E/SSimplify.hs 566
-                        tick stats (toAtom "E.Simplify.inline.constant-folding") 
+                        tick stats (toAtom "E.Simplify.inline.constant-folding")
hunk ./E/SSimplify.hs 569
-                        tick stats (toAtom "E.Simplify.inline.error-folding") 
-                        ticks stats (length xs) (toAtom "E.Simplify.error-application") 
+                        tick stats (toAtom "E.Simplify.inline.error-folding")
+                        ticks stats (length xs) (toAtom "E.Simplify.error-application")
hunk ./E/SSimplify.hs 572
-                    IsBoundTo exp 
-                        | shouldInline exp xs -> do 
+                    IsBoundTo exp
+                        | shouldInline exp xs -> do
hunk ./E/SSimplify.hs 575
-                                name' = if  ("Instance@." `isPrefixOf` name) then "Instance@" else name 
+                                name' = if  ("Instance@." `isPrefixOf` name) then "Instance@" else name
hunk ./E/SSimplify.hs 585
-    isGood (LitCons _ (_:_) _) = False 
+    isGood (LitCons _ (_:_) _) = False
hunk ./E/SSimplify.hs 589
-        tick stats (toAtom $ "E.Simplify.known-case." ++ show c ) 
+        tick stats (toAtom $ "E.Simplify.known-case." ++ show c )
hunk ./E/SSimplify.hs 592
-        tick stats (toAtom $ "E.Simplify.known-case." ++ show l') 
+        tick stats (toAtom $ "E.Simplify.known-case." ++ show l')
hunk ./E/SSimplify.hs 595
-    --    tick stats (toAtom "E.Simplify.known-case._") 
+    --    tick stats (toAtom "E.Simplify.known-case._")
hunk ./E/SSimplify.hs 598
-    match l [] (Just e) = do 
-        tick stats (toAtom "E.Simplify.known-case._") 
+    match l [] (Just e) = do
+        tick stats (toAtom "E.Simplify.known-case._")
hunk ./E/SSimplify.hs 601
-    match m [] Nothing = error $ "End of match: " ++ show m 
-        
-        
+    match m [] Nothing = error $ "End of match: " ++ show m
+
+
hunk ./E/SSimplify.hs 614
-        tick stats (toAtom "E.Simplify.blank-lam") 
-        return (ELam (TVr 0 t) e,[]) 
+        tick stats (toAtom "E.Simplify.blank-lam")
+        return (ELam (TVr 0 t) e,[])
hunk ./E/SSimplify.hs 617
-        tick stats (toAtom "E.Simplify.blank-pi") 
-        return (EPi (TVr 0 t) e,[]) 
+        tick stats (toAtom "E.Simplify.blank-pi")
+        return (EPi (TVr 0 t) e,[])
hunk ./E/SSimplify.hs 620
---        tick stats (toAtom "E.Simplify.eta-reduce-pi") 
---        g (a,[]) 
+--        tick stats (toAtom "E.Simplify.eta-reduce-pi")
+--        g (a,[])
hunk ./E/SSimplify.hs 623
---        tick stats (toAtom "E.Simplify.eta-reduce-lam") 
---        g (a,[]) 
-        
+--        tick stats (toAtom "E.Simplify.eta-reduce-lam")
+--        g (a,[])
+
hunk ./E/SSimplify.hs 630
-                tick stats (toAtom "E.Simplify.inline.copy-propagate") 
+                tick stats (toAtom "E.Simplify.inline.copy-propagate")
hunk ./E/SSimplify.hs 633
-                tick stats (toAtom $ "E.Simplify.inline.constant-folding") 
+                tick stats (toAtom $ "E.Simplify.inline.constant-folding")
hunk ./E/SSimplify.hs 636
-                tick stats (toAtom "E.Simplify.inline.arg-unsafeCoerce") 
+                tick stats (toAtom "E.Simplify.inline.arg-unsafeCoerce")
hunk ./E/SSimplify.hs 639
-                tick stats (toAtom "E.Simplify.inline.constant-folding2") 
+                tick stats (toAtom "E.Simplify.inline.constant-folding2")
hunk ./E/SSimplify.hs 642
-            --    tick stats (toAtom "E.Simplify.error-folding") 
+            --    tick stats (toAtom "E.Simplify.error-folding")
hunk ./E/SSimplify.hs 645
-            --    tick stats (toAtom "E.Simplify.constant-folding") 
+            --    tick stats (toAtom "E.Simplify.constant-folding")
hunk ./E/SSimplify.hs 661
-    
+
hunk ./E/SSimplify.hs 668
-                --    h  e xs' inb 
+                --    h  e xs' inb
hunk ./E/SSimplify.hs 672
-                            app (e,xs') 
+                            app (e,xs')
hunk ./E/SSimplify.hs 675
-                            app (e,xs') 
+                            app (e,xs')
hunk ./E/SSimplify.hs 678
-                            app (e,xs') 
+                            app (e,xs')
hunk ./E/SSimplify.hs 681
-                            app (e,xs') 
+                            app (e,xs')
hunk ./E/SSimplify.hs 684
-                            app (e,xs') 
+                            app (e,xs')
hunk ./E/SSimplify.hs 687
-                        
+
hunk ./E/Shadow.hs 9
-litSMapM f (LitCons s es t) = do 
-    t' <- f t 
+litSMapM f (LitCons s es t) = do
+    t' <- f t
hunk ./E/Shadow.hs 16
-allShadow :: E -> E 
+allShadow :: E -> E
hunk ./E/Shadow.hs 20
-        (mp,_) <- ask 
-        case Map.lookup i mp of 
+        (mp,_) <- ask
+        case Map.lookup i mp of
hunk ./E/Shadow.hs 23
-          _  -> return  eo 
-    f (ELam tvr e) = lp ELam tvr e  
-    f (EPi tvr e) = lp EPi tvr e  
+          _  -> return  eo
+    f (ELam tvr e) = lp ELam tvr e
+    f (EPi tvr e) = lp EPi tvr e
hunk ./E/Shadow.hs 31
-    f (ELit l) = liftM ELit $ litSMapM f l 
+    f (ELit l) = liftM ELit $ litSMapM f l
hunk ./E/Shadow.hs 35
-        (as,rs) <- liftM unzip $ mapMntvr (fsts dl) 
+        (as,rs) <- liftM unzip $ mapMntvr (fsts dl)
hunk ./E/Shadow.hs 37
-            ds <- mapM f (snds dl) 
+            ds <- mapM f (snds dl)
hunk ./E/Shadow.hs 50
-                l' <- fmapM f l 
-                e' <- f e 
+                l' <- fmapM f l
+                e' <- f e
hunk ./E/Shadow.hs 54
-        return  ECase { eCaseScrutinee = e', eCaseDefault = d, eCaseBind = b', eCaseAlts = alts }  
+        return  ECase { eCaseScrutinee = e', eCaseDefault = d, eCaseBind = b', eCaseAlts = alts }
hunk ./E/Shadow.hs 62
-            (t',r) <- ntvr vs t 
+            (t',r) <- ntvr vs t
hunk ./E/Shadow.hs 67
-        (tv,r) <- ntvr tvr 
+        (tv,r) <- ntvr tvr
hunk ./E/Shadow.hs 70
-            
-    ntvr tvr@(TVr { tvrIdent = i, tvrType =  t }) = do 
+
+    ntvr tvr@(TVr { tvrIdent = i, tvrType =  t }) = do
hunk ./E/Shadow.hs 73
-        (_,i') <- ask  
+        (_,i') <- ask
hunk ./E/Shadow.hs 76
-        
-    
+
+
hunk ./E/Strictness.hs 3
-import Boolean.Algebra 
+import Boolean.Algebra
hunk ./E/Strictness.hs 23
-    show (V x) = tvrShowName (tvr { tvrIdent = x }) 
+    show (V x) = tvrShowName (tvr { tvrIdent = x })
hunk ./E/Strictness.hs 28
-data SA = 
+data SA =
hunk ./E/Strictness.hs 34
-    | SOr SA SA     -- A or B 
+    | SOr SA SA     -- A or B
hunk ./E/Strictness.hs 37
-    | If Var Int SA SA  -- if 
+    | If Var Int SA SA  -- if
hunk ./E/Strictness.hs 49
-    ans = E.Strictness.solve [ c  | c@(x,_) <- cr, x /= (V $ -1) ] 
+    ans = E.Strictness.solve [ c  | c@(x,_) <- cr, x /= (V $ -1) ]
hunk ./E/Strictness.hs 51
- 
-solve :: CResult -> IO CResult 
+
+solve :: CResult -> IO CResult
hunk ./E/Strictness.hs 59
-    getVal' x 
-        | Just i <- Map.lookup x mp = getVal i 
+    getVal' x
+        | Just i <- Map.lookup x mp = getVal i
hunk ./E/Strictness.hs 62
-        
+
hunk ./E/Strictness.hs 67
-        x <- getVal' (v,False) 
+        x <- getVal' (v,False)
hunk ./E/Strictness.hs 73
-        case x of 
+        case x of
hunk ./E/Strictness.hs 77
-        a' <- sol a 
+        a' <- sol a
hunk ./E/Strictness.hs 81
-        a' <- sol a 
+        a' <- sol a
hunk ./E/Strictness.hs 95
-    --f (EVar (TVr i _)) = (Map.single i (S 0),[]) 
-    f (EPrim _ as _) = return (andSA (Map.empty:(map (arg (S 0)) as))) 
+    --f (EVar (TVr i _)) = (Map.single i (S 0),[])
+    f (EPrim _ as _) = return (andSA (Map.empty:(map (arg (S 0)) as)))
hunk ./E/Strictness.hs 102
-        fe <- f e  
-        fb <- mapM f (caseBodies ec)  
-        cb <- finS (caseBinds ec) (orSA fb)  
+        fe <- f e
+        fb <- mapM f (caseBodies ec)
+        cb <- finS (caseBinds ec) (orSA fb)
hunk ./E/Strictness.hs 109
-        ds' <- mapM g ds 
+        ds' <- mapM g ds
hunk ./E/Strictness.hs 112
-    f e@(EAp a b)  = case runIdentity $ app (fromAp e) of 
+    f e@(EAp a b)  = case runIdentity $ app (fromAp e) of
hunk ./E/Strictness.hs 115
-    f e = error $ "Strictness: " ++ show e 
-    fin ts sm = do 
+    f e = error $ "Strictness: " ++ show e
+    fin ts sm = do
hunk ./E/Strictness.hs 118
-        return $ Map.fromAscList [ (V i,L) | (V i,v) <- Map.toAscList sm, i `notElem` map tvrNum ts] 
+        return $ Map.fromAscList [ (V i,L) | (V i,v) <- Map.toAscList sm, i `notElem` map tvrNum ts]
hunk ./E/Strictness.hs 122
-        (b,as) = fromLam e 
-        ans = do 
+        (b,as) = fromLam e
+        ans = do
hunk ./E/Strictness.hs 127
-    arg sa (EVar (TVr { tvrIdent = i })) = Map.singleton (V i) sa 
+    arg sa (EVar (TVr { tvrIdent = i })) = Map.singleton (V i) sa
hunk ./E/Strictness.hs 132
-    
hunk ./E/Strictness.hs 133
-saIf _ _ a b | a == b = a 
+
+saIf _ _ a b | a == b = a
hunk ./E/Strictness.hs 139
-orSA = foldl1 orsa 
+orSA = foldl1 orsa
hunk ./E/Strictness.hs 145
-    nk = snub (Map.keys ma ++ Map.keys mb) 
+    nk = snub (Map.keys ma ++ Map.keys mb)
hunk ./E/Strictness.hs 154
-instance SemiBooleanAlgebra SA where 
+instance SemiBooleanAlgebra SA where
hunk ./E/Strictness.hs 169
---sand' (a `SAnd` b) c = sand a (sand b c) 
+--sand' (a `SAnd` b) c = sand a (sand b c)
hunk ./E/Strictness.hs 177
-    x = sor' a b 
+    x = sor' a b
hunk ./E/Strictness.hs 185
-    --sor' (a `SOr` b) c = sor' a (sor' b c) 
+    --sor' (a `SOr` b) c = sor' a (sor' b c)
hunk ./E/Subst.hs 23
-substLet :: [(TVr,E)] -> E -> E 
+substLet :: [(TVr,E)] -> E -> E
hunk ./E/Subst.hs 26
-    ans = eLetRec nas (substMap' (Map.fromList [ (n,e) | (TVr { tvrIdent = n },e) <- as]) e) 
+    ans = eLetRec nas (substMap' (Map.fromList [ (n,e) | (TVr { tvrIdent = n },e) <- as]) e)
hunk ./E/Subst.hs 29
-subst :: 
+subst ::
hunk ./E/Subst.hs 34
-subst (TVr { tvrIdent = 0 }) _ e = e 
-subst (TVr { tvrIdent = i }) w e = doSubst False False (Map.insert i (Just w) $ Map.fromList [ (x,Nothing) | x <- freeVars (getType w) ++ freeVars e ]) e 
+subst (TVr { tvrIdent = 0 }) _ e = e
+subst (TVr { tvrIdent = i }) w e = doSubst False False (Map.insert i (Just w) $ Map.fromList [ (x,Nothing) | x <- freeVars (getType w) ++ freeVars e ]) e
hunk ./E/Subst.hs 44
-subst' (TVr { tvrIdent = 0 }) _ e = e 
-subst' (TVr { tvrIdent = (i) }) w e = doSubst True False (Map.insert i (Just w) $ Map.fromList [ (x,Nothing) | x <- freeVars (getType w) ++ freeVars e ]) e 
+subst' (TVr { tvrIdent = 0 }) _ e = e
+subst' (TVr { tvrIdent = (i) }) w e = doSubst True False (Map.insert i (Just w) $ Map.fromList [ (x,Nothing) | x <- freeVars (getType w) ++ freeVars e ]) e
hunk ./E/Subst.hs 52
-litSMapM f (LitCons s es t) = do 
-    t' <- f t 
+litSMapM f (LitCons s es t) = do
+    t' <- f t
hunk ./E/Subst.hs 63
-noShadow :: E -> E 
+noShadow :: E -> E
hunk ./E/Subst.hs 77
-doSubst :: Bool -> Bool -> Map.Map Int (Maybe E) -> E -> E 
+doSubst :: Bool -> Bool -> Map.Map Int (Maybe E) -> E -> E
hunk ./E/Subst.hs 81
-        mp <- ask 
-        case Map.lookup i mp of 
+        mp <- ask
+        case Map.lookup i mp of
hunk ./E/Subst.hs 84
-          _ 
+          _
hunk ./E/Subst.hs 86
-            | otherwise  -> return  eo 
-    f (ELam tvr e) = lp ELam tvr e  
-    f (EPi tvr e) = lp EPi tvr e  
+            | otherwise  -> return  eo
+    f (ELam tvr e) = lp ELam tvr e
+    f (EPi tvr e) = lp EPi tvr e
hunk ./E/Subst.hs 93
-        (as,rs) <- liftM unzip $ mapMntvr (fsts dl) 
+        (as,rs) <- liftM unzip $ mapMntvr (fsts dl)
hunk ./E/Subst.hs 95
-            ds <- mapM f (snds dl) 
+            ds <- mapM f (snds dl)
hunk ./E/Subst.hs 98
-    f (ELit l) = liftM ELit $ litSMapM f l 
+    f (ELit l) = liftM ELit $ litSMapM f l
hunk ./E/Subst.hs 111
-                l' <- fmapM f l 
-                e' <- f e 
+                l' <- fmapM f l
+                e' <- f e
hunk ./E/Subst.hs 115
-        return  ECase { eCaseScrutinee = e', eCaseDefault = d, eCaseBind = b', eCaseAlts = alts }  
+        return  ECase { eCaseScrutinee = e', eCaseDefault = d, eCaseBind = b', eCaseAlts = alts }
hunk ./E/Subst.hs 121
-        (tv,r) <- ntvr [] tvr 
+        (tv,r) <- ntvr [] tvr
hunk ./E/Subst.hs 127
-            (t',r) <- ntvr vs t 
+            (t',r) <- ntvr vs t
hunk ./E/Subst.hs 130
-            
+
hunk ./E/Subst.hs 133
-    --    (t',r) <- ntvr t 
+    --    (t',r) <- ntvr t
hunk ./E/Subst.hs 141
-    ntvr xs tvr@(TVr {tvrIdent = i, tvrType =  t}) = do 
+    ntvr xs tvr@(TVr {tvrIdent = i, tvrType =  t}) = do
hunk ./E/Subst.hs 148
-        
-    
hunk ./E/Subst.hs 149
-mnv allShadow xs i ss 
-    | allShadow = nv ss 
+
+
+mnv allShadow xs i ss
+    | allShadow = nv ss
hunk ./E/Subst.hs 155
-        
hunk ./E/Subst.hs 156
-nv ss = v (2 * (Map.size ss + 1)) where 
+
+nv ss = v (2 * (Map.size ss + 1)) where
hunk ./E/Subst.hs 161
-nv' ss = v (2 * (Map.size ss + 1)) where 
+nv' ss = v (2 * (Map.size ss + 1)) where
hunk ./E/Subst.hs 173
-    mtick (toAtom $ "E.Simplify.typecon-reduce.{" ++ show n ++ "}" ) 
+    mtick (toAtom $ "E.Simplify.typecon-reduce.{" ++ show n ++ "}" )
hunk ./E/Subst.hs 176
-    mtick (toAtom "E.Simplify.beta-reduce") 
+    mtick (toAtom "E.Simplify.beta-reduce")
hunk ./E/Subst.hs 179
-    mtick (toAtom "E.Simplify.pi-reduce") 
+    mtick (toAtom "E.Simplify.pi-reduce")
hunk ./E/Subst.hs 182
-    mtick (toAtom "E.Simplify.case-application") 
+    mtick (toAtom "E.Simplify.case-application")
hunk ./E/Subst.hs 184
-    caseBodiesMapM f ec 
+    caseBodiesMapM f ec
hunk ./E/Subst.hs 186
-    mtick (toAtom "E.Simplify.let-application") 
+    mtick (toAtom "E.Simplify.let-application")
hunk ./E/Subst.hs 188
-    return $ eLetRec ds e' 
+    return $ eLetRec ds e'
hunk ./E/Subst.hs 190
-    mtick (toAtom "E.Simplify.error-application") 
+    mtick (toAtom "E.Simplify.error-application")
hunk ./E/Subst.hs 193
-    return $ foldl EAp e as 
+    return $ foldl EAp e as
hunk ./E/Subst.hs 204
-        (ss', dl', im') = foldl f (ss,[], im) dl  
+        (ss', dl', im') = foldl f (ss,[], im) dl
hunk ./E/Subst.hs 221
-    nv ss = v (2 * (IS.size ss + 1)) where 
+    nv ss = v (2 * (IS.size ss + 1)) where
hunk ./E/Subst.hs 229
-        v = nv (ss `IS.union` freeVars t')        
+        v = nv (ss `IS.union` freeVars t')
hunk ./E/Traverse.hs 23
-newtype MInt = MInt Int 
+newtype MInt = MInt Int
hunk ./E/Traverse.hs 44
-travOptions :: Monad m => TravOptions m 
+travOptions :: Monad m => TravOptions m
hunk ./E/Traverse.hs 55
-travOptionsI :: TravOptions Identity 
+travOptionsI :: TravOptions Identity
hunk ./E/Traverse.hs 76
-newBinding :: Monad m => E -> TravM m (TVr,E) 
+newBinding :: Monad m => E -> TravM m (TVr,E)
hunk ./E/Traverse.hs 78
-    v <- newVarName 
+    v <- newVarName
hunk ./E/Traverse.hs 82
-lookupBinding :: Monad m => TVr -> TravM m Binding 
+lookupBinding :: Monad m => TVr -> TravM m Binding
hunk ./E/Traverse.hs 91
-    --m <- get  
+    --m <- get
hunk ./E/Traverse.hs 100
-newVar' ss n | n <= 0 || n `Map.member` ss  = v $ (2 * Map.size ss + 2) + (n + (n `mod` 2))  where 
+newVar' ss n | n <= 0 || n `Map.member` ss  = v $ (2 * Map.size ss + 2) + (n + (n `mod` 2))  where
hunk ./E/Traverse.hs 107
-traverse :: (MonadFix m,Monad m) => TravOptions m -> (Int -> (E,[E]) -> TravM m E) -> Subst -> (Map.Map Int Binding) -> E -> m E 
+traverse :: (MonadFix m,Monad m) => TravOptions m -> (Int -> (E,[E]) -> TravM m E) -> Subst -> (Map.Map Int Binding) -> E -> m E
hunk ./E/Traverse.hs 113
-    f :: E -> ReaderT (Map.Map Int Binding, Subst, Int) (NameMT Int m) E  
+    f :: E -> ReaderT (Map.Map Int Binding, Subst, Int) (NameMT Int m) E
hunk ./E/Traverse.hs 117
-        --put (y,z,n + 1) 
+        --put (y,z,n + 1)
hunk ./E/Traverse.hs 122
-        x' <- g x 
+        x' <- g x
hunk ./E/Traverse.hs 127
-    g  e@(EVar (TVr { tvrIdent = n, tvrType =  t})) = do 
-        (_,im,lvl) <- ask 
+    g  e@(EVar (TVr { tvrIdent = n, tvrType =  t})) = do
+        (_,im,lvl) <- ask
hunk ./E/Traverse.hs 131
-            Just n' -> do 
-                lift $ lift $  propegateRecord tOpt 1     
+            Just n' -> do
+                lift $ lift $  propegateRecord tOpt 1
hunk ./E/Traverse.hs 134
-            Nothing -> return e 
+            Nothing -> return e
hunk ./E/Traverse.hs 149
-        (ob,b') <- ntvr f' b 
-        localSubst [(ob,EVar b')] $ do 
-            as' <- mapM (da [ v  | EVar v <- [e',EVar b']] [ v  | EVar v <- [e,EVar b]])   as 
-            d' <- localVars [ (tvrNum v,NotAmong [ n | Alt (LitCons n _ _) _ <- as]) | EVar v <- [e',EVar b'] ] $ fmapM f d 
-            return $ ECase e' b' as' d' 
+        (ob,b') <- ntvr f' b
+        localSubst [(ob,EVar b')] $ do
+            as' <- mapM (da [ v  | EVar v <- [e',EVar b']] [ v  | EVar v <- [e,EVar b]])   as
+            d' <- localVars [ (tvrNum v,NotAmong [ n | Alt (LitCons n _ _) _ <- as]) | EVar v <- [e',EVar b'] ] $ fmapM f d
+            return $ ECase e' b' as' d'
hunk ./E/Traverse.hs 159
-            (n,tvrn) <- ntvr f' tvr 
+            (n,tvrn) <- ntvr f' tvr
hunk ./E/Traverse.hs 162
-            lift $ lift $  letToCaseRecord tOpt 1     
+            lift $ lift $  letToCaseRecord tOpt 1
hunk ./E/Traverse.hs 165
-            (n,tvrn) <- ntvr f' tvr 
+            (n,tvrn) <- ntvr f' tvr
hunk ./E/Traverse.hs 170
-            ds' <- mapM (ntvr f' . fst) ds 
+            ds' <- mapM (ntvr f' . fst) ds
hunk ./E/Traverse.hs 172
-            --lift $ lift $  pruneRecord tOpt (length ds - length ds'') 
+            --lift $ lift $  pruneRecord tOpt (length ds - length ds'')
hunk ./E/Traverse.hs 183
-        lift $ lift $  pruneRecord tOpt (length ds - length ds'') 
+        lift $ lift $  pruneRecord tOpt (length ds - length ds'')
hunk ./E/Traverse.hs 198
-            localSubst [ (x,EVar y) | (x,y) <- xs'] $ do 
-                l' <- f l 
+            localSubst [ (x,EVar y) | (x,y) <- xs'] $ do
+                l' <- f l
hunk ./E/Traverse.hs 204
-            l' <- f l 
+            l' <- f l
hunk ./E/Traverse.hs 211
-        (n,tvr@(TVr { tvrIdent = n' })) <- ntvr fg tv  
+        (n,tvr@(TVr { tvrIdent = n' })) <- ntvr fg tv
hunk ./E/Traverse.hs 229
-        n' <- if n > 0 then uniqueName  n else newName  
+        n' <- if n > 0 then uniqueName  n else newName
hunk ./E/Traverse.hs 231
-        let tvr = ttvr { tvrIdent = n', tvrType = t' } 
+        let tvr = ttvr { tvrIdent = n', tvrType = t' }
hunk ./E/Traverse.hs 236
-    h (((TVr { tvrIdent = n }),x):dds) e ds = do 
+    h (((TVr { tvrIdent = n }),x):dds) e ds = do
hunk ./E/Traverse.hs 238
-        let (Just (EVar nt)) = Map.lookup n tm 
+        let (Just (EVar nt)) = Map.lookup n tm
hunk ./E/Traverse.hs 241
-        --case isAtomic x' of 
-        --    False -> do 
-                --modify (\ (a,b,c) -> (Map.insert (tvrNum nt) (IsBoundTo x') a,b,c)) 
+        --case isAtomic x' of
+        --    False -> do
+                --modify (\ (a,b,c) -> (Map.insert (tvrNum nt) (IsBoundTo x') a,b,c))
hunk ./E/Traverse.hs 248
-    h (Left ((TVr (Just n) _),x):dds) e ds = do 
+    h (Left ((TVr (Just n) _),x):dds) e ds = do
hunk ./E/Traverse.hs 250
-        let (Just nt) = Map.lookup n tm 
+        let (Just nt) = Map.lookup n tm
hunk ./E/Traverse.hs 252
-        modify (\ (a,b,c) -> (Map.insert (tvrNum nt) (Just x') a,b,c)) 
+        modify (\ (a,b,c) -> (Map.insert (tvrNum nt) (Just x') a,b,c))
hunk ./E/Traverse.hs 254
-    h (Right ds:dds) e rs = do 
+    h (Right ds:dds) e rs = do
hunk ./E/Traverse.hs 257
-                let Just nt = Map.lookup n tm 
+                let Just nt = Map.lookup n tm
hunk ./E/Traverse.hs 266
-            localSubst [ (x,EVar y) | (x,y) <- xs'] $ do 
-                l' <- f l 
+            localSubst [ (x,EVar y) | (x,y) <- xs'] $ do
+                l' <- f l
hunk ./E/Traverse.hs 272
-            l' <- f l 
+            l' <- f l
hunk ./E/TypeCheck.hs 8
-import E.E                 
+import E.E
hunk ./E/TypeCheck.hs 26
-withContextDoc s a = withContext (render s) a 
+withContextDoc s a = withContext (render s) a
hunk ./E/TypeCheck.hs 28
--- | Perform a full typecheck, evaluating type terms as necessary. 
+-- | Perform a full typecheck, evaluating type terms as necessary.
hunk ./E/TypeCheck.hs 34
-    rfc e =  withContextDoc (text "fullCheck:" </> prettyE e) (fc e >>=  strong')  
-    rfc' nds e =  withContextDoc (text "fullCheck':" </> prettyE e) (inferType' nds  e >>=  strong')  
+    rfc e =  withContextDoc (text "fullCheck:" </> prettyE e) (fc e >>=  strong')
+    rfc' nds e =  withContextDoc (text "fullCheck':" </> prettyE e) (inferType' nds  e >>=  strong')
hunk ./E/TypeCheck.hs 43
-    --fc (ELam tvr@(TVr n at) b) = valid at >> rfc' [ d | d@(v,_) <- ds, tvrNum v /= n ] b >>= \b' -> (strong' $ EPi tvr b') 
+    --fc (ELam tvr@(TVr n at) b) = valid at >> rfc' [ d | d@(v,_) <- ds, tvrNum v /= n ] b >>= \b' -> (strong' $ EPi tvr b')
hunk ./E/TypeCheck.hs 45
-        valid at 
-        b' <- rfc' [ d | d@(v,_) <- ds, tvrNum v /= n ] b 
-        strong' $ EPi tvr b' 
+        valid at
+        b' <- rfc' [ d | d@(v,_) <- ds, tvrNum v /= n ] b
+        strong' $ EPi tvr b'
hunk ./E/TypeCheck.hs 50
-        a' <- rfc a 
-        case followAliases dataTable a' of 
+        a' <- rfc a
+        case followAliases dataTable a' of
hunk ./E/TypeCheck.hs 59
-            x -> fail $ "App: " ++ render (tupled [ePretty x,ePretty a, ePretty b])  
+            x -> fail $ "App: " ++ render (tupled [ePretty x,ePretty a, ePretty b])
hunk ./E/TypeCheck.hs 62
-            nds = vs ++ ds 
-        mapM_ ck vs 
+            nds = vs ++ ds
+        mapM_ ck vs
hunk ./E/TypeCheck.hs 65
-        et <- inferType' nds e  
+        et <- inferType' nds e
hunk ./E/TypeCheck.hs 78
-        eqAll (et:ps) 
+        eqAll (et:ps)
hunk ./E/TypeCheck.hs 87
-        eqAll (et:ps) 
+        eqAll (et:ps)
hunk ./E/TypeCheck.hs 92
-        rfc (subst' v nv e) 
+        rfc (subst' v nv e)
hunk ./E/TypeCheck.hs 97
-        
+
hunk ./E/TypeCheck.hs 100
-        
-        
-         
+
+
+
hunk ./E/TypeCheck.hs 108
-            withContextDoc (hsep [text "Case Pattern: ", parens $ prettyE et, parens $ prettyE (ELit l)]) $ eq et (getType  l) 
-            e' <- rfc e 
+            withContextDoc (hsep [text "Case Pattern: ", parens $ prettyE et, parens $ prettyE (ELit l)]) $ eq et (getType  l)
+            e' <- rfc e
hunk ./E/TypeCheck.hs 115
-            withContextDoc (hsep [text "Case Pattern: ", parens $ prettyE et, parens $ prettyE (ELit l)]) $ eq et (getType l) 
-            e' <- rfc e 
-            return (discardArgs (length es) e')  where -- TODO - check these. 
+            withContextDoc (hsep [text "Case Pattern: ", parens $ prettyE et, parens $ prettyE (ELit l)]) $ eq et (getType l)
+            e' <- rfc e
+            return (discardArgs (length es) e')  where -- TODO - check these.
hunk ./E/TypeCheck.hs 121
-    eqAll ts = withContextDoc (text "eqAll" </> list (map prettyE ts)) $ foldl1M_ eq ts  
+    eqAll ts = withContextDoc (text "eqAll" </> list (map prettyE ts)) $ foldl1M_ eq ts
hunk ./E/TypeCheck.hs 123
-    valid' nds s 
+    valid' nds s
hunk ./E/TypeCheck.hs 129
-        e1 <- strong nds t1 
+        e1 <- strong nds t1
hunk ./E/TypeCheck.hs 133
-            Left s -> failDoc $ hsep [text "eq:",text s, align $ vcat [ prettyE (e1),prettyE (e2) ]  ] 
+            Left s -> failDoc $ hsep [text "eq:",text s, align $ vcat [ prettyE (e1),prettyE (e2) ]  ]
hunk ./E/TypeCheck.hs 135
---        let x 
+--        let x
hunk ./E/TypeCheck.hs 139
---              | otherwise = failDoc $ hsep [text "eq:",{- tupled (map pprint $ fsts nds), -} tupled [ prettyE (e1),prettyE (e2) ], tupled [ prettyE (allShadow e1), prettyE (allShadow e2)] {- , tupled [ text (show e1), text (show e2)] -}  ] 
+--              | otherwise = failDoc $ hsep [text "eq:",{- tupled (map pprint $ fsts nds), -} tupled [ prettyE (e1),prettyE (e2) ], tupled [ prettyE (allShadow e1), prettyE (allShadow e2)] {- , tupled [ text (show e1), text (show e2)] -}  ]
hunk ./E/TypeCheck.hs 147
-    --eq t1 t2 | Just _ <- E.Eval.unify (smplE t1) (smplE t2) = return (smplE t1) 
-    --eq t1 t2 | Just _ <- E.Eval.unify (smplE t2) (smplE t1) = return (smplE t1) 
+    --eq t1 t2 | Just _ <- E.Eval.unify (smplE t1) (smplE t2) = return (smplE t1)
+    --eq t1 t2 | Just _ <- E.Eval.unify (smplE t2) (smplE t1) = return (smplE t1)
hunk ./E/TypeCheck.hs 151
-    --eq t1 t2 | Left d <- E.Eval.unify (smplE t1) (smplE t2) = failDoc $ hsep [text "eq:", tupled [text d, prettyE (smplE t1),prettyE (smplE t2) ] ] 
-    --eq t1 t2  = failDoc $ hsep [text "eq:", tupled [ prettyE (smplE t1),prettyE (smplE t2) ] ] 
+    --eq t1 t2 | Left d <- E.Eval.unify (smplE t1) (smplE t2) = failDoc $ hsep [text "eq:", tupled [text d, prettyE (smplE t1),prettyE (smplE t2) ] ]
+    --eq t1 t2  = failDoc $ hsep [text "eq:", tupled [ prettyE (smplE t1),prettyE (smplE t2) ] ]
hunk ./E/TypeCheck.hs 163
-typeInfer dataTable e = case typeInfer'' dataTable [] e of 
+typeInfer dataTable e = case typeInfer'' dataTable [] e of
hunk ./E/TypeCheck.hs 168
-typeInfer' dataTable ds e = case typeInfer'' dataTable ds e of 
+typeInfer' dataTable ds e = case typeInfer'' dataTable ds e of
hunk ./E/TypeCheck.hs 176
-    rfc e =  withContextDoc (text "fullCheck:" </> prettyE e) (fc e >>=  strong')  
-    rfc' nds e =  withContextDoc (text "fullCheck:" </> prettyE e) (inferType' nds  e >>=  strong')  
+    rfc e =  withContextDoc (text "fullCheck:" </> prettyE e) (fc e >>=  strong')
+    rfc' nds e =  withContextDoc (text "fullCheck:" </> prettyE e) (inferType' nds  e >>=  strong')
hunk ./E/TypeCheck.hs 181
-    fc e@(ELit _) = strong' (typ e) 
+    fc e@(ELit _) = strong' (typ e)
hunk ./E/TypeCheck.hs 187
-        b' <- rfc' [ d | d@(v,_) <- ds, tvrNum v /= n ] b 
-        return (EPi (tVr n at') b') 
+        b' <- rfc' [ d | d@(v,_) <- ds, tvrNum v /= n ] b
+        return (EPi (tVr n at') b')
hunk ./E/TypeCheck.hs 191
-        a' <- rfc a 
-        case followAliases dataTable a' of 
+        a' <- rfc a
+        case followAliases dataTable a' of
hunk ./E/TypeCheck.hs 197
-            x -> fail $ "App: " ++ render (tupled [ePretty x,ePretty a, ePretty b])  
+            x -> fail $ "App: " ++ render (tupled [ePretty x,ePretty a, ePretty b])
hunk ./E/TypeCheck.hs 199
-        let nds = vs ++ ds 
-        et <- inferType' nds e  
+        let nds = vs ++ ds
+        et <- inferType' nds e
hunk ./E/Values.hs 20
-    
+
hunk ./E/Values.hs 46
-class ToE a where 
+class ToE a where
hunk ./E/Values.hs 49
-    
+
hunk ./E/Values.hs 61
-    
+
hunk ./E/Values.hs 76
-dc_Rational = toName DataConstructor ("Ratio",":%") 
+dc_Rational = toName DataConstructor ("Ratio",":%")
hunk ./E/Values.hs 80
-instance ToE Char where 
+instance ToE Char where
hunk ./E/Values.hs 85
-    toE rat = ELit (LitCons dc_Rational [toE (numerator rat), toE (denominator rat)] tRational) 
+    toE rat = ELit (LitCons dc_Rational [toE (numerator rat), toE (denominator rat)] tRational)
hunk ./E/Values.hs 88
-instance ToE Integer where 
+instance ToE Integer where
hunk ./E/Values.hs 92
-instance ToE Int where 
+instance ToE Int where
hunk ./E/Values.hs 98
-    toE (x:xs) = eCons (toE x) (toE xs) 
-    typeE (_::[a]) = ELit (litCons TypeConstructor ("Prelude","[]") [typeE (undefined::a)] eStar)   
-    
+    toE (x:xs) = eCons (toE x) (toE xs)
+    typeE (_::[a]) = ELit (litCons TypeConstructor ("Prelude","[]") [typeE (undefined::a)] eStar)
+
hunk ./E/Values.hs 110
-eJustIO w x = ELit (LitCons dc_JustIO [w,x] (ELit (LitCons (toName TypeConstructor ("Jhc.IO","IOResult")) [typ x] eStar))) 
+eJustIO w x = ELit (LitCons dc_JustIO [w,x] (ELit (LitCons (toName TypeConstructor ("Jhc.IO","IOResult")) [typ x] eStar)))
hunk ./E/Values.hs 117
---    f [] = [(PatWildCard,eLam (TVr Nothing (typ e)) els)] 
+--    f [] = [(PatWildCard,eLam (TVr Nothing (typ e)) els)]
hunk ./E/Values.hs 120
-eLet (TVr { tvrIdent = 0 }) _ = id 
-eLet t@(TVr { tvrType =  ty}) e | sortStarLike ty && isAtomic e = subst t e  
+eLet (TVr { tvrIdent = 0 }) _ = id
+eLet t@(TVr { tvrType =  ty}) e | sortStarLike ty && isAtomic e = subst t e
hunk ./E/Values.hs 126
-fullyConst (ELit (LitCons _ xs _)) = mapM_ fullyConst xs 
+fullyConst (ELit (LitCons _ xs _)) = mapM_ fullyConst xs
hunk ./E/Values.hs 129
-    fullyConst t 
+    fullyConst t
hunk ./E/Values.hs 155
-safeToDup e = whnfOrBot e || isELam e || isEPi e  
+safeToDup e = whnfOrBot e || isELam e || isEPi e
hunk ./E/Values.hs 157
-eStrictLet t@(TVr { tvrType =  ty }) v e | sortStarLike ty && isAtomic v = subst t v e  
+eStrictLet t@(TVr { tvrType =  ty }) v e | sortStarLike ty && isAtomic v = subst t v e
hunk ./E/Values.hs 163
-prim_unsafeCoerce e t = p e' where 
+prim_unsafeCoerce e t = p e' where
hunk ./E/Values.hs 169
-    
+
hunk ./E/Values.hs 180
-    
+
hunk ./E/Values.hs 187
---prim_const rs s t = EPrim (APrim (CConst s t)) 
+--prim_const rs s t = EPrim (APrim (CConst s t))
hunk ./E/Values.hs 195
-caseBodiesMapM :: Monad m => (E -> m E) -> E -> m E 
+caseBodiesMapM :: Monad m => (E -> m E) -> E -> m E
hunk ./E/Values.hs 199
-    d' <- fmapM f d 
+    d' <- fmapM f d
hunk ./FilterInput.hs 24
-dupAndClose :: Fd -> Fd -> IO ()    
+dupAndClose :: Fd -> Fd -> IO ()
hunk ./FindFixpoint.hs 21
-instance Monad (Ms b) where                                            
-    return a = Ms' (\_ -> return a) 
+instance Monad (Ms b) where
+    return a = Ms' (\_ -> return a)
hunk ./FindFixpoint.hs 24
-        = Ms' (\v  -> comp v >>= \r -> case fun r   of Ms' x -> x v) 
+        = Ms' (\v  -> comp v >>= \r -> case fun r   of Ms' x -> x v)
hunk ./FindFixpoint.hs 27
-    {-# INLINE (>>) #-}  
-    {-# INLINE (>>=) #-}  
-    {-# INLINE return #-}  
+    {-# INLINE (>>) #-}
+    {-# INLINE (>>=) #-}
+    {-# INLINE return #-}
hunk ./FindFixpoint.hs 36
-{-# INLINE getVal #-}  
-getVal ::  Int -> Ms b b 
+{-# INLINE getVal #-}
+getVal ::  Int -> Ms b b
hunk ./FindFixpoint.hs 39
-    s <- readArray ref n 
+    s <- readArray ref n
hunk ./FindFixpoint.hs 41
-    readArray arr n 
-    
-    
+    readArray arr n
+
+
hunk ./FindFixpoint.hs 47
-    let put = case str' of 
-            Just _ -> CharIO.putErrLn 
-            Nothing -> const (return ())     
-        put' = case str' of 
-            Just _ -> CharIO.putErr 
-            Nothing -> const (return ())     
+    let put = case str' of
+            Just _ -> CharIO.putErrLn
+            Nothing -> const (return ())
+        put' = case str' of
+            Just _ -> CharIO.putErr
+            Nothing -> const (return ())
hunk ./FindFixpoint.hs 59
-        fna = listArray (0,len - 1) (snds as) 
+        fna = listArray (0,len - 1) (snds as)
hunk ./FindFixpoint.hs 64
-                    ds <- readArray ref i 
+                    ds <- readArray ref i
hunk ./FindFixpoint.hs 73
-            b'<- fna Array.! i 
+            b'<- fna Array.! i
hunk ./FindFixpoint.hs 75
-                True -> li rs (IntSet.delete i s) 
+                True -> li rs (IntSet.delete i s)
hunk ./FindFixpoint.hs 78
-                    ns <- readArray ref i  
-                    li rs (ns `IntSet.union` IntSet.delete i s) 
+                    ns <- readArray ref i
+                    li rs (ns `IntSet.union` IntSet.delete i s)
hunk ./FixpointFinder.hs 8
-import Data.Map as Map hiding((!),map) 
+import Data.Map as Map hiding((!),map)
hunk ./FixpointFinder.hs 25
-data FFEnv a b = FFEnv { 
-        ffarray :: IOArray Int (b,[Int]), 
+data FFEnv a b = FFEnv {
+        ffarray :: IOArray Int (b,[Int]),
hunk ./FixpointFinder.hs 34
-    return a = Ms (\_ -> return a) 
+    return a = Ms (\_ -> return a)
hunk ./FixpointFinder.hs 36
-        = Ms (\v  -> comp v >>= \r -> case fun r   of Ms x -> x v) 
+        = Ms (\v  -> comp v >>= \r -> case fun r   of Ms x -> x v)
hunk ./FixpointFinder.hs 46
-    --let ind = unsafePerformIO (putErrLn $ "Lookup... " ++ show x) `seq` Map.find x (ffmap ff) 
-    let ind =  Map.find x (ffmap ff) 
+    --let ind = unsafePerformIO (putErrLn $ "Lookup... " ++ show x) `seq` Map.find x (ffmap ff)
+    let ind =  Map.find x (ffmap ff)
hunk ./FixpointFinder.hs 49
-    (n,_) <- lift $ readArray (ffarray ff) ind 
+    (n,_) <- lift $ readArray (ffarray ff) ind
hunk ./FixpointFinder.hs 54
-solve empty vs = do 
+solve empty vs = do
hunk ./FixpointFinder.hs 63
-            (r,is) <- runWriterT fn 
+            (r,is) <- runWriterT fn
hunk ./FixpointFinder.hs 66
-            if (r /= empty) 
+            if (r /= empty)
hunk ./FixpointFinder.hs 71
-    CharIO.putStrLn $ "solve initial changed: " ++ show (Set.size cs) 
-    let z (a,n,fn) = readArray arr n >>= \(_,ds) -> return ((a,n,fn),ds) 
-    rs <- mapM z as 
+    CharIO.putStrLn $ "solve initial changed: " ++ show (Set.size cs)
+    let z (a,n,fn) = readArray arr n >>= \(_,ds) -> return ((a,n,fn),ds)
+    rs <- mapM z as
hunk ./FixpointFinder.hs 81
-                CharIO.putStrLn $ "Iteration... " ++ (show $ Set.size cs) 
-                --mapM_ (\n ->  readArray arr n >>= \(x,_) ->  CharIO.print (aarr!n,x))  (Set.toList cs)    
-            (v,ls) <- readArray arr n 
+                CharIO.putStrLn $ "Iteration... " ++ (show $ Set.size cs)
+                --mapM_ (\n ->  readArray arr n >>= \(x,_) ->  CharIO.print (aarr!n,x))  (Set.toList cs)
+            (v,ls) <- readArray arr n
hunk ./FixpointFinder.hs 85
-                (r,is) <- runWriterT fn 
-                if r /= v then 
-                    writeArray arr n (r,snub (Seq.toList is)) >> 
-                        --print (a,r) >> 
-                           f rs (cs `Set.union` Set.single n)  
+                (r,is) <- runWriterT fn
+                if r /= v then
+                    writeArray arr n (r,snub (Seq.toList is)) >>
+                        --print (a,r) >>
+                           f rs (cs `Set.union` Set.single n)
hunk ./FixpointFinder.hs 92
-                
-    f (cycle as') cs 
+
+    f (cycle as') cs
hunk ./FixpointFinder.hs 95
-            (v,_) <- readArray arr n 
+            (v,_) <- readArray arr n
hunk ./FixpointFinder.hs 97
-    mapM g as 
-    
+    mapM g as
+
hunk ./FixpointFinder.hs 102
-        
+
hunk ./FixpointFinder.hs 105
-        (b',ds) = runWriter (mb m)  
-        
-    g [] _ rs | z `seq` True = f xs nm [] where  
+        (b',ds) = runWriter (mb m)
+
+    g [] _ rs | z `seq` True = f xs nm [] where
hunk ./FixpointFinder.hs 113
-        
+
hunk ./FixpointFinder.hs 118
-            (b',_) = runWriter (mb m)  
+            (b',_) = runWriter (mb m)
hunk ./FixpointFinder.hs 124
---data unboxed Mode = Waiting | InProgress | RecursiveLoop 
+--data unboxed Mode = Waiting | InProgress | RecursiveLoop
hunk ./FixpointFinder.hs 131
-    f [] ys _ = ys 
-    f (x:xs) ys m 
-        | x `IntSet.member` m = f xs ys m 
+    f [] ys _ = ys
+    f (x:xs) ys m
+        | x `IntSet.member` m = f xs ys m
hunk ./FixpointFinder.hs 140
-    Just v <- return $ Map.lookup x m 
+    Just v <- return $ Map.lookup x m
hunk ./FixpointFinder.hs 147
-        (b',ds) = runWriterT mb m  
-    g [] _ rs  = f xs nm [] where  
+        (b',ds) = runWriterT mb m
+    g [] _ rs  = f xs nm [] where
hunk ./FixpointFinder.hs 153
-        
+
hunk ./FixpointFinder.hs 158
-            (b',_) = runWriterT mb m  
+            (b',_) = runWriterT mb m
hunk ./FixpointFinder.hs 168
-instance Monad (Ms' b) where                                            
-    return a = Ms' (\_ -> return a) 
+instance Monad (Ms' b) where
+    return a = Ms' (\_ -> return a)
hunk ./FixpointFinder.hs 171
-        = Ms' (\v  -> comp v >>= \r -> case fun r   of Ms' x -> x v) 
+        = Ms' (\v  -> comp v >>= \r -> case fun r   of Ms' x -> x v)
hunk ./FixpointFinder.hs 174
-    {-# INLINE (>>) #-}  
-    {-# INLINE (>>=) #-}  
-    {-# INLINE return #-}  
+    {-# INLINE (>>) #-}
+    {-# INLINE (>>=) #-}
+    {-# INLINE return #-}
hunk ./FixpointFinder.hs 184
-{-# INLINE getVal' #-}  
-getVal' :: Env b -> Int -> Ms' b b 
+{-# INLINE getVal' #-}
+getVal' :: Env b -> Int -> Ms' b b
hunk ./FixpointFinder.hs 187
-    s <- readArray ref n 
-    --unless (self `IntSet.member` s) 
+    s <- readArray ref n
+    --unless (self `IntSet.member` s)
hunk ./FixpointFinder.hs 190
-    readArray arr n 
-    
-    
+    readArray arr n
+
+
hunk ./FixpointFinder.hs 201
-        fna = listArray (0,len - 1) (snds as) 
+        fna = listArray (0,len - 1) (snds as)
hunk ./FixpointFinder.hs 206
-                    ds <- readArray ref i 
+                    ds <- readArray ref i
hunk ./FixpointFinder.hs 215
-            b'<- (fna Array.! i :: IO b)  
+            b'<- (fna Array.! i :: IO b)
hunk ./FixpointFinder.hs 217
-                True -> li rs (IntSet.delete i s) 
+                True -> li rs (IntSet.delete i s)
hunk ./FixpointFinder.hs 220
-                    ns <- readArray ref i  
-                    li rs (ns `IntSet.union` IntSet.delete i s) 
+                    ns <- readArray ref i
+                    li rs (ns `IntSet.union` IntSet.delete i s)
hunk ./FixpointFinder.hs 226
-    
+
hunk ./FixpointFinder.hs 228
-    let f as [] 0# _ _  = return ()  
+    let f as [] 0# _ _  = return ()
hunk ./FixpointFinder.hs 230
-            CharIO.putErrLn ("Iteration... " ++ show (I# n)) 
+            CharIO.putErrLn ("Iteration... " ++ show (I# n))
hunk ./FixpointFinder.hs 236
-                    b <- fn    
+                    b <- fn
hunk ./FixpointFinder.hs 238
-                g (CyclicSCC xs) = CharIO.putErr "LI: " >> li xs xs 0# >> CharIO.putErrLn "" 
+                g (CyclicSCC xs) = CharIO.putErr "LI: " >> li xs xs 0# >> CharIO.putErrLn ""
hunk ./FixpointFinder.hs 240
-            mapM_ g scc  
+            mapM_ g scc
hunk ./FixpointFinder.hs 243
-            --mapM CharIO.print (map (map fst . z) scc) 
+            --mapM CharIO.print (map (map fst . z) scc)
hunk ./FixpointFinder.hs 245
-            case l of 
+            case l of
hunk ./FixpointFinder.hs 253
-            b <- readArray arr i 
+            b <- readArray arr i
hunk ./FixpointFinder.hs 255
-            b' <- fn 
-            nds <- readIORef ref 
+            b' <- fn
+            nds <- readIORef ref
hunk ./FixpointFinder.hs 266
-            b' <- fn 
+            b' <- fn
hunk ./FixpointFinder.hs 268
-                True -> li xs rs n 
+                True -> li xs rs n
hunk ./FixpointFinder.hs 271
-                    li xs rs (n +# 1#) 
+                    li xs rs (n +# 1#)
hunk ./FixpointFinder.hs 287
-    return a = KI (\_ -> return a) 
+    return a = KI (\_ -> return a)
hunk ./FixpointFinder.hs 289
-        = KI (\v  -> comp v >>= \r -> case fun r   of KI x -> x v) 
+        = KI (\v  -> comp v >>= \r -> case fun r   of KI x -> x v)
hunk ./FixpointFinder.hs 293
-      env :: KindEnv,     -- the environment of kind assumptions 
+      env :: KindEnv,     -- the environment of kind assumptions
hunk ./FreeVars.hs 27
-    freeVars (Left x) = freeVars x 
-    freeVars (Right y) = freeVars y 
+    freeVars (Left x) = freeVars x
+    freeVars (Right y) = freeVars y
hunk ./FrontEnd/Class.hs 3
-        Copyright:              Mark Jones and The Hatchet Team 
+        Copyright:              Mark Jones and The Hatchet Team
hunk ./FrontEnd/Class.hs 8
-        Description:            Code for manipulating the class hierarchy and 
+        Description:            Code for manipulating the class hierarchy and
hunk ./FrontEnd/Class.hs 21
-        Notes:                  See the files License and License.thih 
+        Notes:                  See the files License and License.thih
hunk ./FrontEnd/Class.hs 30
--- TODO this, of everything desperatly needs to be rewritten the most. 
+-- TODO this, of everything desperatly needs to be rewritten the most.
hunk ./FrontEnd/Class.hs 62
-import GenUtil(concatInter) 
+import GenUtil(concatInter)
hunk ./FrontEnd/Class.hs 64
-import HsSyn    
+import HsSyn
hunk ./FrontEnd/Class.hs 73
-import Representation 
-import Type     
+import Representation
+import Type
hunk ./FrontEnd/Class.hs 76
-import Utils        
+import Utils
hunk ./FrontEnd/Class.hs 102
-reducePred h p@(IsIn c t) 
+reducePred h p@(IsIn c t)
hunk ./FrontEnd/Class.hs 156
-    
+
hunk ./FrontEnd/Class.hs 163
-findClassRecord (ClassHierarchy ch) cn = case Map.lookup cn ch of 
-    Nothing -> error $ "findClassRecord: " ++ show cn 
-    Just n -> n 
+findClassRecord (ClassHierarchy ch) cn = case Map.lookup cn ch of
+    Nothing -> error $ "findClassRecord: " ++ show cn
+    Just n -> n
hunk ./FrontEnd/Class.hs 167
-asksClassRecord (ClassHierarchy ch) cn f = case Map.lookup cn ch of 
-    Nothing -> error $ "asksClassRecord: " ++ show cn 
-    Just n -> f n 
+asksClassRecord (ClassHierarchy ch) cn f = case Map.lookup cn ch of
+    Nothing -> error $ "asksClassRecord: " ++ show cn
+    Just n -> f n
hunk ./FrontEnd/Class.hs 178
-showInst :: Inst -> String 
+showInst :: Inst -> String
hunk ./FrontEnd/Class.hs 180
-        
+
hunk ./FrontEnd/Class.hs 197
-    classOrd = toHsName classOrd 
+    classOrd = toHsName classOrd
hunk ./FrontEnd/Class.hs 202
-    classIx = toHsName classIx 
-    classFunctor = toHsName classFunctor 
-    classMonad = toHsName classMonad 
-    classNum = toHsName classNum 
-    classReal = toHsName classReal 
-    classIntegral = toHsName classIntegral 
-    classFractional = toHsName classFractional 
-    classFloating = toHsName classFloating 
-    classRealFrac = toHsName classRealFrac 
-    classRealFloat = toHsName classRealFloat 
+    classIx = toHsName classIx
+    classFunctor = toHsName classFunctor
+    classMonad = toHsName classMonad
+    classNum = toHsName classNum
+    classReal = toHsName classReal
+    classIntegral = toHsName classIntegral
+    classFractional = toHsName classFractional
+    classFloating = toHsName classFloating
+    classRealFrac = toHsName classRealFrac
+    classRealFloat = toHsName classRealFloat
hunk ./FrontEnd/Class.hs 219
-addClassToHierarchy  kt (HsClassDecl _ t decls) (ClassHierarchy h) |   (HsQualType cntxt (HsTyApp (HsTyCon className) (HsTyVar argName)))  <- toHsQualType t = let 
+addClassToHierarchy  kt (HsClassDecl _ t decls) (ClassHierarchy h) |   (HsQualType cntxt (HsTyApp (HsTyCon className) (HsTyVar argName)))  <- toHsQualType t = let
hunk ./FrontEnd/Class.hs 221
-   newClassContext = [(className, argName)] 
-   in return $ ClassHierarchy $ Map.insertWith combineClassRecords  className ClassRecord { className = className, classSupers = map fst cntxt, classInsts = [], classDerives = [], classAssumps = qualifiedMethodAssumps } h  
-    
+   newClassContext = [(className, argName)]
+   in return $ ClassHierarchy $ Map.insertWith combineClassRecords  className ClassRecord { className = className, classSupers = map fst cntxt, classInsts = [], classDerives = [], classAssumps = qualifiedMethodAssumps } h
+
hunk ./FrontEnd/Class.hs 231
---      = concatMap (aHsTypeSigToAssumps kt . qualifyMethod newClassContext) (filter isSigDecl decls) 
+--      = concatMap (aHsTypeSigToAssumps kt . qualifyMethod newClassContext) (filter isSigDecl decls)
hunk ./FrontEnd/Class.hs 233
---      = [(className, argName)] 
+--      = [(className, argName)]
hunk ./FrontEnd/Class.hs 238
-qualifyMethod [(c,n)] (HsTypeSig sloc names (HsQualType oc t)) 
+qualifyMethod [(c,n)] (HsTypeSig sloc names (HsQualType oc t))
hunk ./FrontEnd/Class.hs 240
-        --n' = fromJust $ applyTU (once_tdTU $ adhocTU failTU f) t  
+        --n' = fromJust $ applyTU (once_tdTU $ adhocTU failTU f) t
hunk ./FrontEnd/Class.hs 244
-        Just n' = (something (mkQ mzero f)) t  
+        Just n' = (something (mkQ mzero f)) t
hunk ./FrontEnd/Class.hs 247
-            
-    
+
+
hunk ./FrontEnd/Class.hs 258
-        
-        
+
+
hunk ./FrontEnd/Class.hs 280
-            
+
hunk ./FrontEnd/Class.hs 282
-               _  -> putStrLn $ "\n" ++ 
+               _  -> putStrLn $ "\n" ++
hunk ./FrontEnd/Class.hs 284
-            
-         
+
+
hunk ./FrontEnd/Class.hs 289
-genClassHierarchy :: [(HsDecl)] -> ClassHierarchy 
-genClassHierarchy classes 
-   = foldl (flip addClassToHierarchy) stdClassHierarchy classes 
+genClassHierarchy :: [(HsDecl)] -> ClassHierarchy
+genClassHierarchy classes
+   = foldl (flip addClassToHierarchy) stdClassHierarchy classes
hunk ./FrontEnd/Class.hs 294
-   stdClassHierarchy = listToFM preludeClasses 
+   stdClassHierarchy = listToFM preludeClasses
hunk ./FrontEnd/Class.hs 303
-   --where 
+   --where
hunk ./FrontEnd/Class.hs 311
-           Just r -> ClassHierarchy $ Map.insert c (f r) h 
+           Just r -> ClassHierarchy $ Map.insert c (f r) h
hunk ./FrontEnd/Class.hs 315
-    f c 
+    f c
hunk ./FrontEnd/Class.hs 362
-   (cntxt, classType, argType) 
+   (cntxt, classType, argType)
hunk ./FrontEnd/Class.hs 366
-   {- 
+   {-
hunk ./FrontEnd/Class.hs 381
-           _anythingElse 
-              -> let tyConName = nameOfTyCon tyCon 
+           _anythingElse
+              -> let tyConName = nameOfTyCon tyCon
hunk ./FrontEnd/Class.hs 395
-hsInstDeclToInst kt (HsDataDecl _sloc cntxt tyConName argNames _condecls derives@(_:_)) 
+hsInstDeclToInst kt (HsDataDecl _sloc cntxt tyConName argNames _condecls derives@(_:_))
hunk ./FrontEnd/Class.hs 398
-   tyConKind = kindOf tyConName kt 
+   tyConKind = kindOf tyConName kt
hunk ./FrontEnd/Class.hs 400
-   argTypeKind = foldr1 Kfun $ drop (length argNames) flatTyConKind 
+   argTypeKind = foldr1 Kfun $ drop (length argNames) flatTyConKind
hunk ./FrontEnd/Class.hs 407
-   --newInstances = makeDeriveInstances newContext convertedType derives 
+   --newInstances = makeDeriveInstances newContext convertedType derives
hunk ./FrontEnd/Class.hs 410
-hsInstDeclToInst kt (HsNewTypeDecl _sloc cntxt tyConName argNames _condecls derives@(_:_)) 
+hsInstDeclToInst kt (HsNewTypeDecl _sloc cntxt tyConName argNames _condecls derives@(_:_))
hunk ./FrontEnd/Class.hs 413
-   tyConKind = kindOf tyConName kt 
+   tyConKind = kindOf tyConName kt
hunk ./FrontEnd/Class.hs 415
-   argTypeKind = foldr1 Kfun $ drop (length argNames) flatTyConKind 
+   argTypeKind = foldr1 Kfun $ drop (length argNames) flatTyConKind
hunk ./FrontEnd/Class.hs 422
-   --newInstances = makeDeriveInstances newContext convertedType derives 
+   --newInstances = makeDeriveInstances newContext convertedType derives
hunk ./FrontEnd/Class.hs 446
-        = error $ "makeDeriveInstances: attempt to make type " ++ pretty t ++ 
+        = error $ "makeDeriveInstances: attempt to make type " ++ pretty t ++
hunk ./FrontEnd/Class.hs 463
+
hunk ./FrontEnd/Class.hs 465
- 
hunk ./FrontEnd/Class.hs 470
---   className 
+--   className
hunk ./FrontEnd/Class.hs 473
---           HsUnQualType (HsTyApp (HsTyCon className) _argType) -> className 
+--           HsUnQualType (HsTyApp (HsTyCon className) _argType) -> className
hunk ./FrontEnd/Class.hs 476
+
hunk ./FrontEnd/Class.hs 479
-    
hunk ./FrontEnd/Class.hs 482
-    f n 
-        | n == classEnum = [cia  (hsValName ("Prelude","toEnum")), cia $ hsValName ("Prelude","fromEnum")]      
-        | n == classBounded = [cia  (hsValName ("Prelude","minBound")), cia $ hsValName ("Prelude","maxBound")]      
+    f n
+        | n == classEnum = [cia  (hsValName ("Prelude","toEnum")), cia $ hsValName ("Prelude","fromEnum")]
+        | n == classBounded = [cia  (hsValName ("Prelude","minBound")), cia $ hsValName ("Prelude","maxBound")]
hunk ./FrontEnd/Class.hs 488
-        methodSigs = asksClassRecord ch n classAssumps 
+        methodSigs = asksClassRecord ch n classAssumps
hunk ./FrontEnd/Class.hs 490
-    
+
hunk ./FrontEnd/Class.hs 501
-instanceToTopDecls kt classHierarchy decl@HsDataDecl {} = 
-     (makeDerivation kt classHierarchy (hsDeclName decl) (hsDeclArgs decl) (hsDeclCons decl)) (hsDeclDerives decl) 
-instanceToTopDecls kt classHierarchy decl@HsNewTypeDecl {} = 
-    (makeDerivation kt classHierarchy (hsDeclName decl) (hsDeclArgs decl) [(hsDeclCon decl)]) (hsDeclDerives decl) 
-        
-        
+instanceToTopDecls kt classHierarchy decl@HsDataDecl {} =
+     (makeDerivation kt classHierarchy (hsDeclName decl) (hsDeclArgs decl) (hsDeclCons decl)) (hsDeclDerives decl)
+instanceToTopDecls kt classHierarchy decl@HsNewTypeDecl {} =
+    (makeDerivation kt classHierarchy (hsDeclName decl) (hsDeclArgs decl) [(hsDeclCon decl)]) (hsDeclDerives decl)
+
+
hunk ./FrontEnd/Class.hs 553
+
hunk ./FrontEnd/Class.hs 556
-   
hunk ./FrontEnd/Class.hs 557
-newMethodSig' kt methodName newCntxt qt' instanceType  = newQualType where     
-   ((IsIn _ classArg:restContext) :=> t) = unQuantify qt' 
+newMethodSig' kt methodName newCntxt qt' instanceType  = newQualType where
+   ((IsIn _ classArg:restContext) :=> t) = unQuantify qt'
hunk ./FrontEnd/Class.hs 566
-   --newQualType = runIdentity $ (applyTP $ full_tdTP (adhocTP idTP at)) $ quantify (tv qt) qt 
+   --newQualType = runIdentity $ (applyTP $ full_tdTP (adhocTP idTP at)) $ quantify (tv qt) qt
hunk ./FrontEnd/Class.hs 568
-   --qt = (map (aHsAsstToPred kt) newCntxt ++ restContext) :=> (runIdentity $ applyTP (full_tdTP $ adhocTP idTP ct) t) 
+   --qt = (map (aHsAsstToPred kt) newCntxt ++ restContext) :=> (runIdentity $ applyTP (full_tdTP $ adhocTP idTP ct) t)
hunk ./FrontEnd/Class.hs 571
-   newQualType = everywhere (mkT at) $ quantify (tv qt) qt 
+   newQualType = everywhere (mkT at) $ quantify (tv qt) qt
hunk ./FrontEnd/Class.hs 573
-   qt = (map (aHsAsstToPred kt) newCntxt ++ restContext) :=> (everywhere (mkT ct) t) 
+   qt = (map (aHsAsstToPred kt) newCntxt ++ restContext) :=> (everywhere (mkT ct) t)
hunk ./FrontEnd/Class.hs 580
-   = HsTypeSig bogusASrcLoc [newName] newQualType 
+   = HsTypeSig bogusASrcLoc [newName] newQualType
hunk ./FrontEnd/Class.hs 587
-   newT = oneTypeReplace (HsTyVar classArg, instanceType) t 
-   newQualType 
-      = let finalCntxt = newCntxt++restContxt 
+   newT = oneTypeReplace (HsTyVar classArg, instanceType) t
+   newQualType
+      = let finalCntxt = newCntxt++restContxt
hunk ./FrontEnd/Class.hs 592
-                 (_:_) -> HsQualType finalCntxt newT 
+                 (_:_) -> HsQualType finalCntxt newT
hunk ./FrontEnd/Class.hs 594
-  
--- collect assumptions of all class methods 
+
+-- collect assumptions of all class methods
hunk ./FrontEnd/Class.hs 628
-    return $ partition (all (`elem` fs) . tv) $ simplify h  $ ps' 
+    return $ partition (all (`elem` fs) . tv) $ simplify h  $ ps'
hunk ./FrontEnd/Class.hs 645
-       hnf (TArrow _t1 _t2) = False 
---       hnf (TTuple _args) = False 
+       hnf (TArrow _t1 _t2) = False
+--       hnf (TTuple _args) = False
hunk ./FrontEnd/Class.hs 657
-    loop rs (p:ps) 
+    loop rs (p:ps)
hunk ./FrontEnd/Class.hs 680
-                  -- False, -- XXX 
+                  -- False, -- XXX
hunk ./FrontEnd/Class.hs 687
-withDefaults h vs ps 
+withDefaults h vs ps
hunk ./FrontEnd/Class.hs 689
---  | otherwise = fail $ "Zambiguity: " ++ (render $ pprint ps) ++  show (ps,ps',ams)  
+--  | otherwise = fail $ "Zambiguity: " ++ (render $ pprint ps) ++  show (ps,ps',ams)
hunk ./FrontEnd/Class.hs 697
-    ams <- withDefaults h vs ps 
+    ams <- withDefaults h vs ps
hunk ./FrontEnd/Class.hs 704
-  | any null tss = fail $ "useDefaults.ambiguity: " ++ (render $ pprint ps) ++  show ps  
-  | otherwise = fail $ "Zambiguity: " ++ (render $ pprint ps) ++  show (ps,ps',ams)  
+  | any null tss = fail $ "useDefaults.ambiguity: " ++ (render $ pprint ps) ++  show ps
+  | otherwise = fail $ "Zambiguity: " ++ (render $ pprint ps) ++  show (ps,ps',ams)
hunk ./FrontEnd/Class.hs 713
-  | any null tss = fail $ "topDefaults: ambiguity " ++ (render $ pprint ps) 
+  | any null tss = fail $ "topDefaults: ambiguity " ++ (render $ pprint ps)
hunk ./FrontEnd/Class.hs 733
-    f (HsClassDecl sl t decls) 
-        | HsTyApp (HsTyCon className) (HsTyVar argName)  <- tbody = do 
+    f (HsClassDecl sl t decls)
+        | HsTyApp (HsTyCon className) (HsTyVar argName)  <- tbody = do
hunk ./FrontEnd/Class.hs 736
-                newClassContext = [(className, argName)] 
-            tell [ClassRecord { className = className, classSrcLoc = sl, classSupers = map fst cntxt, classInsts = [], classDerives = [], classAssumps = qualifiedMethodAssumps }] 
-        | otherwise = failSl sl "Invalid Class declaration." 
+                newClassContext = [(className, argName)]
+            tell [ClassRecord { className = className, classSrcLoc = sl, classSupers = map fst cntxt, classInsts = [], classDerives = [], classAssumps = qualifiedMethodAssumps }]
+        | otherwise = failSl sl "Invalid Class declaration."
hunk ./FrontEnd/Class.hs 744
-            Nothing -> return [] -- case Map.lookup x ans of 
+            Nothing -> return [] -- case Map.lookup x ans of
hunk ./FrontEnd/Class.hs 746
-               --  Nothing -> return [] -- failSl (srcLoc decl) "Invalid Instance"  
+               --  Nothing -> return [] -- failSl (srcLoc decl) "Invalid Instance"
hunk ./FrontEnd/DataConsAssump.hs 5
-        Module:                 DataConsAssump 
+        Module:                 DataConsAssump
hunk ./FrontEnd/DataConsAssump.hs 7
-        Description:            Computes the type assumptions of data 
+        Description:            Computes the type assumptions of data
hunk ./FrontEnd/DataConsAssump.hs 19
-                                "These declarations may only appear at the 
+                                "These declarations may only appear at the
hunk ./FrontEnd/DataConsAssump.hs 31
-import HsSyn  
-import Representation     
+import HsSyn
+import Representation
hunk ./FrontEnd/DataConsAssump.hs 35
-import KindInfer 
+import KindInfer
hunk ./FrontEnd/DataConsAssump.hs 40
-dataConsEnv :: Module -> KindEnv -> [HsDecl] -> Map.Map HsName Scheme 
-dataConsEnv modName kt decls 
-   = Map.unions $ map (dataDeclEnv modName kt) decls 
+dataConsEnv :: Module -> KindEnv -> [HsDecl] -> Map.Map HsName Scheme
+dataConsEnv modName kt decls
+   = Map.unions $ map (dataDeclEnv modName kt) decls
hunk ./FrontEnd/DataConsAssump.hs 48
-dataDeclEnv :: Module -> KindEnv -> (HsDecl) -> Map.Map HsName Scheme 
+dataDeclEnv :: Module -> KindEnv -> (HsDecl) -> Map.Map HsName Scheme
hunk ./FrontEnd/DataConsAssump.hs 50
-   = Map.unions $ map (conDeclType modName kt preds resultType) $ condecls 
+   = Map.unions $ map (conDeclType modName kt preds resultType) $ condecls
hunk ./FrontEnd/DataConsAssump.hs 52
-   typeKind = kindOf typeName kt 
+   typeKind = kindOf typeName kt
hunk ./FrontEnd/DataConsAssump.hs 56
-   argKinds = init $ unfoldKind typeKind 
+   argKinds = init $ unfoldKind typeKind
hunk ./FrontEnd/DataConsAssump.hs 58
-   fromHsNameToTyVar (k, n) 
+   fromHsNameToTyVar (k, n)
hunk ./FrontEnd/DataConsAssump.hs 75
-dataDeclEnv _modName _kt _anyOtherDecl 
+dataDeclEnv _modName _kt _anyOtherDecl
hunk ./FrontEnd/DataConsAssump.hs 82
-unitEnv (x,y) = Map.singleton x y 
+unitEnv (x,y) = Map.singleton x y
hunk ./FrontEnd/DataConsAssump.hs 84
-conDeclType :: Module -> KindEnv -> [Pred] -> Type -> HsConDecl -> Map.Map HsName Scheme 
+conDeclType :: Module -> KindEnv -> [Pred] -> Type -> HsConDecl -> Map.Map HsName Scheme
hunk ./FrontEnd/DataConsAssump.hs 97
-bangTypeToType kt (HsBangedTy t) = aHsTypeToType kt t 
+bangTypeToType kt (HsBangedTy t) = aHsTypeToType kt t
hunk ./FrontEnd/DeclsDepends.hs 5
-        Module:                 DeclsDepends 
+        Module:                 DeclsDepends
hunk ./FrontEnd/DeclsDepends.hs 8
-                                depends upon, for use in dependency 
+                                depends upon, for use in dependency
hunk ./FrontEnd/DeclsDepends.hs 19
-import HsSyn 
+import HsSyn
hunk ./FrontEnd/DeclsDepends.hs 29
-debugDeclBindGroups groups 
+debugDeclBindGroups groups
hunk ./FrontEnd/DeclsDepends.hs 32
-                            getDeclDeps  
+                            getDeclDeps
hunk ./FrontEnd/DeclsDepends.hs 34
--- HsDecl getDeps function 
+-- HsDecl getDeps function
hunk ./FrontEnd/DeclsDepends.hs 39
-getDeclDeps (HsPatBind _pat _ rhs wheres) 
+getDeclDeps (HsPatBind _pat _ rhs wheres)
hunk ./FrontEnd/DeclsDepends.hs 57
-   
+
hunk ./FrontEnd/DeclsDepends.hs 59
-   = getRhsDeps rhs ++ foldr (++) [] (map getLocalDeclDeps wheres) 
+   = getRhsDeps rhs ++ foldr (++) [] (map getLocalDeclDeps wheres)
hunk ./FrontEnd/DeclsDepends.hs 66
-getRhsDeps (HsUnGuardedRhs e) 
+getRhsDeps (HsUnGuardedRhs e)
hunk ./FrontEnd/DeclsDepends.hs 72
-getGuardedRhsDeps (HsGuardedRhs _sloc guardExp rhsExp) 
-   = getExpDeps guardExp ++ getExpDeps rhsExp 
+getGuardedRhsDeps (HsGuardedRhs _sloc guardExp rhsExp)
+   = getExpDeps guardExp ++ getExpDeps rhsExp
hunk ./FrontEnd/DeclsDepends.hs 76
-getExpDeps (HsVar name) 
-   = [name] 
+getExpDeps (HsVar name)
+   = [name]
hunk ./FrontEnd/DeclsDepends.hs 88
-     getExpDeps e3 
+     getExpDeps e3
hunk ./FrontEnd/DeclsDepends.hs 90
-getExpDeps (HsApp e1 e2) 
-   = getExpDeps e1 ++ getExpDeps e2 
+getExpDeps (HsApp e1 e2)
+   = getExpDeps e1 ++ getExpDeps e2
hunk ./FrontEnd/DeclsDepends.hs 93
-getExpDeps (HsNegApp e) 
-   = getExpDeps e 
+getExpDeps (HsNegApp e)
+   = getExpDeps e
hunk ./FrontEnd/DeclsDepends.hs 96
-getExpDeps (HsLambda _ _ e) 
-   = getExpDeps e 
+getExpDeps (HsLambda _ _ e)
+   = getExpDeps e
hunk ./FrontEnd/DeclsDepends.hs 101
-     getExpDeps e 
+     getExpDeps e
hunk ./FrontEnd/DeclsDepends.hs 103
-getExpDeps (HsIf e1 e2 e3) 
+getExpDeps (HsIf e1 e2 e3)
hunk ./FrontEnd/DeclsDepends.hs 106
-     getExpDeps e3 
+     getExpDeps e3
hunk ./FrontEnd/DeclsDepends.hs 115
-getExpDeps (HsTuple exps) 
+getExpDeps (HsTuple exps)
hunk ./FrontEnd/DeclsDepends.hs 118
-getExpDeps (HsList exps) 
+getExpDeps (HsList exps)
hunk ./FrontEnd/DeclsDepends.hs 161
-     foldr (++) [] (map getLocalDeclDeps wheres) 
+     foldr (++) [] (map getLocalDeclDeps wheres)
hunk ./FrontEnd/DependAnalysis.hs 5
-        Module:                 DependAnalysis  
+        Module:                 DependAnalysis
hunk ./FrontEnd/DependAnalysis.hs 22
-import List (nub) 
+import List (nub)
hunk ./FrontEnd/DependAnalysis.hs 44
-	= [ mapOnList nameToNodeFM group | group <- nameGroups ] 
+	= [ mapOnList nameToNodeFM group | group <- nameGroups ]
hunk ./FrontEnd/DependAnalysis.hs 46
-	nameGroups = buildNameGroups nameList nameEdges 
+	nameGroups = buildNameGroups nameList nameEdges
hunk ./FrontEnd/DependAnalysis.hs 48
-	nameEdges = buildNameEdges ns getName getDeps 
+	nameEdges = buildNameEdges ns getName getDeps
hunk ./FrontEnd/DependAnalysis.hs 54
-        --Just x -> x 
+        --Just x -> x
hunk ./FrontEnd/DependAnalysis.hs 85
-	= [ mapOnList intToNameFM group | group <- intGroups ] 
+	= [ mapOnList intToNameFM group | group <- intGroups ]
hunk ./FrontEnd/DependAnalysis.hs 120
-		Just x  -> 
+		Just x  ->
hunk ./FrontEnd/DependAnalysis.hs 122
-				Just y  -> (x,y) : (mapOnTuple fm as) 
-				Nothing -> mapOnTuple fm as 
-		Nothing -> mapOnTuple fm as 
+				Just y  -> (x,y) : (mapOnTuple fm as)
+				Nothing -> mapOnTuple fm as
+		Nothing -> mapOnTuple fm as
hunk ./FrontEnd/DependAnalysis.hs 129
--- showBindGroups 
+-- showBindGroups
hunk ./FrontEnd/DependAnalysis.hs 152
-	= "Bindgroup " ++ show groupNum ++ " = " 
-	  ++ bgString ++ "\n" 
+	= "Bindgroup " ++ show groupNum ++ " = "
+	  ++ bgString ++ "\n"
hunk ./FrontEnd/DependAnalysis.hs 156
-	bgString = wrapString "EMPTY" (listToString n getAlias) 
+	bgString = wrapString "EMPTY" (listToString n getAlias)
hunk ./FrontEnd/DependAnalysis.hs 159
--- debugBindGroups 
+-- debugBindGroups
hunk ./FrontEnd/DependAnalysis.hs 192
-	= show groupNum ++ " = " 
-	  ++ bgString ++ "\n" 
+	= show groupNum ++ " = "
+	  ++ bgString ++ "\n"
hunk ./FrontEnd/DependAnalysis.hs 199
-	  
+	
hunk ./FrontEnd/DependAnalysis.hs 201
--- Expand bindgroups, generating dependancie and error information. 
+-- Expand bindgroups, generating dependancie and error information.
hunk ./FrontEnd/DependAnalysis.hs 213
-		then (name:a, bgs++b, name:c) 
-		else (name:a, bgs++b, c) 
+		then (name:a, bgs++b, name:c)
+		else (name:a, bgs++b, c)
hunk ./FrontEnd/DependAnalysis.hs 217
-	(bgs, err) = inHistory (getDeps n) history 
+	(bgs, err) = inHistory (getDeps n) history
hunk ./FrontEnd/DependAnalysis.hs 227
-	= bgString ++ " " ++ depString ++ " " ++ errString 
+	= bgString ++ " " ++ depString ++ " " ++ errString
hunk ./FrontEnd/DependAnalysis.hs 260
-inHistory (name:names) history 
+inHistory (name:names) history
hunk ./FrontEnd/DependAnalysis.hs 276
-searchHistory _ [] 
+searchHistory _ []
hunk ./FrontEnd/Deriving.hs 14
-    f n 
+    f n
hunk ./FrontEnd/Deriving.hs 16
-        | n == hsUnqualValName "Enum" = [inst n (mkEnum cons)] 
-        | otherwise = error $ "unknown deriving: " ++ show n 
-    inst n ds = HsInstDecl sloc (HsQualType [] (HsTyApp (HsTyCon n) tipe))  ds  
+        | n == hsUnqualValName "Enum" = [inst n (mkEnum cons)]
+        | otherwise = error $ "unknown deriving: " ++ show n
+    inst n ds = HsInstDecl sloc (HsQualType [] (HsTyApp (HsTyCon n) tipe))  ds
hunk ./FrontEnd/Deriving.hs 23
-    mkEnum cs = [HsFunBind (map f (zip cs [0..])),  HsFunBind $ (map g (zip cs [0..])) ++ [err]] where 
+    mkEnum cs = [HsFunBind (map f (zip cs [0..])),  HsFunBind $ (map g (zip cs [0..])) ++ [err]] where
hunk ./FrontEnd/Deriving.hs 31
-                constraints :: [(Class,Var)], 
+                constraints :: [(Class,Var)],
hunk ./FrontEnd/Deriving.hs 36
-		deriving (Eq,Show) 
-data Body = Body { 
+		deriving (Eq,Show)
+data Body = Body {
hunk ./FrontEnd/Deriving.hs 41
-    } deriving (Eq,Show) 
+    } deriving (Eq,Show)
hunk ./FrontEnd/Deriving.hs 44
-toData :: HsName -> [HsName] -> [HsConDecl] -> [HsName] -> Data 
+toData :: HsName -> [HsName] -> [HsConDecl] -> [HsName] -> Data
hunk ./FrontEnd/Deriving.hs 46
-    f c = Body { constructor = show $ hsConDeclName c, types = hsConDeclArgs c, labels = lb c } 
+    f c = Body { constructor = show $ hsConDeclName c, types = hsConDeclArgs c, labels = lb c }
hunk ./FrontEnd/Deriving.hs 50
-                                                         
+
hunk ./FrontEnd/Deriving.hs 58
-eqfn = instanceSkeleton "Eq" [(makeEq,defaultEq)] 
+eqfn = instanceSkeleton "Eq" [(makeEq,defaultEq)]
hunk ./FrontEnd/Deriving.hs 65
-	v' = varNames' types 
+	v' = varNames' types
hunk ./FrontEnd/Deriving.hs 68
-	body = sepWith (text "&&") $ 
+	body = sepWith (text "&&") $
hunk ./FrontEnd/Deriving.hs 78
-ordfn d = let 
+ordfn d = let
hunk ./FrontEnd/Deriving.hs 83
-   f (b,n) (b',n') 
+   f (b,n) (b',n')
hunk ./FrontEnd/Deriving.hs 89
-		      head  = fsep [l,r, char '='] 
+		      head  = fsep [l,r, char '=']
hunk ./FrontEnd/Deriving.hs 113
-    ans = HsFunBind $ concat [ map x (body d) ++ y | (x,y) <- fs ] 
+    ans = HsFunBind $ concat [ map x (body d) ++ y | (x,y) <- fs ]
hunk ./FrontEnd/Deriving.hs 115
-showfn = instanceSkeleton "Show" [(makeShow,mempty)] 
+showfn = instanceSkeleton "Show" [(makeShow,mempty)]
hunk ./FrontEnd/Deriving.hs 140
--- Read 
+-- Read
hunk ./FrontEnd/Deriving.hs 157
-	read = lambda . listComp (result rest) 
+	read = lambda . listComp (result rest)
hunk ./FrontEnd/Deriving.hs 170
-		in lambda . listComp (result rest) 
-			$ lexConstr ip : openB 
+		in lambda . listComp (result rest)
+			$ lexConstr ip : openB
hunk ./FrontEnd/Deriving.hs 175
-	listComp x (l:ll) = brackets . fsep . sepWith comma $  
+	listComp x (l:ll) = brackets . fsep . sepWith comma $
hunk ./FrontEnd/Deriving.hs 193
-enumfn d = let 
+enumfn d = let
hunk ./FrontEnd/Deriving.hs 198
-	   then commentLine $ text "Warning -- can't derive Enum for" 
+	   then commentLine $ text "Warning -- can't derive Enum for"
hunk ./FrontEnd/Deriving.hs 200
-	   else simpleInstance "Enum" d <+> text "where" 
+	   else simpleInstance "Enum" d <+> text "where"
hunk ./FrontEnd/Deriving.hs 207
-		texts [constructor , "=", show n])	 
+		texts [constructor , "=", show n])	
hunk ./FrontEnd/Deriving.hs 213
-		texts [show n , "=", constructor])    
+		texts [show n , "=", constructor])
hunk ./FrontEnd/Deriving.hs 216
-enumFromFn D{body=body} = let 
+enumFromFn D{body=body} = let
hunk ./FrontEnd/Deriving.hs 218
-	bodydoc = fsep [char 'e', char '=', text "drop", 
+	bodydoc = fsep [char 'e', char '=', text "drop",
hunk ./FrontEnd/Deriving.hs 236
-boundedfn d@D{name=name,body=body,derives=derives} 
+boundedfn d@D{name=name,body=body,derives=derives}
hunk ./FrontEnd/Deriving.hs 250
-		hsep . texts $ [ "minBound","=",constructor f] ++ 
+		hsep . texts $ [ "minBound","=",constructor f] ++
hunk ./FrontEnd/Desugar.hs 18
-                                        - do notation is converted into 
+                                        - do notation is converted into
hunk ./FrontEnd/Desugar.hs 27
-                                According to the Haskell report a pattern 
-                                binding is called "simple" if it consists only 
-                                of a single variable - thus we convert all 
+                                According to the Haskell report a pattern
+                                binding is called "simple" if it consists only
+                                of a single variable - thus we convert all
hunk ./FrontEnd/Desugar.hs 57
-readUnique :: PatSM Int 
-readUnique 
+readUnique :: PatSM Int
+readUnique
hunk ./FrontEnd/Desugar.hs 61
-        return (fst state) 
+        return (fst state)
hunk ./FrontEnd/Desugar.hs 64
-readSyns 
+readSyns
hunk ./FrontEnd/Desugar.hs 70
-incUnique :: PatSM () 
+incUnique :: PatSM ()
hunk ./FrontEnd/Desugar.hs 85
---readPatSM                  :: PatSM PatState 
+--readPatSM                  :: PatSM PatState
hunk ./FrontEnd/Desugar.hs 107
--- a new (unique) name introduced in expressions 
+-- a new (unique) name introduced in expressions
hunk ./FrontEnd/Desugar.hs 111
-remSynsSig :: HsDecl -> PatSM HsDecl 
-remSynsSig sig 
+remSynsSig :: HsDecl -> PatSM HsDecl
+remSynsSig sig
hunk ./FrontEnd/Desugar.hs 122
-        let newType = removeSynonymsFromType syns t 
+        let newType = removeSynonymsFromType syns t
hunk ./FrontEnd/Desugar.hs 135
- 
+
hunk ./FrontEnd/Desugar.hs 143
-desugarHsModule :: HsModule -> HsModule 
+desugarHsModule :: HsModule -> HsModule
hunk ./FrontEnd/Desugar.hs 147
-    
+
hunk ./FrontEnd/Desugar.hs 152
---   (newTidy, _) = runPatSM (0::Int, synonyms) $ desugarTidyModuleM tidy 
+--   (newTidy, _) = runPatSM (0::Int, synonyms) $ desugarTidyModuleM tidy
hunk ./FrontEnd/Desugar.hs 167
---        newTyDecls    <- mapM desugarDecl oldTyDecls 
---        newDataDecls  <- mapM desugarDecl oldDataDecls 
---        newInFixDecls <- mapM desugarDecl oldInFixDecls 
---        newNewTyDecls <- mapM desugarDecl oldNewTyDecls 
---        newClassDecls <- mapM desugarDecl oldClassDecls 
---        newInstDecls  <- mapM desugarDecl oldInstDecls 
---        newDefs       <- mapM desugarDecl oldDefs 
---        newTySigs     <- mapM desugarDecl oldTySigs 
---        newFunBinds   <- mapM desugarDecl oldFunBinds 
---        newPatBinds   <- mapM desugarDecl oldPatBinds 
+--        newTyDecls    <- mapM desugarDecl oldTyDecls
+--        newDataDecls  <- mapM desugarDecl oldDataDecls
+--        newInFixDecls <- mapM desugarDecl oldInFixDecls
+--        newNewTyDecls <- mapM desugarDecl oldNewTyDecls
+--        newClassDecls <- mapM desugarDecl oldClassDecls
+--        newInstDecls  <- mapM desugarDecl oldInstDecls
+--        newDefs       <- mapM desugarDecl oldDefs
+--        newTySigs     <- mapM desugarDecl oldTySigs
+--        newFunBinds   <- mapM desugarDecl oldFunBinds
+--        newPatBinds   <- mapM desugarDecl oldPatBinds
hunk ./FrontEnd/Desugar.hs 195
-    newMatches <- mapM desugarMatch matches  
+    newMatches <- mapM desugarMatch matches
hunk ./FrontEnd/Desugar.hs 203
-        
+
hunk ./FrontEnd/Desugar.hs 214
-    let newTopDeclForRhs 
+    let newTopDeclForRhs
hunk ./FrontEnd/Desugar.hs 216
-    let newBinds = genBindsForPat pat sloc newRhsName 
-    newBinds <- mapM desugarDecl newBinds 
+    let newBinds = genBindsForPat pat sloc newRhsName
+    newBinds <- mapM desugarDecl newBinds
hunk ./FrontEnd/Desugar.hs 221
-    newDecls <- mapM desugarDecl decls 
+    newDecls <- mapM desugarDecl decls
hunk ./FrontEnd/Desugar.hs 230
-    newSig <- remSynsSig sig 
+    newSig <- remSynsSig sig
hunk ./FrontEnd/Desugar.hs 237
-        ds <- deriveInstances sloc name args newConDecls derives 
+        ds <- deriveInstances sloc name args newConDecls derives
hunk ./FrontEnd/Desugar.hs 244
-        ds <- deriveInstances sloc name args [newConDecl] derives 
+        ds <- deriveInstances sloc name args [newConDecl] derives
hunk ./FrontEnd/Desugar.hs 247
-        
+
hunk ./FrontEnd/Desugar.hs 252
-createSelectors _sloc ds = ans where 
+createSelectors _sloc ds = ans where
hunk ./FrontEnd/Desugar.hs 258
-    ans = return $  map g ns 
+    ans = return $  map g ns
hunk ./FrontEnd/Desugar.hs 260
-        f (_,(c,i,l)) = HsMatch _sloc n [pat c i l] (HsUnGuardedRhs (HsVar var)) [] 
+        f (_,(c,i,l)) = HsMatch _sloc n [pat c i l] (HsUnGuardedRhs (HsVar var)) []
hunk ./FrontEnd/Desugar.hs 263
-        
+
hunk ./FrontEnd/Desugar.hs 285
-    return (HsUnBangedTy newType)   
+    return (HsUnBangedTy newType)
hunk ./FrontEnd/Desugar.hs 336
-   = patVarNames pat 
+   = patVarNames pat
hunk ./FrontEnd/Desugar.hs 338
--- replaces all occurrences of a name with a new variable 
+-- replaces all occurrences of a name with a new variable
hunk ./FrontEnd/Desugar.hs 347
-replaceVarNamesInPat name (HsPNeg pat) 
-   = HsPNeg $ replaceVarNamesInPat name pat 
-replaceVarNamesInPat name (HsPInfixApp pat1 conName pat2) 
+replaceVarNamesInPat name (HsPNeg pat)
+   = HsPNeg $ replaceVarNamesInPat name pat
+replaceVarNamesInPat name (HsPInfixApp pat1 conName pat2)
hunk ./FrontEnd/Desugar.hs 359
-replaceVarNamesInPat name (HsPRec _ _) 
+replaceVarNamesInPat name (HsPRec _ _)
hunk ./FrontEnd/Desugar.hs 366
-   = HsPIrrPat $ replaceVarNamesInPat name pat 
+   = HsPIrrPat $ replaceVarNamesInPat name pat
hunk ./FrontEnd/Desugar.hs 391
-desugarExp e@HsCon {} = return e 
+desugarExp e@HsCon {} = return e
hunk ./FrontEnd/Desugar.hs 413
-desugarExp (HsLambda sloc pats e) 
+desugarExp (HsLambda sloc pats e)
hunk ./FrontEnd/Desugar.hs 421
-        let (xs,zs) = unzip ps       
+        let (xs,zs) = unzip ps
hunk ./FrontEnd/Desugar.hs 423
-        return (HsLambda sloc (map HsPVar xs) e')  
-    ne e [] = desugarExp e    
+        return (HsLambda sloc (map HsPVar xs) e')
+    ne e [] = desugarExp e
hunk ./FrontEnd/Desugar.hs 426
-        e' <- ne e zs 
+        e' <- ne e zs
hunk ./FrontEnd/Desugar.hs 429
-        return $ HsCase (HsVar n) [a1, a2 ] 
+        return $ HsCase (HsVar n) [a1, a2 ]
hunk ./FrontEnd/Desugar.hs 442
-        newDecls <- mapM desugarDecl decls    
+        newDecls <- mapM desugarDecl decls
hunk ./FrontEnd/Desugar.hs 469
-desugarExp (HsList exps)   
+desugarExp (HsList exps)
hunk ./FrontEnd/Desugar.hs 486
-        newE1 <- desugarExp e1                          
+        newE1 <- desugarExp e1
hunk ./FrontEnd/Desugar.hs 492
-    fus' <- mapM desugarFU fus 
+    fus' <- mapM desugarFU fus
hunk ./FrontEnd/Desugar.hs 497
-    fus' <- mapM desugarFU fus 
+    fus' <- mapM desugarFU fus
hunk ./FrontEnd/Desugar.hs 543
-   = do 
+   = do
hunk ./FrontEnd/Desugar.hs 547
-        let newVarDecl = HsPatBind sloc 
-                                    (HsPVar newVarName) 
+        let newVarDecl = HsPatBind sloc
+                                    (HsPVar newVarName)
hunk ./FrontEnd/Desugar.hs 564
-        return (HsIrrPat newE) 
+        return (HsIrrPat newE)
hunk ./FrontEnd/Desugar.hs 611
-        newDecls <- mapM desugarDecl decls 
+        newDecls <- mapM desugarDecl decls
hunk ./FrontEnd/Desugar.hs 649
-   kase = HsCase (HsVar newPatVarName) [a1, a2 ] 
+   kase = HsCase (HsVar newPatVarName) [a1, a2 ]
hunk ./FrontEnd/Desugar.hs 661
-        kase = HsCase (HsVar newPatVarName) [a1, a2 ] 
+        kase = HsCase (HsVar newPatVarName) [a1, a2 ]
hunk ./FrontEnd/Desugar.hs 664
-    
+
hunk ./FrontEnd/Diagnostic.hs 7
-        Description:            Utilities for working with (error/otherwise) 
+        Description:            Utilities for working with (error/otherwise)
hunk ./FrontEnd/Diagnostic.hs 10
-        Primary Authors:        Bryn Humberstone 
+        Primary Authors:        Bryn Humberstone
hunk ./FrontEnd/Diagnostic.hs 33
-data TypeError 
+data TypeError
hunk ./FrontEnd/Diagnostic.hs 35
-        | BogusError 
+        | BogusError
hunk ./FrontEnd/Diagnostic.hs 37
-    
+
hunk ./FrontEnd/Diagnostic.hs 41
-   = error $ "\n" ++ 
+   = error $ "\n" ++
hunk ./FrontEnd/Diagnostic.hs 44
-             "Where:   " ++ dumpDiagnostic 3 ds 
+             "Where:   " ++ dumpDiagnostic 3 ds
hunk ./FrontEnd/Diagnostic.hs 49
-           BogusError    -> ("bogus reason", "bogus reason") 
+           BogusError    -> ("bogus reason", "bogus reason")
hunk ./FrontEnd/Diagnostic.hs 51
-     
+
hunk ./FrontEnd/Diagnostic.hs 53
-data Diagnostic = Msg (Maybe SrcLoc) String 
+data Diagnostic = Msg (Maybe SrcLoc) String
hunk ./FrontEnd/Diagnostic.hs 82
-{- take a diagnostic stack and a 'maxContext' and display the 
+{- take a diagnostic stack and a 'maxContext' and display the
hunk ./FrontEnd/Diagnostic.hs 91
-         = case diag of 
-                Msg maybeloc _ -> isJust maybeloc 
+         = case diag of
+                Msg maybeloc _ -> isJust maybeloc
hunk ./FrontEnd/Diagnostic.hs 95
-     mostRecentASrcLoc 
+     mostRecentASrcLoc
hunk ./FrontEnd/Diagnostic.hs 97
-                Just (Msg (Just (SrcLoc fn line col)) _) 
+                Just (Msg (Just (SrcLoc fn line col)) _)
hunk ./FrontEnd/Diagnostic.hs 100
-                
+
hunk ./FrontEnd/Diagnostic.hs 103
-   the stack first, so most calls will have to reverse the stack 
+   the stack first, so most calls will have to reverse the stack
hunk ./FrontEnd/Diagnostic.hs 105
-showDiagnostics :: [Diagnostic] -> String   
+showDiagnostics :: [Diagnostic] -> String
hunk ./FrontEnd/Diagnostic.hs 107
-    = case diags of 
+    = case diags of
hunk ./FrontEnd/Diagnostic.hs 110
-    where 
+    where
hunk ./FrontEnd/Diagnostic.hs 113
-       = case diags of 
+       = case diags of
hunk ./FrontEnd/Diagnostic.hs 117
-       
+
hunk ./FrontEnd/Diagnostic.hs 119
-       = msg 
+       = msg
hunk ./FrontEnd/Diagnostic.hs 121
-         ++ case maybeLoc of 
+         ++ case maybeLoc of
hunk ./FrontEnd/Diagnostic.hs 124
-              
+
hunk ./FrontEnd/Exports.hs 4
-module FrontEnd.Exports(determineExports) where 
+module FrontEnd.Exports(determineExports) where
hunk ./FrontEnd/Exports.hs 13
-import List 
+import List
hunk ./FrontEnd/Exports.hs 25
-    mp xs 
+    mp xs
hunk ./FrontEnd/Exports.hs 38
-    let ds = [ (n,cs) | (n,_,cs) <- defs ++ concatMap modInfoDefs ms] 
-    ms <- determineExports' ds ae ms 
-    let g m = do 
-            when (dump FD.Imports) $ do 
-                putStrLn $ " -- Imports -- " ++  show (modInfoName m) 
+    let ds = [ (n,cs) | (n,_,cs) <- defs ++ concatMap modInfoDefs ms]
+    ms <- determineExports' ds ae ms
+    let g m = do
+            when (dump FD.Imports) $ do
+                putStrLn $ " -- Imports -- " ++  show (modInfoName m)
hunk ./FrontEnd/Exports.hs 44
-            when (dump FD.Exports) $ do 
-                putStrLn $ " -- Exports -- " ++  show (modInfoName m) 
+            when (dump FD.Exports) $ do
+                putStrLn $ " -- Exports -- " ++  show (modInfoName m)
hunk ./FrontEnd/Exports.hs 53
-    rs <- solve Nothing  mempty [ x |(_,_,x) <- ms] 
-    let lf m =  Map.lookup m  $ dmodMap `mappend` Map.fromList [ (modInfoName x,Set.fromList [(toUnqualified x,x) | x <- modInfoExport x]) |  x  <- xs] 
+    rs <- solve Nothing  mempty [ x |(_,_,x) <- ms]
+    let lf m =  Map.lookup m  $ dmodMap `mappend` Map.fromList [ (modInfoName x,Set.fromList [(toUnqualified x,x) | x <- modInfoExport x]) |  x  <- xs]
hunk ./FrontEnd/Exports.hs 56
-            ne' <- ce mi ne 
+            ne' <- ce mi ne
hunk ./FrontEnd/Exports.hs 58
-    xs <- mapM g $ zip todoMods rs 
-    return xs 
+    xs <- mapM g $ zip todoMods rs
+    return xs
hunk ./FrontEnd/Exports.hs 65
-    le m = runIdentity $ Map.lookup m modMap 
+    le m = runIdentity $ Map.lookup m modMap
hunk ./FrontEnd/Exports.hs 71
-    getExports :: Monad m => ModInfo -> (Module -> m (Rel Name Name)) -> m (Rel Name Name) 
+    getExports :: Monad m => ModInfo -> (Module -> m (Rel Name Name)) -> m (Rel Name Name)
hunk ./FrontEnd/Exports.hs 74
-        is <- getImports mi le 
-        let f (HsEModuleContents m) = mapDomain g unqs `R.intersection` qs where                   
+        is <- getImports mi le
+        let f (HsEModuleContents m) = mapDomain g unqs `R.intersection` qs where
hunk ./FrontEnd/Exports.hs 78
-            f z = entSpec False is z 
+            f z = entSpec False is z
hunk ./FrontEnd/Exports.hs 82
-    getImports :: Monad m => ModInfo -> (Module -> m (Rel Name Name)) -> m (Rel Name Name) 
+    getImports :: Monad m => ModInfo -> (Module -> m (Rel Name Name)) -> m (Rel Name Name)
hunk ./FrontEnd/Exports.hs 85
-            es <- le (hsImportDeclModule x) 
+            es <- le (hsImportDeclModule x)
hunk ./FrontEnd/Exports.hs 88
-                Nothing -> return es -- return $ (mapDomain ((Name.qualifyName as)) es `mappend` if hsImportDeclQualified x then mempty else es) 
+                Nothing -> return es -- return $ (mapDomain ((Name.qualifyName as)) es `mappend` if hsImportDeclQualified x then mempty else es)
hunk ./FrontEnd/Exports.hs 92
-            return $ (mapDomain ((Name.qualifyName as)) es' `mappend` if hsImportDeclQualified x then mempty else es') 
-        is = modInfoModImports mi 
-        ls = R.fromList $  concat [ [(toUnqualified z,z),(z,z)]| (z, _, _) <- modInfoDefs mi] 
+            return $ (mapDomain ((Name.qualifyName as)) es' `mappend` if hsImportDeclQualified x then mempty else es')
+        is = modInfoModImports mi
+        ls = R.fromList $  concat [ [(toUnqualified z,z),(z,z)]| (z, _, _) <- modInfoDefs mi]
hunk ./FrontEnd/Exports.hs 96
-    entSpec :: 
+    entSpec ::
hunk ./FrontEnd/Exports.hs 99
-        -> HsExportSpec   -- ^ the specification 
+        -> HsExportSpec   -- ^ the specification
hunk ./FrontEnd/Exports.hs 109
-        ss = concat $ concat [ maybeToList (Map.lookup x ownsMap) | x <- Set.toList $ range (restrictDomain (`elem` ct) rel)] 
+        ss = concat $ concat [ maybeToList (Map.lookup x ownsMap) | x <- Set.toList $ range (restrictDomain (`elem` ct) rel)]
hunk ./FrontEnd/Exports.hs 122
-    
+
hunk ./FrontEnd/HsErrors.hs 19
-    hsQualType (hsTypeType x) 
+    hsQualType (hsTypeType x)
hunk ./FrontEnd/HsErrors.hs 28
-    when (null cs) $ warn sl "h98-emptydata" "data types with no constructors are a non-haskell98 feature" 
+    when (null cs) $ warn sl "h98-emptydata" "data types with no constructors are a non-haskell98 feature"
hunk ./FrontEnd/HsErrors.hs 47
-    
hunk ./FrontEnd/HsErrors.hs 48
-mapHsTypeHsType f (HsTyFun a b) = do 
-    a <- f a 
+
+mapHsTypeHsType f (HsTyFun a b) = do
+    a <- f a
hunk ./FrontEnd/HsErrors.hs 56
-mapHsTypeHsType f (HsTyApp a b) = do 
-    a <- f a 
+mapHsTypeHsType f (HsTyApp a b) = do
+    a <- f a
hunk ./FrontEnd/HsErrors.hs 60
-mapHsTypeHsType f (HsTyForall vs qt) = do 
+mapHsTypeHsType f (HsTyForall vs qt) = do
hunk ./FrontEnd/HsErrors.hs 64
-    
+
hunk ./FrontEnd/HsParser.ly 19
-> 
+>
hunk ./FrontEnd/HsParser.ly 21
-> import FrontEnd.ParseMonad 
+> import FrontEnd.ParseMonad
hunk ./FrontEnd/HsParser.ly 24
-> 
+>
hunk ./FrontEnd/HsParser.ly 266
->           {% checkDataHeader $2 `thenP` \(cs,c,t) -> 
+>           {% checkDataHeader $2 `thenP` \(cs,c,t) ->
hunk ./FrontEnd/HsParser.ly 347
-> kind :: { HsKind } 
+> kind :: { HsKind }
hunk ./FrontEnd/HsParser.ly 410
->	| srcloc con '{' fielddecls '}' 
+>	| srcloc con '{' fielddecls '}'
hunk ./FrontEnd/HsParser.ly 640
->	| infixexp srcloc ralt 'where' decllist 
+>	| infixexp srcloc ralt 'where' decllist
hunk ./FrontEnd/HsParser.ly 792
- 
+
hunk ./FrontEnd/HsPretty.hs 35
-infixl 5 $$$ 
+infixl 5 $$$
hunk ./FrontEnd/HsPretty.hs 42
-	      | PPInLine		-- inline decls, \n between them 
+	      | PPInLine		-- inline decls, \n between them
hunk ./FrontEnd/HsPretty.hs 48
-data PPHsMode = PPHsMode { 
+data PPHsMode = PPHsMode {
hunk ./FrontEnd/HsPretty.hs 68
-		      layout = PPOffsideRule, 
+		      layout = PPOffsideRule,
hunk ./FrontEnd/HsPretty.hs 94
-getPPEnv :: DocM s s 
+getPPEnv :: DocM s s
hunk ./FrontEnd/HsPretty.hs 97
--- So that pp code still looks the same 
+-- So that pp code still looks the same
hunk ./FrontEnd/HsPretty.hs 107
-nest i m = m >>= return . P.nest i 
+nest i m = m >>= return . P.nest i
hunk ./FrontEnd/HsPretty.hs 201
-fullRenderWithMode :: PPHsMode -> P.Mode -> Int -> Float -> 
+fullRenderWithMode :: PPHsMode -> P.Mode -> Int -> Float ->
hunk ./FrontEnd/HsPretty.hs 203
-fullRenderWithMode ppMode m i f fn e mD = 
+fullRenderWithMode ppMode m i f fn e mD =
hunk ./FrontEnd/HsPretty.hs 207
-fullRender :: P.Mode -> Int -> Float -> (P.TextDetails -> a -> a) 
+fullRender :: P.Mode -> Int -> Float -> (P.TextDetails -> a -> a)
hunk ./FrontEnd/HsPretty.hs 213
-ppHsModule (HsModule mod _ mbExports imp decls _) = 
+ppHsModule (HsModule mod _ mbExports imp decls _) =
hunk ./FrontEnd/HsPretty.hs 230
-ppHsExportSpec (HsEAbs name)                     = ppHsQName name 
+ppHsExportSpec (HsEAbs name)                     = ppHsQName name
hunk ./FrontEnd/HsPretty.hs 234
-ppHsExportSpec (HsEModuleContents (Module name)) = text "module" <+> text name 
+ppHsExportSpec (HsEModuleContents (Module name)) = text "module" <+> text name
hunk ./FrontEnd/HsPretty.hs 236
-ppHsImportDecl (HsImportDecl pos (Module mod) bool mbName mbSpecs) = 
-	   mySep [text "import", 
+ppHsImportDecl (HsImportDecl pos (Module mod) bool mbName mbSpecs) =
+	   mySep [text "import",
hunk ./FrontEnd/HsPretty.hs 239
-		 text mod, 
+		 text mod,
hunk ./FrontEnd/HsPretty.hs 243
-	   exports (b,specList) 
+	   exports (b,specList)
hunk ./FrontEnd/HsPretty.hs 249
-ppHsImportSpec (HsIAbs name)                     = ppHsName name 
+ppHsImportSpec (HsIAbs name)                     = ppHsName name
hunk ./FrontEnd/HsPretty.hs 257
-ppHsDecl (HsTypeDecl loc name nameList htype) = 
+ppHsDecl (HsTypeDecl loc name nameList htype) =
hunk ./FrontEnd/HsPretty.hs 259
-	   mySep ( [text "type",ppHsName name] 
+	   mySep ( [text "type",ppHsName name]
hunk ./FrontEnd/HsPretty.hs 263
-ppHsDecl (HsDataDecl loc context name nameList constrList derives) = 
+ppHsDecl (HsDataDecl loc context name nameList constrList derives) =
hunk ./FrontEnd/HsPretty.hs 265
-           mySep ([text "data", ppHsContext context, ppHsName name] 
+           mySep ([text "data", ppHsContext context, ppHsName name]
hunk ./FrontEnd/HsPretty.hs 285
-	   $$$ body classIndent (map ppHsDecl declList)  
+	   $$$ body classIndent (map ppHsDecl declList)
hunk ./FrontEnd/HsPretty.hs 289
-ppHsDecl (HsInstDecl pos qualType []) = 
+ppHsDecl (HsInstDecl pos qualType []) =
hunk ./FrontEnd/HsPretty.hs 292
-ppHsDecl (HsInstDecl pos qualType declList) = 
+ppHsDecl (HsInstDecl pos qualType declList) =
hunk ./FrontEnd/HsPretty.hs 296
-		   
-ppHsDecl (HsDefaultDecl pos htype) = 
-	   --blankline $ 
+		
+ppHsDecl (HsDefaultDecl pos htype) =
+	   --blankline $
hunk ./FrontEnd/HsPretty.hs 300
- 
-ppHsDecl (HsTypeSig pos nameList qualType) = 
-	 --blankline $ 
+
+ppHsDecl (HsTypeSig pos nameList qualType) =
+	 --blankline $
hunk ./FrontEnd/HsPretty.hs 307
-ppHsDecl (HsFunBind pos matches) 
+ppHsDecl (HsFunBind pos matches)
hunk ./FrontEnd/HsPretty.hs 310
-ppHsDecl (HsFunBind matches) 
-   =  foldr ($$$) empty (map ppMatch matches) 
+ppHsDecl (HsFunBind matches)
+   =  foldr ($$$) empty (map ppMatch matches)
hunk ./FrontEnd/HsPretty.hs 321
-	   --blankline $ 
+	   --blankline $
hunk ./FrontEnd/HsPretty.hs 336
-        
+
hunk ./FrontEnd/HsPretty.hs 347
-	 mySep $ (ppHsName name) : 
+	 mySep $ (ppHsName name) :
hunk ./FrontEnd/HsPretty.hs 403
-ppHsRhs (HsGuardedRhss guardList) = 
+ppHsRhs (HsGuardedRhss guardList) =
hunk ./FrontEnd/HsPretty.hs 407
-ppHsGuardedRhs (HsGuardedRhs pos guard body) = 
+ppHsGuardedRhs (HsGuardedRhs pos guard body) =
hunk ./FrontEnd/HsPretty.hs 433
-	where 
+	where
hunk ./FrontEnd/HsPretty.hs 436
-	ppInfix (HsVar n) = ppHsQNameInfix n 
+	ppInfix (HsVar n) = ppHsQNameInfix n
hunk ./FrontEnd/HsPretty.hs 441
--- ppHsExp (HsLambda expList body) = myFsep $ 
+-- ppHsExp (HsLambda expList body) = myFsep $
hunk ./FrontEnd/HsPretty.hs 449
-ppHsExp (HsIf cond thenexp elsexp) = 
+ppHsExp (HsIf cond thenexp elsexp) =
hunk ./FrontEnd/HsPretty.hs 472
-ppHsExp (HsRecConstr c fieldList) = 
+ppHsExp (HsRecConstr c fieldList) =
hunk ./FrontEnd/HsPretty.hs 475
-ppHsExp (HsRecUpdate exp fieldList) = 
+ppHsExp (HsRecUpdate exp fieldList) =
hunk ./FrontEnd/HsPretty.hs 487
-ppHsExp (HsList list) = 
+ppHsExp (HsList list) =
hunk ./FrontEnd/HsPretty.hs 493
-ppHsExp (HsEnumFromThen from thenE) = 
+ppHsExp (HsEnumFromThen from thenE) =
hunk ./FrontEnd/HsPretty.hs 495
-ppHsExp (HsEnumFromThenTo from thenE to) = 
+ppHsExp (HsEnumFromThenTo from thenE to) =
hunk ./FrontEnd/HsPretty.hs 498
-ppHsExp (HsListComp exp stmtList) = 
+ppHsExp (HsListComp exp stmtList) =
hunk ./FrontEnd/HsPretty.hs 501
-ppHsExp (HsExpTypeSig pos exp ty) = 
+ppHsExp (HsExpTypeSig pos exp ty) =
hunk ./FrontEnd/HsPretty.hs 515
-ppHsPat (HsPRec c fields) 
-    =  ppHsQName c 
+ppHsPat (HsPRec c fields)
+    =  ppHsQName c
hunk ./FrontEnd/HsPretty.hs 526
-  
+
hunk ./FrontEnd/HsPretty.hs 536
-ppGAlt (HsGuardedAlt pos exp body) = 
+ppGAlt (HsGuardedAlt pos exp body) =
hunk ./FrontEnd/HsPretty.hs 544
-ppHsStmt (HsLetStmt declList) = text "let" 
+ppHsStmt (HsLetStmt declList) = text "let"
hunk ./FrontEnd/HsPretty.hs 549
-ppHsFieldUpdate (HsFieldUpdate name exp) = 
+ppHsFieldUpdate (HsFieldUpdate name exp) =
hunk ./FrontEnd/HsPretty.hs 555
-ppHsQName z@(Qual m@(Module mod) name) 
+ppHsQName z@(Qual m@(Module mod) name)
hunk ./FrontEnd/HsPretty.hs 583
-isSymbolName x | (c:_) <- hsIdentString (hsNameIdent (unRename x)), isAlpha c || c `elem` "'_" = False 
+isSymbolName x | (c:_) <- hsIdentString (hsNameIdent (unRename x)), isAlpha c || c `elem` "'_" = False
hunk ./FrontEnd/HsPretty.hs 626
-topLevel header dl = do 
+topLevel header dl = do
hunk ./FrontEnd/HsPretty.hs 628
-	 case e of 
+	 case e of
hunk ./FrontEnd/HsPretty.hs 637
-	 case e of PPOffsideRule -> indent 
+	 case e of PPOffsideRule -> indent
hunk ./FrontEnd/HsPretty.hs 643
-		   indentExplicit = do {i <- fmap f getPPEnv; 
+		   indentExplicit = do {i <- fmap f getPPEnv;
hunk ./FrontEnd/HsPretty.hs 680
-    pprint d = unDocM (ppHsDecl d) defaultMode  
+    pprint d = unDocM (ppHsDecl d) defaultMode
hunk ./FrontEnd/HsPretty.hs 683
-    pprint d = unDocM (ppHsExp d) defaultMode  
+    pprint d = unDocM (ppHsExp d) defaultMode
hunk ./FrontEnd/HsPretty.hs 686
-    pprint d = unDocM (ppHsType d) defaultMode  
+    pprint d = unDocM (ppHsType d) defaultMode
hunk ./FrontEnd/HsPretty.hs 689
-    pprint d = unDocM (ppHsQualType d) defaultMode  
+    pprint d = unDocM (ppHsQualType d) defaultMode
hunk ./FrontEnd/HsSyn.hs 15
-data SrcLoc = SrcLoc { srcLocFileName :: String, srcLocLine :: !Int, srcLocColumn :: !Int} 
+data SrcLoc = SrcLoc { srcLocFileName :: String, srcLocLine :: !Int, srcLocColumn :: !Int}
hunk ./FrontEnd/HsSyn.hs 20
-    deriving(Data,Typeable,Eq,Ord) 
+    deriving(Data,Typeable,Eq,Ord)
hunk ./FrontEnd/HsSyn.hs 26
-instance Monoid SrcLoc where 
+instance Monoid SrcLoc where
hunk ./FrontEnd/HsSyn.hs 28
-    mappend a b 
+    mappend a b
hunk ./FrontEnd/HsSyn.hs 32
-    
+
hunk ./FrontEnd/HsSyn.hs 58
-    show (SrcSpan { srcSpanBegin =  sl1, srcSpanEnd = sl2 } ) = show sl1 ++ "-" ++ show sl2 
+    show (SrcSpan { srcSpanBegin =  sl1, srcSpanEnd = sl2 } ) = show sl1 ++ "-" ++ show sl2
hunk ./FrontEnd/HsSyn.hs 60
-newtype Module = Module String 
+newtype Module = Module String
hunk ./FrontEnd/HsSyn.hs 76
-    toAtom = Atom.fromString . show 
+    toAtom = Atom.fromString . show
hunk ./FrontEnd/HsSyn.hs 79
-   showsPrec _ (Qual (Module m) s) = 
+   showsPrec _ (Qual (Module m) s) =
hunk ./FrontEnd/HsSyn.hs 91
-    
+
hunk ./FrontEnd/HsSyn.hs 111
-data HsModule = HsModule { 
-    hsModuleName :: Module, 
+data HsModule = HsModule {
+    hsModuleName :: Module,
hunk ./FrontEnd/HsSyn.hs 114
-    hsModuleExports :: (Maybe [HsExportSpec]), 
-    hsModuleImports :: [HsImportDecl], 
-    hsModuleDecls :: [HsDecl], 
+    hsModuleExports :: (Maybe [HsExportSpec]),
+    hsModuleImports :: [HsImportDecl],
+    hsModuleDecls :: [HsDecl],
hunk ./FrontEnd/HsSyn.hs 136
-data HsImportDecl = HsImportDecl { 
-    hsImportDeclSrcLoc :: SrcLoc, 
-    hsImportDeclModule :: Module, 
-    hsImportDeclQualified :: !Bool, 
-    hsImportDeclAs :: (Maybe Module), 
-    hsImportDeclSpec :: (Maybe (Bool,[HsImportSpec])) 
+data HsImportDecl = HsImportDecl {
+    hsImportDeclSrcLoc :: SrcLoc,
+    hsImportDeclModule :: Module,
+    hsImportDeclQualified :: !Bool,
+    hsImportDeclAs :: (Maybe Module),
+    hsImportDeclSpec :: (Maybe (Bool,[HsImportSpec]))
hunk ./FrontEnd/HsSyn.hs 190
-data HsMatch 
+data HsMatch
hunk ./FrontEnd/HsSyn.hs 201
-hsConDeclArgs HsRecDecl { hsConDeclRecArg = as } = concat [ replicate (length ns) t | (ns,t) <- as] 
+hsConDeclArgs HsRecDecl { hsConDeclRecArg = as } = concat [ replicate (length ns) t | (ns,t) <- as]
hunk ./FrontEnd/HsSyn.hs 232
-         | HsTyForall { 
-            hsTypeVars :: [HsTyVarBind], 
+         | HsTyForall {
+            hsTypeVars :: [HsTyVarBind],
hunk ./FrontEnd/HsSyn.hs 238
-data HsTyVarBind = HsTyVarBind { 
-    hsTyVarBindSrcLoc :: SrcLoc, 
-    hsTyVarBindName :: HsName, 
+data HsTyVarBind = HsTyVarBind {
+    hsTyVarBindSrcLoc :: SrcLoc,
+    hsTyVarBindName :: HsName,
hunk ./FrontEnd/HsSyn.hs 278
-	= HsVar { {- hsExpSrcSpan :: SrcSpan,-} hsExpName :: HsName } 
+	= HsVar { {- hsExpSrcSpan :: SrcSpan,-} hsExpName :: HsName }
hunk ./FrontEnd/Infix.hs 13
-        Primary Authors:        Lindsay Powles 
+        Primary Authors:        Lindsay Powles
hunk ./FrontEnd/Infix.hs 73
-    
-    
+
+
hunk ./FrontEnd/Infix.hs 78
---infixer infixRules tidyMod = 
+--infixer infixRules tidyMod =
hunk ./FrontEnd/Infix.hs 94
-buildFixityMap ds = FixityMap (Map.fromList $ concatMap f ds)  where 
+buildFixityMap ds = FixityMap (Map.fromList $ concatMap f ds)  where
hunk ./FrontEnd/Infix.hs 97
-        make_key = fromValishHsName 
+        make_key = fromValishHsName
hunk ./FrontEnd/Infix.hs 101
-        
+
hunk ./FrontEnd/Infix.hs 116
-    HsVar qname    -> Map.findWithDefault defaultFixity (toName Val qname) infixMap 
-    HsCon qname    -> Map.findWithDefault defaultFixity (toName DataConstructor qname) infixMap 
+    HsVar qname    -> Map.findWithDefault defaultFixity (toName Val qname) infixMap
+    HsCon qname    -> Map.findWithDefault defaultFixity (toName DataConstructor qname) infixMap
hunk ./FrontEnd/Infix.hs 162
-processGRhs :: SymbolMap -> HsGuardedRhs -> HsGuardedRhs 
+processGRhs :: SymbolMap -> HsGuardedRhs -> HsGuardedRhs
hunk ./FrontEnd/Infix.hs 176
-processGAlts :: SymbolMap -> HsGuardedAlts -> HsGuardedAlts 
+processGAlts :: SymbolMap -> HsGuardedAlts -> HsGuardedAlts
hunk ./FrontEnd/MultiModuleBasics.hs 10
-                                programs. 
+                                programs.
hunk ./FrontEnd/MultiModuleBasics.hs 12
-        Primary Authors:        Bryn Humberstone 
+        Primary Authors:        Bryn Humberstone
hunk ./FrontEnd/MultiModuleBasics.hs 40
-    } 
+    }
hunk ./FrontEnd/MultiModuleBasics.hs 48
- 
+
hunk ./FrontEnd/MultiModuleBasics.hs 54
-    modEnvVarAssumptions :: Env Scheme,          -- used for typechecking 
-    modEnvDConsAssumptions :: Env Scheme,        -- used for typechecking 
+    modEnvVarAssumptions :: Env Scheme,          -- used for typechecking
+    modEnvDConsAssumptions :: Env Scheme,        -- used for typechecking
hunk ./FrontEnd/MultiModuleBasics.hs 62
-    } 
+    }
hunk ./FrontEnd/MultiModuleBasics.hs 66
-emptyModEnv = mempty 
+emptyModEnv = mempty
hunk ./FrontEnd/ParseUtils.hs 7
--- 
+--
hunk ./FrontEnd/ParseUtils.hs 350
-    funName = matchName $ head matches 
+    funName = matchName $ head matches
hunk ./FrontEnd/ParseUtils.hs 356
-matchName (HsMatch _sloc name _pats _rhs _whereDecls) = name 
+matchName (HsMatch _sloc name _pats _rhs _whereDecls) = name
hunk ./FrontEnd/ParseUtils.hs 362
-sameFun name (HsFunBind matches@(_:_)) = name == (matchName $ head matches) 
+sameFun name (HsFunBind matches@(_:_)) = name == (matchName $ head matches)
hunk ./FrontEnd/ParseUtils.hs 367
-collectMatches :: [HsDecl] -> [HsMatch] 
+collectMatches :: [HsDecl] -> [HsMatch]
hunk ./FrontEnd/ParseUtils.hs 372
-        _anythingElse             -> collectMatches ds 
+        _anythingElse             -> collectMatches ds
hunk ./FrontEnd/Representation.hs 91
-instance Show Tyvar where 
-    showsPrec _ Tyvar { tyvarName = hn, tyvarKind = k, tyvarRef = Just _ } = shows hn . (":-" ++) . shows k 
-    showsPrec _ Tyvar { tyvarName = hn, tyvarKind = k } = shows hn . ("::" ++) . shows k 
+instance Show Tyvar where
+    showsPrec _ Tyvar { tyvarName = hn, tyvarKind = k, tyvarRef = Just _ } = shows hn . (":-" ++) . shows k
+    showsPrec _ Tyvar { tyvarName = hn, tyvarKind = k } = shows hn . ("::" ++) . shows k
hunk ./FrontEnd/Representation.hs 95
-findType :: MonadIO m => Type -> m Type 
+findType :: MonadIO m => Type -> m Type
hunk ./FrontEnd/Representation.hs 97
-    rt <- readIORef r 
-    case rt of 
+    rt <- readIORef r
+    case rt of
hunk ./FrontEnd/Representation.hs 108
-    return $ TVar tv { tyvarRef = Just r } 
+    return $ TVar tv { tyvarRef = Just r }
hunk ./FrontEnd/Representation.hs 118
-flattenType :: (FlattenType t, MonadIO m) => t -> m t 
+flattenType :: (FlattenType t, MonadIO m) => t -> m t
hunk ./FrontEnd/Representation.hs 122
-   flattenType' xs = mapM flattenType' xs 
+   flattenType' xs = mapM flattenType' xs
hunk ./FrontEnd/Representation.hs 137
-        tv' <- findType tv 
+        tv' <- findType tv
hunk ./FrontEnd/TIMain.hs 578
-      --liftIO $ mapM (putStrLn .  render . ppHsDecl) bs 
+      --liftIO $ mapM (putStrLn .  render . ppHsDecl) bs
hunk ./FrontEnd/TIMain.hs 694
-     ps <- flattenType ps 
+     ps <- flattenType ps
hunk ./FrontEnd/TIModule.hs 5
-import Class   
+import Class
hunk ./FrontEnd/TIModule.hs 11
-import FrontEnd.Desugar           
+import FrontEnd.Desugar
hunk ./FrontEnd/TIModule.hs 13
-import FrontEnd.Rename     
+import FrontEnd.Rename
hunk ./FrontEnd/TIModule.hs 17
-import HsSyn 
+import HsSyn
hunk ./FrontEnd/TIModule.hs 23
-import MultiModuleBasics  
+import MultiModuleBasics
hunk ./FrontEnd/TIModule.hs 33
-import TIMain             
+import TIMain
hunk ./FrontEnd/TIModule.hs 37
-import Utils 
+import Utils
hunk ./FrontEnd/TIModule.hs 67
-    
+
hunk ./FrontEnd/TIModule.hs 74
-                            
+
hunk ./FrontEnd/TIModule.hs 78
-buildFieldMap :: Ho -> [ModInfo] -> FieldMap 
-buildFieldMap ho ms = (ans',ans) where 
+buildFieldMap :: Ho -> [ModInfo] -> FieldMap
+buildFieldMap ho ms = (ans',ans) where
hunk ./FrontEnd/TIModule.hs 81
-        allDefs = theDefs ++ [ (x,z) | (x,(_,z)) <- Map.toList (hoDefs ho), nameType x == DataConstructor ] 
+        allDefs = theDefs ++ [ (x,z) | (x,(_,z)) <- Map.toList (hoDefs ho), nameType x == DataConstructor ]
hunk ./FrontEnd/TIModule.hs 88
-    when (dump FD.Parsed) $ do 
+    when (dump FD.Parsed) $ do
hunk ./FrontEnd/TIModule.hs 90
-        putStrLn $ HsPretty.render 
-            $ HsPretty.ppHsModule 
-                $ modInfoHsModule m 
+        putStrLn $ HsPretty.render
+            $ HsPretty.ppHsModule
+                $ modInfoHsModule m
hunk ./FrontEnd/TIModule.hs 107
-             putStrLn $ HsPretty.render 
-                      $ HsPretty.ppHsModule 
+             putStrLn $ HsPretty.render
+                      $ HsPretty.ppHsModule
hunk ./FrontEnd/TIModule.hs 112
-    
+
hunk ./FrontEnd/TIModule.hs 117
--- assume all dependencies are met in the 
+-- assume all dependencies are met in the
hunk ./FrontEnd/TIModule.hs 133
-    let thisFixityMap = buildFixityMap (concat [ filter isHsInfixDecl (hsModuleDecls $ modInfoHsModule m) | m <- ms]) 
+    let thisFixityMap = buildFixityMap (concat [ filter isHsInfixDecl (hsModuleDecls $ modInfoHsModule m) | m <- ms])
hunk ./FrontEnd/TIModule.hs 138
-    ms <- mapM f ms 
+    ms <- mapM f ms
hunk ./FrontEnd/TIModule.hs 143
-        putStrLn $ HsPretty.render (HsPretty.ppHsDecls ds) 
-        
+        putStrLn $ HsPretty.render (HsPretty.ppHsDecls ds)
+
hunk ./FrontEnd/TIModule.hs 147
-    let classAndDataDecls = filter (or' [isHsDataDecl, isHsNewTypeDecl, isHsClassDecl]) ds  -- rDataDecls ++ rNewTyDecls ++ rClassDecls  
+    let classAndDataDecls = filter (or' [isHsDataDecl, isHsNewTypeDecl, isHsClassDecl]) ds  -- rDataDecls ++ rNewTyDecls ++ rClassDecls
hunk ./FrontEnd/TIModule.hs 177
-    
+
hunk ./FrontEnd/TIModule.hs 190
-        --ca = listToEnv $ [ (x,y) | (x :>: y) <- myClassAssumps  ++ instAssumps ] 
-        --ca' = listToEnv $ [ (x,y) | (x :>: y) <- myClassAssumps  ] 
-        instanceEnv   = Map.fromList $ [ (x,y) | (x :>: y) <-  instAssumps ] 
+        --ca = listToEnv $ [ (x,y) | (x :>: y) <- myClassAssumps  ++ instAssumps ]
+        --ca' = listToEnv $ [ (x,y) | (x :>: y) <- myClassAssumps  ]
+        instanceEnv   = Map.fromList $ [ (x,y) | (x :>: y) <-  instAssumps ]
hunk ./FrontEnd/TIModule.hs 194
-        classEnv  = Map.fromList $ [ (x,y) | (x :>: y) <- myClassAssumps, x `elem` classDefs  ] 
+        classEnv  = Map.fromList $ [ (x,y) | (x :>: y) <- myClassAssumps, x `elem` classDefs  ]
hunk ./FrontEnd/TIModule.hs 198
-    when (not (null liftedInstances) && (dump FD.Instance) ) $ do 
+    when (not (null liftedInstances) && (dump FD.Instance) ) $ do
hunk ./FrontEnd/TIModule.hs 213
-                                             
+
hunk ./FrontEnd/TIModule.hs 225
-    let programBgs   
+    let programBgs
hunk ./FrontEnd/TIModule.hs 234
-    when (dump FD.Program) $ do 
+    when (dump FD.Program) $ do
hunk ./FrontEnd/TIModule.hs 242
-    let moduleName = modInfoName (head ms) 
-    localVarEnv <- tiProgram 
+    let moduleName = modInfoName (head ms)
+    localVarEnv <- tiProgram
hunk ./FrontEnd/TIModule.hs 248
-                globalDConsEnv                 -- data constructor type environment 
+                globalDConsEnv                 -- data constructor type environment
hunk ./FrontEnd/TIModule.hs 259
-    let externalKindEnv = Map.fromList [ v | v@(x@(Qual m i) ,s) <- Map.toList kindInfo, isGlobal x, m `elem` map modInfoName ms ]  
+    let externalKindEnv = Map.fromList [ v | v@(x@(Qual m i) ,s) <- Map.toList kindInfo, isGlobal x, m `elem` map modInfoName ms ]
hunk ./FrontEnd/TIModule.hs 262
-    
+
hunk ./FrontEnd/TIModule.hs 277
-        
+
hunk ./FrontEnd/TIModule.hs 287
-    let me''' = 
-            addItems modEnvVarAssumptions_u (trimEnv localVarEnv) . 
+    let me''' =
+            addItems modEnvVarAssumptions_u (trimEnv localVarEnv) .
hunk ./FrontEnd/TIModule.hs 290
-            addItems modEnvAllAssumptions_u allAssumps . 
-            addItems modEnvKinds_u (trimMapEnv kindInfo) . 
-            modEnvTypeSynonyms_s ts . --  (++ [ d | d <- ds, isHsTypeDecl d ]) . 
+            addItems modEnvAllAssumptions_u allAssumps .
+            addItems modEnvKinds_u (trimMapEnv kindInfo) .
+            modEnvTypeSynonyms_s ts . --  (++ [ d | d <- ds, isHsTypeDecl d ]) .
hunk ./FrontEnd/TIModule.hs 295
-            --modEnvFixities_u (++ [ d | d <- ds, isHsInfixDecl d ])  
-            modEnvFixities_s fixityMap  
+            --modEnvFixities_u (++ [ d | d <- ds, isHsInfixDecl d ])
+            modEnvFixities_s fixityMap
hunk ./FrontEnd/TIModule.hs 298
-    --let mi = ModuleInfo { varAssumps = localVarEnv, dconsAssumps = localDConsEnv, 
-    --                    classHierarchy = cHierarchyWithInstances, kinds = kindInfo, infixDecls = getInfixDecls mod, 
-    --                    tyconsMembers = getTyconsMembers mod, synonyms = tidyTyDecls tidyMod, 
+    --let mi = ModuleInfo { varAssumps = localVarEnv, dconsAssumps = localDConsEnv,
+    --                    classHierarchy = cHierarchyWithInstances, kinds = kindInfo, infixDecls = getInfixDecls mod,
+    --                    tyconsMembers = getTyconsMembers mod, synonyms = tidyTyDecls tidyMod,
hunk ./FrontEnd/TIModule.hs 318
-    ms <- mapM f ms 
+    ms <- mapM f ms
hunk ./FrontEnd/TIModule.hs 324
-        putStrLn $ HsPretty.render (HsPretty.ppHsDecls ds) 
-        
+        putStrLn $ HsPretty.render (HsPretty.ppHsDecls ds)
+
hunk ./FrontEnd/TIModule.hs 328
-    let classAndDataDecls = filter (or' [isHsDataDecl, isHsNewTypeDecl, isHsClassDecl]) ds  -- rDataDecls ++ rNewTyDecls ++ rClassDecls  
+    let classAndDataDecls = filter (or' [isHsDataDecl, isHsNewTypeDecl, isHsClassDecl]) ds  -- rDataDecls ++ rNewTyDecls ++ rClassDecls
hunk ./FrontEnd/TIModule.hs 367
-        --ca = listToEnv $ [ (x,y) | (x :>: y) <- myClassAssumps  ++ instAssumps ] 
-        --ca' = listToEnv $ [ (x,y) | (x :>: y) <- myClassAssumps  ] 
-        instanceEnv   = Map.fromList $ [ (x,y) | (x :>: y) <-  instAssumps ] 
+        --ca = listToEnv $ [ (x,y) | (x :>: y) <- myClassAssumps  ++ instAssumps ]
+        --ca' = listToEnv $ [ (x,y) | (x :>: y) <- myClassAssumps  ]
+        instanceEnv   = Map.fromList $ [ (x,y) | (x :>: y) <-  instAssumps ]
hunk ./FrontEnd/TIModule.hs 371
-        classEnv  = Map.fromList $ [ (x,y) | (x :>: y) <- myClassAssumps, x `elem` classDefs  ] 
+        classEnv  = Map.fromList $ [ (x,y) | (x :>: y) <- myClassAssumps, x `elem` classDefs  ]
hunk ./FrontEnd/TIModule.hs 375
-    when (not (null liftedInstances) && (dump FD.Instance) ) $ do 
+    when (not (null liftedInstances) && (dump FD.Instance) ) $ do
hunk ./FrontEnd/TIModule.hs 390
-                                             
+
hunk ./FrontEnd/TIModule.hs 402
-    let programBgs   
+    let programBgs
hunk ./FrontEnd/TIModule.hs 411
-    when (dump FD.Program) $ do 
+    when (dump FD.Program) $ do
hunk ./FrontEnd/TIModule.hs 419
-    let moduleName = modInfoName (head ms) 
-    localVarEnv <- tiProgram 
+    let moduleName = modInfoName (head ms)
+    localVarEnv <- tiProgram
hunk ./FrontEnd/TIModule.hs 425
-                globalDConsEnv                 -- data constructor type environment 
+                globalDConsEnv                 -- data constructor type environment
hunk ./FrontEnd/TIModule.hs 435
-    
+
hunk ./FrontEnd/TIModule.hs 437
-    let me''' = 
-            addItems modEnvVarAssumptions_u (trimEnv localVarEnv) . 
+    let me''' =
+            addItems modEnvVarAssumptions_u (trimEnv localVarEnv) .
hunk ./FrontEnd/TIModule.hs 440
-            addItems modEnvAllAssumptions_u allAssumps . 
-            addItems modEnvKinds_u (trimMapEnv kindInfo) . 
-            modEnvTypeSynonyms_s ts . --  (++ [ d | d <- ds, isHsTypeDecl d ]) . 
+            addItems modEnvAllAssumptions_u allAssumps .
+            addItems modEnvKinds_u (trimMapEnv kindInfo) .
+            modEnvTypeSynonyms_s ts . --  (++ [ d | d <- ds, isHsTypeDecl d ]) .
hunk ./FrontEnd/TIModule.hs 445
-            --modEnvFixities_u (++ [ d | d <- ds, isHsInfixDecl d ])  
-            modEnvFixities_s fixityMap  
+            --modEnvFixities_u (++ [ d | d <- ds, isHsInfixDecl d ])
+            modEnvFixities_s fixityMap
hunk ./FrontEnd/TIModule.hs 448
-    --let mi = ModuleInfo { varAssumps = localVarEnv, dconsAssumps = localDConsEnv, 
-    --                    classHierarchy = cHierarchyWithInstances, kinds = kindInfo, infixDecls = getInfixDecls mod, 
-    --                    tyconsMembers = getTyconsMembers mod, synonyms = tidyTyDecls tidyMod, 
+    --let mi = ModuleInfo { varAssumps = localVarEnv, dconsAssumps = localDConsEnv,
+    --                    classHierarchy = cHierarchyWithInstances, kinds = kindInfo, infixDecls = getInfixDecls mod,
+    --                    tyconsMembers = getTyconsMembers mod, synonyms = tidyTyDecls tidyMod,
hunk ./FrontEnd/TIModule.hs 453
-    
+
hunk ./FrontEnd/TIModule.hs 456
-    
+
hunk ./FrontEnd/TIModule.hs 459
-tiModule dumps modSyntax imports = do 
+tiModule dumps modSyntax imports = do
hunk ./FrontEnd/TIModule.hs 473
-             putStrLn $ HsPretty.render 
-                      $ HsPretty.ppHsModule 
+             putStrLn $ HsPretty.render
+                      $ HsPretty.ppHsModule
hunk ./FrontEnd/TIModule.hs 478
-        -- TODO: we probably need to worry about synonyms and 
+        -- TODO: we probably need to worry about synonyms and
hunk ./FrontEnd/TIModule.hs 481
-    let 
-        importVarEnv' = trimEnv $ importVarEnv 
+    let
+        importVarEnv' = trimEnv $ importVarEnv
hunk ./FrontEnd/TIModule.hs 485
-    let importedNames = getNamesFromEnv importVarEnv' 
+    let importedNames = getNamesFromEnv importVarEnv'
hunk ./FrontEnd/TIModule.hs 488
-                     ++ getNamesFromEnv importClassHierarchy 
+                     ++ getNamesFromEnv importClassHierarchy
hunk ./FrontEnd/TIModule.hs 490
-                     ++ getNamesFromEnv importKindEnv         
+                     ++ getNamesFromEnv importKindEnv
hunk ./FrontEnd/TIModule.hs 497
-        getNamesFromTycons = concatMap snd 
+        getNamesFromTycons = concatMap snd
hunk ./FrontEnd/TIModule.hs 508
-             putStrLn $ HsPretty.render 
-                      $ HsPretty.ppHsModule 
+             putStrLn $ HsPretty.render
+                      $ HsPretty.ppHsModule
hunk ./FrontEnd/TIModule.hs 517
-             putStrLn $ HsPretty.render 
-                      $ HsPretty.ppHsModule 
+             putStrLn $ HsPretty.render
+                      $ HsPretty.ppHsModule
hunk ./FrontEnd/TIModule.hs 523
-    let --rTyDecls    = tidyTyDecls    renamedTidyModule 
-        rDataDecls  = tidyDataDecls  renamedTidyModule 
-        rNewTyDecls = tidyNewTyDecls renamedTidyModule 
-        rClassDecls = tidyClassDecls renamedTidyModule 
-        rInstDecls  = tidyInstDecls  renamedTidyModule 
-        rTySigs     = tidyTySigs     renamedTidyModule 
-        rFunBinds   = tidyFunBinds   renamedTidyModule 
-        rPatBinds   = tidyPatBinds   renamedTidyModule 
+    let --rTyDecls    = tidyTyDecls    renamedTidyModule
+        rDataDecls  = tidyDataDecls  renamedTidyModule
+        rNewTyDecls = tidyNewTyDecls renamedTidyModule
+        rClassDecls = tidyClassDecls renamedTidyModule
+        rInstDecls  = tidyInstDecls  renamedTidyModule
+        rTySigs     = tidyTySigs     renamedTidyModule
+        rFunBinds   = tidyFunBinds   renamedTidyModule
+        rPatBinds   = tidyPatBinds   renamedTidyModule
hunk ./FrontEnd/TIModule.hs 539
-    let classAndDataDecls = rDataDecls ++ rNewTyDecls ++ rClassDecls 
+    let classAndDataDecls = rDataDecls ++ rNewTyDecls ++ rClassDecls
hunk ./FrontEnd/TIModule.hs 562
-    let cHierarchyWithInstances 
+    let cHierarchyWithInstances
hunk ./FrontEnd/TIModule.hs 571
-        ca = listToEnv $ [ (x,y) | (x :>: y) <- myClassAssumps  ++ instAssumps ] 
+        ca = listToEnv $ [ (x,y) | (x :>: y) <- myClassAssumps  ++ instAssumps ]
hunk ./FrontEnd/TIModule.hs 578
-           putStr $ unlines $ 
+           putStr $ unlines $
hunk ./FrontEnd/TIModule.hs 589
-                                             
+
hunk ./FrontEnd/TIModule.hs 593
-    let programBgs 
+    let programBgs
hunk ./FrontEnd/TIModule.hs 595
-           
+
hunk ./FrontEnd/TIModule.hs 613
-    let localVarEnv = tiProgram 
+    let localVarEnv = tiProgram
hunk ./FrontEnd/TIModule.hs 618
-                globalDConsEnv                 -- data constructor type environment 
+                globalDConsEnv                 -- data constructor type environment
hunk ./FrontEnd/TIModule.hs 629
-    let mi = ModuleInfo { varAssumps = localVarEnv, dconsAssumps = localDConsEnv, 
-                        classHierarchy = cHierarchyWithInstances, kinds = kindInfo, infixDecls = getInfixDecls mod, 
-                        tyconsMembers = getTyconsMembers mod, synonyms = tidyTyDecls tidyMod, 
+    let mi = ModuleInfo { varAssumps = localVarEnv, dconsAssumps = localDConsEnv,
+                        classHierarchy = cHierarchyWithInstances, kinds = kindInfo, infixDecls = getInfixDecls mod,
+                        tyconsMembers = getTyconsMembers mod, synonyms = tidyTyDecls tidyMod,
hunk ./FrontEnd/TIMonad.hs 169
-unify t1 t2 = do 
+unify t1 t2 = do
hunk ./FrontEnd/TIMonad.hs 172
-    b <- mgu t1' t2' 
-    case b of 
+    b <- mgu t1' t2'
+    case b of
hunk ./FrontEnd/TIMonad.hs 184
---s <- getSubst            
---let t1' = apply s t1     
---    t2' = apply s t2     
+--s <- getSubst
+--let t1' = apply s t1
+--    t2' = apply s t2
hunk ./FrontEnd/TIMonad.hs 209
-extSubst s = sequence_ [ do y' <- findType y ; liftIO $ writeIORef r (Just y') | (Tyvar { tyvarRef = ~(Just r)} ,y) <- Map.toList s] 
+extSubst s = sequence_ [ do y' <- findType y ; liftIO $ writeIORef r (Just y') | (Tyvar { tyvarRef = ~(Just r)} ,y) <- Map.toList s]
hunk ./FrontEnd/Type.hs 163
-    case r of 
+    case r of
hunk ./FrontEnd/Type.hs 166
-    
+
hunk ./FrontEnd/TypeSigs.hs 28
-import HsSyn  
+import HsSyn
hunk ./FrontEnd/TypeSigs.hs 45
-   = collectSigsFromRhs rhs ++ 
-     collectSigsFromDecls wheres ++ 
+   = collectSigsFromRhs rhs ++
+     collectSigsFromDecls wheres ++
hunk ./FrontEnd/TypeSigs.hs 70
-collectSigsFromGuardedRhs :: (HsGuardedRhs) -> [(HsDecl)] 
+collectSigsFromGuardedRhs :: (HsGuardedRhs) -> [(HsDecl)]
hunk ./FrontEnd/TypeSigs.hs 107
-     collectSigsFromExp e3 
+     collectSigsFromExp e3
hunk ./FrontEnd/TypeSigs.hs 203
-   = Map.fromList $ 
+   = Map.fromList $
hunk ./FrontEnd/TypeSigs.hs 206
-        
+
hunk ./FrontEnd/TypeSynonyms.hs 8
-import HsSyn  
+import HsSyn
hunk ./FrontEnd/TypeSynonyms.hs 24
-    deriving(Monoid,Binary,HasSize) 
+    deriving(Monoid,Binary,HasSize)
hunk ./FrontEnd/TypeSynonyms.hs 26
--- | convert a set of type synonym declarations to a synonym map used for efficient synonym 
+-- | convert a set of type synonym declarations to a synonym map used for efficient synonym
hunk ./FrontEnd/TypeSynonyms.hs 28
- 
-declsToTypeSynonyms :: [HsDecl] -> TypeSynonyms         
+
+declsToTypeSynonyms :: [HsDecl] -> TypeSynonyms
hunk ./FrontEnd/TypeSynonyms.hs 31
- 
+
hunk ./FrontEnd/TypeSynonyms.hs 36
-quantifyHsType :: [HsName] -> HsQualType -> HsType 
-quantifyHsType inscope t 
-  | null vs, null (hsQualTypeHsContext t) = hsQualTypeType t 
+quantifyHsType :: [HsName] -> HsQualType -> HsType
+quantifyHsType inscope t
+  | null vs, null (hsQualTypeHsContext t) = hsQualTypeType t
hunk ./FrontEnd/TypeSynonyms.hs 43
-    fv (HsTyForall vs qt) = tell $ snub (execWriter (fv $ hsQualTypeType qt)) \\ map hsTyVarBindName vs 
+    fv (HsTyForall vs qt) = tell $ snub (execWriter (fv $ hsQualTypeType qt)) \\ map hsTyVarBindName vs
hunk ./FrontEnd/TypeSynonyms.hs 54
-          else do 
-            eval (drop (length args) stack) (subst (Map.fromList [(a,s) | a <- args | s <- stack]) t)  
-    eval stack (HsTyApp t1 t2) = eval (t2:stack) t1 
+          else do
+            eval (drop (length args) stack) (subst (Map.fromList [(a,s) | a <- args | s <- stack]) t)
+    eval stack (HsTyApp t1 t2) = eval (t2:stack) t1
hunk ./FrontEnd/TypeSynonyms.hs 64
-    subst sm (HsTyForall vs t) = HsTyForall vs  t { hsQualTypeType =  subst (foldr ($) sm (map (\v m -> Map.delete (hsTyVarBindName v) m) vs)) (hsQualTypeType t) } 
+    subst sm (HsTyForall vs t) = HsTyForall vs  t { hsQualTypeType =  subst (foldr ($) sm (map (\v m -> Map.delete (hsTyVarBindName v) m) vs)) (hsQualTypeType t) }
hunk ./FrontEnd/TypeSyns.hs 1
-module TypeSyns( expandTypeSyns ) where 
+module TypeSyns( expandTypeSyns ) where
hunk ./FrontEnd/TypeSyns.hs 6
-import Char        
-import Utils     
+import Char
+import Utils
hunk ./FrontEnd/TypeSyns.hs 28
-data ScopeState = ScopeState {  
+data ScopeState = ScopeState {
hunk ./FrontEnd/TypeSyns.hs 33
-    } 
+    }
hunk ./FrontEnd/TypeSyns.hs 36
-type ScopeSM = State ScopeState 
+type ScopeSM = State ScopeState
hunk ./FrontEnd/TypeSyns.hs 47
-setSrcLoc e = modify (\s -> s { srcLoc = e `mappend` srcLoc s}) 
+setSrcLoc e = modify (\s -> s { srcLoc = e `mappend` srcLoc s})
hunk ./FrontEnd/TypeSyns.hs 52
-    startState = ScopeState { 
+    startState = ScopeState {
hunk ./FrontEnd/TypeSyns.hs 59
-    (rm, _) = runState (renameDecls m) startState 
+    (rm, _) = runState (renameDecls m) startState
hunk ./FrontEnd/TypeSyns.hs 74
-     
+
hunk ./FrontEnd/TypeSyns.hs 78
-renameHsDecls decls subtable = do 
+renameHsDecls decls subtable = do
hunk ./FrontEnd/TypeSyns.hs 96
-      
+
hunk ./FrontEnd/TypeSyns.hs 179
-    return (HsConDecl srcLoc hsName' hsBangTypes') 
+    return (HsConDecl srcLoc hsName' hsBangTypes')
hunk ./FrontEnd/TypeSyns.hs 215
-    rt v@(HsTyVar _) _   = return v 
+    rt v@(HsTyVar _) _   = return v
hunk ./FrontEnd/TypeSyns.hs 217
-        hsName' <- renameTypeHsName hsName subTable 
+        hsName' <- renameTypeHsName hsName subTable
hunk ./FrontEnd/TypeSyns.hs 251
-renameHsPat :: HsPat -> SubTable -> ScopeSM (HsPat) 
+renameHsPat :: HsPat -> SubTable -> ScopeSM (HsPat)
hunk ./FrontEnd/TypeSyns.hs 343
-    return (HsCon hsName') 
+    return (HsCon hsName')
hunk ./FrontEnd/TypeSyns.hs 440
-    return (HsListComp hsExp' hsStmts')     
+    return (HsListComp hsExp' hsStmts')
hunk ./FrontEnd/TypeSyns.hs 540
--- Regardless of whether the name is found, if it's not qualified 
--- it will be qualified with the current module's prefix. 
+-- Regardless of whether the name is found, if it's not qualified
+-- it will be qualified with the current module's prefix.
hunk ./FrontEnd/TypeSyns.hs 544
+
hunk ./FrontEnd/TypeSyns.hs 546
-    
hunk ./FrontEnd/TypeSyns.hs 559
--- renamed name to its source location and binding type 
+-- renamed name to its source location and binding type
hunk ./FrontEnd/TypeSyns.hs 587
-      subTable'  <- clobberHsName  hsName  subTable 
+      subTable'  <- clobberHsName  hsName  subTable
hunk ./FrontEnd/TypeSyns.hs 604
--- renames a haskell name with its unique number 
+-- renames a haskell name with its unique number
hunk ./FrontEnd/TypeSyns.hs 608
--- unRename gets the original identifier name 
+-- unRename gets the original identifier name
hunk ./FrontEnd/TypeSyns.hs 616
-                      Qual mod i -> Qual mod $ unrenameIdent i 
+                      Qual mod i -> Qual mod $ unrenameIdent i
hunk ./FrontEnd/TypeSyns.hs 622
-isRenamed (UnQual i)    = isIdentRenamed i 
-isRenamed (Qual _mod i) = isIdentRenamed i 
+isRenamed (UnQual i)    = isIdentRenamed i
+isRenamed (Qual _mod i) = isIdentRenamed i
hunk ./FrontEnd/TypeSyns.hs 704
-      subTable'' <- updateSubTableWithClasses subTable' hsDecls 
+      subTable'' <- updateSubTableWithClasses subTable' hsDecls
hunk ./FrontEnd/TypeSyns.hs 712
-  = error $ "non simple pattern binding found (sloc): " ++ show sloc 
+  = error $ "non simple pattern binding found (sloc): " ++ show sloc
hunk ./FrontEnd/TypeSyns.hs 714
-getHsNamesAndASrcLocsFromHsDecl (HsFunBind hsMatches) = getHsNamesAndASrcLocsFromHsMatches hsMatches     
+getHsNamesAndASrcLocsFromHsDecl (HsFunBind hsMatches) = getHsNamesAndASrcLocsFromHsMatches hsMatches
hunk ./FrontEnd/TypeSyns.hs 729
-    g (b,n,sl,ns) = (b,mod n, sl, map mod ns) 
+    g (b,n,sl,ns) = (b,mod n, sl, map mod ns)
hunk ./FrontEnd/TypeSyns.hs 736
-    f (HsDataDecl sl _ n _ cs _) = tell $ (True,n,sl,fsts cs'):[ (False,n,sl,[]) | (n,sl) <- cs'] where 
+    f (HsDataDecl sl _ n _ cs _) = tell $ (True,n,sl,fsts cs'):[ (False,n,sl,[]) | (n,sl) <- cs'] where
hunk ./FrontEnd/TypeSyns.hs 738
-    f (HsNewTypeDecl sl _ n _ c _) =  tell $ (True,n,sl,fsts cs'):[ (False,n,sl,[]) | (n,sl) <- cs'] where 
+    f (HsNewTypeDecl sl _ n _ c _) =  tell $ (True,n,sl,fsts cs'):[ (False,n,sl,[]) | (n,sl) <- cs'] where
hunk ./FrontEnd/TypeSyns.hs 741
-        Just z = maybeGetDeclName cd    
+        Just z = maybeGetDeclName cd
hunk ./FrontEnd/TypeSyns.hs 758
-namesHsDeclTS (HsTypeSig sl ns _) = ((map (rtup sl) ns),[])  
+namesHsDeclTS (HsTypeSig sl ns _) = ((map (rtup sl) ns),[])
hunk ./FrontEnd/TypeSyns.hs 761
-namesHsConDecl c = (hsConDeclName c,hsConDeclSrcLoc c) : case c of 
-    HsRecDecl { hsConDeclRecArg = ra } -> concatMap (map (rtup (hsConDeclSrcLoc c)) . fst) ra 
+namesHsConDecl c = (hsConDeclName c,hsConDeclSrcLoc c) : case c of
+    HsRecDecl { hsConDeclRecArg = ra } -> concatMap (map (rtup (hsConDeclSrcLoc c)) . fst) ra
hunk ./FrontEnd/TypeSyns.hs 929
-                HsAssocNone 
+                HsAssocNone
hunk ./FrontEnd/TypeSyns.hs 931
-                HsAssocLeft 
+                HsAssocLeft
hunk ./FrontEnd/TypeSyns.hs 933
-                HsAssocRight 
+                HsAssocRight
hunk ./FrontEnd/TypeSyns.hs 1044
-            HsVar  name -> HsVar (replaceName f name) 
+            HsVar  name -> HsVar (replaceName f name)
hunk ./FrontEnd/TypeSyns.hs 1046
-                HsCon  # name 
+                HsCon  # name
hunk ./FrontEnd/TypeSyns.hs 1123
-                HsPWildCard 
+                HsPWildCard
hunk ./FrontEnd/TypeSyns.hs 1188
-instance Renameable HsName where 
+instance Renameable HsName where
hunk ./FrontEnd/TypeSyns.hs 1198
-type IdentTable = FiniteMap HsName (SrcLoc, Binding) 
+type IdentTable = FiniteMap HsName (SrcLoc, Binding)
hunk ./FrontEnd/TypeSyns.hs 1216
-   = putStr $ unlines $ map showIdentTabEntry $ toListFM idt 
+   = putStr $ unlines $ map showIdentTabEntry $ toListFM idt
hunk ./FrontEnd/TypeSyns.hs 1219
-   showIdentTabEntry (name, (SrcLoc fn row col, bind)) 
-      = lJustify 40 (fromHsName name) ++ 
-        fn ++ ":" ++ showPos (row, col) ++ 
+   showIdentTabEntry (name, (SrcLoc fn row col, bind))
+      = lJustify 40 (fromHsName name) ++
+        fn ++ ":" ++ showPos (row, col) ++
hunk ./FrontEnd/TypeSyns.hs 1224
-      | row < 0 || col < 0 = rJustify 10 "none" 
-      | otherwise          = rJustify 10 $ show pos 
+      | row < 0 || col < 0 = rJustify 10 "none"
+      | otherwise          = rJustify 10 $ show pos
hunk ./FrontEnd/TypeSyns.hs 1231
-   = case lookupFM idtab i of 
+   = case lookupFM idtab i of
hunk ./FrontEnd/Warning.hs 37
-    sl <- getSrcLoc 
-    warn sl t m 
+    sl <- getSrcLoc
+    warn sl t m
hunk ./FrontEnd/Warning.hs 45
-pad n s = case length s of 
+pad n s = case length s of
hunk ./FrontEnd/Warning.hs 47
-    x -> s ++ replicate (n - x) ' ' 
+    x -> s ++ replicate (n - x) ' '
hunk ./FrontEnd/Warning.hs 51
-    ws <- readIORef ioWarnings 
+    ws <- readIORef ioWarnings
hunk ./FrontEnd/Warning.hs 58
-    s Warning { warnSrcLoc = sl, warnType = t, warnMessage = m } | sl == bogusASrcLoc = putErrLn $ msg t m 
-    s Warning { warnSrcLoc = SrcLoc { srcLocFileName = fn, srcLocLine = -1 }, warnType = t ,warnMessage = m } = 
+    s Warning { warnSrcLoc = sl, warnType = t, warnMessage = m } | sl == bogusASrcLoc = putErrLn $ msg t m
+    s Warning { warnSrcLoc = SrcLoc { srcLocFileName = fn, srcLocLine = -1 }, warnType = t ,warnMessage = m } =
hunk ./FrontEnd/Warning.hs 61
-    s Warning { warnSrcLoc = SrcLoc { srcLocFileName = fn, srcLocLine = l }, warnType = t ,warnMessage = m } = 
+    s Warning { warnSrcLoc = SrcLoc { srcLocFileName = fn, srcLocLine = l }, warnType = t ,warnMessage = m } =
hunk ./FrontEnd/Warning.hs 65
-fatal = ["undefined-name", "ambiguous-name", "multiply-defined", 
+fatal = ["undefined-name", "ambiguous-name", "multiply-defined",
hunk ./FrontEnd/Warning.hs 69
-instance Show Warning where 
-    show  Warning { warnSrcLoc = sl, warnType = t, warnMessage = m } | sl == bogusASrcLoc =  msg t m 
-    show  Warning { warnSrcLoc = SrcLoc { srcLocFileName = fn, srcLocLine = l }, warnType = t ,warnMessage = m } = 
+instance Show Warning where
+    show  Warning { warnSrcLoc = sl, warnType = t, warnMessage = m } | sl == bogusASrcLoc =  msg t m
+    show  Warning { warnSrcLoc = SrcLoc { srcLocFileName = fn, srcLocLine = l }, warnType = t ,warnMessage = m } =
hunk ./GraphUtil.hs 6
-import qualified Data.Graph 
+import qualified Data.Graph
hunk ./GraphUtil.hs 14
-data Graph n k = Graph Data.Graph.Graph (Vertex -> n) (k -> Maybe Vertex) (n -> k)    
+data Graph n k = Graph Data.Graph.Graph (Vertex -> n) (k -> Maybe Vertex) (n -> k)
hunk ./GraphUtil.hs 23
-    --kv a = Map.lookup a $ Map.fromList $  zip (sort $ map fn ns) [0..] 
+    --kv a = Map.lookup a $ Map.fromList $  zip (sort $ map fn ns) [0..]
hunk ./GraphUtil.hs 30
-findLoopBreakers :: 
+findLoopBreakers ::
hunk ./GraphUtil.hs 35
-    scc = Data.Graph.scc g 
-    ans = f g scc [] [] where 
+    scc = Data.Graph.scc g
+    ans = f g scc [] [] where
hunk ./GraphUtil.hs 40
-            
+
hunk ./GraphUtil.hs 42
-            ((mv,_):_) = sortBy (\ a b -> compare (snd b) (snd a)) [ (v,func (ln v)) | v <- ns]  
+            ((mv,_):_) = sortBy (\ a b -> compare (snd b) (snd a)) [ (v,func (ln v)) | v <- ns]
hunk ./GraphUtil.hs 45
-            ng = fmap (List.delete mv) g 
-            
-        f _ [] xs lb = (map (ln . head) (group $ sort lb),reverse $ map ln xs) 
+            ng = fmap (List.delete mv) g
+
+        f _ [] xs lb = (map (ln . head) (group $ sort lb),reverse $ map ln xs)
hunk ./GraphUtil.hs 49
-        
+
hunk ./GraphUtil.hs 53
-    
+
hunk ./GraphUtil.hs 61
-    decode other = Right (dec other []) 
+    decode other = Right (dec other [])
hunk ./GraphUtil.hs 70
-topSort (Graph g ln _ _) = map ln $ Data.Graph.topSort g 
+topSort (Graph g ln _ _) = map ln $ Data.Graph.topSort g
hunk ./GraphUtil.hs 73
-cyclicNodes g = concat [ xs | Right xs <- GraphUtil.scc g] 
+cyclicNodes g = concat [ xs | Right xs <- GraphUtil.scc g]
hunk ./Grin/DeadFunctions.hs 1
-module Grin.DeadFunctions(deadFunctions) where 
+module Grin.DeadFunctions(deadFunctions) where
hunk ./Grin/DeadFunctions.hs 14
-import Grin.Whiz 
+import Grin.Whiz
hunk ./Grin/DeadFunctions.hs 23
-concatMapM f xs = liftM concat $ mapM f xs 
+concatMapM f xs = liftM concat $ mapM f xs
hunk ./Grin/DeadFunctions.hs 29
-    mempty = Unused 
+    mempty = Unused
hunk ./Grin/DeadFunctions.hs 43
-    functionCalls :: [Atom] 
+    functionCalls :: [Atom]
hunk ./Grin/DeadFunctions.hs 77
-        ef =  concatMap tagToFunction  (freeVars (nc)) 
+        ef =  concatMap tagToFunction  (freeVars (nc))
hunk ./Grin/DeadFunctions.hs 86
-deadFunctions :: 
+deadFunctions ::
hunk ./Grin/DeadFunctions.hs 89
-    -> [Atom]  -- ^ roots 
-    -> Grin    -- ^ input 
+    -> [Atom]  -- ^ roots
+    -> Grin    -- ^ input
hunk ./Grin/DeadFunctions.hs 94
-        reach = [ x|  (x,_,_) <- map lv $ snub $ concatMap (reachable graph) (map la keeps)]  
-        rs = Set.fromList (map functionName reach) 
+        reach = [ x|  (x,_,_) <- map lv $ snub $ concatMap (reachable graph) (map la keeps)]
+        rs = Set.fromList (map functionName reach)
hunk ./Grin/DeadFunctions.hs 103
-    replicateM_ (length (grinFunctions grin) - length reach) $ tick stats $ (toAtom "Optimize.dead-function") 
+    replicateM_ (length (grinFunctions grin) - length reach) $ tick stats $ (toAtom "Optimize.dead-function")
hunk ./Grin/DeadFunctions.hs 105
-    --CharIO.print [ a | (a,_) <- grinFunctions grin, not $ a `Set.member` rs ] 
-    --mapM cleanupDeadArgs 
+    --CharIO.print [ a | (a,_) <- grinFunctions grin, not $ a `Set.member` rs ]
+    --mapM cleanupDeadArgs
hunk ./Grin/DeadFunctions.hs 111
-        replicateM_ (length uuc) $ tick stats $ (toAtom "Optimize.caf-cleanup") 
+        replicateM_ (length uuc) $ tick stats $ (toAtom "Optimize.caf-cleanup")
hunk ./Grin/DeadFunctions.hs 115
-    reach <- findDeadCode stats  reach 
-        
+    reach <- findDeadCode stats  reach
+
hunk ./Grin/DeadFunctions.hs 122
-class  FixIn b a | b -> a where 
+class  FixIn b a | b -> a where
hunk ./Grin/DeadFunctions.hs 128
-findFixpoint :: (Show a,Ord a,Eq b,Monoid b) => Maybe String -> (x -> a) -> ((a -> Ms b b) -> x -> Ms b b) -> [x] -> IO [(x,b)]  
+findFixpoint :: (Show a,Ord a,Eq b,Monoid b) => Maybe String -> (x -> a) -> ((a -> Ms b b) -> x -> Ms b b) -> [x] -> IO [(x,b)]
hunk ./Grin/DeadFunctions.hs 136
-    f a | otherwise = error $ "findFixpoint: Cannot find " ++ show a 
-    is = map (fn f) xs 
-    
-    
-    
+    f a | otherwise = error $ "findFixpoint: Cannot find " ++ show a
+    is = map (fn f) xs
+
+
+
hunk ./Grin/DeadFunctions.hs 142
-findDeadCode stats fs = ans where 
+findDeadCode stats fs = ans where
hunk ./Grin/DeadFunctions.hs 149
-            z f@(FunctionInfo { functionUnusedArgs = [] }) = f 
-        return $ map z fs 
+            z f@(FunctionInfo { functionUnusedArgs = [] }) = f
+        return $ map z fs
hunk ./Grin/DeadFunctions.hs 160
-        rs' (x,False) 
+        rs' (x,False)
hunk ./Grin/DeadFunctions.hs 164
-    
+
hunk ./Grin/DeadFunctions.hs 173
-        as <- dff fn' as 
+        as <- dff fn' as
hunk ./Grin/DeadFunctions.hs 176
-        as <- dff fn' as 
+        as <- dff fn' as
hunk ./Grin/DeadFunctions.hs 179
-        as <- dff fn' as 
+        as <- dff fn' as
hunk ./Grin/DeadFunctions.hs 183
-        xs = lup fn 
+        xs = lup fn
hunk ./Grin/DeadFunctions.hs 193
-    
-groupConcatFst xs = [ (x,mconcat $ snds xs) | (x,xs) <- sortGroupUnderF fst xs] 
-        
+
+groupConcatFst xs = [ (x,mconcat $ snds xs) | (x,xs) <- sortGroupUnderF fst xs]
+
hunk ./Grin/DeadFunctions.hs 198
-collectArgInfo exp@(Tup as :-> _) = ans where   
-    ws = Map.fromList $ groupConcatFst $ Seq.toList $ execWriter (whizExps f exp) 
-    lv x = case Map.lookup x ws of 
+collectArgInfo exp@(Tup as :-> _) = ans where
+    ws = Map.fromList $ groupConcatFst $ Seq.toList $ execWriter (whizExps f exp)
+    lv x = case Map.lookup x ws of
hunk ./Grin/DeadFunctions.hs 204
-    f e = g e >> return e 
+    f e = g e >> return e
hunk ./Grin/DeadFunctions.hs 214
-    
-    
+
+
hunk ./Grin/EvalInline.hs 2
-    createEval, 
+    createEval,
hunk ./Grin/EvalInline.hs 13
-data UpdateType = NoUpdate | TrailingUpdate | HoistedUpdate Val 
+data UpdateType = NoUpdate | TrailingUpdate | HoistedUpdate Val
hunk ./Grin/EvalInline.hs 32
-        Case n2 cs 
+        Case n2 cs
hunk ./Grin/Fizz.hs 32
-fizz :: Monad m => 
+fizz :: Monad m =>
hunk ./Grin/Fizz.hs 39
-whiz sub te tf inState start = res where 
-    res = runStateT (dc mempty start) inState 
+whiz sub te tf inState start = res where
+    res = runStateT (dc mempty start) inState
hunk ./Grin/Fizz.hs 43
-        Return (Tup xs) <- g env a 
+        Return (Tup xs) <- g env a
hunk ./Grin/Fizz.hs 45
-        ts <- lift $ mapM te [(y,Return x) | x <- xs | y <- ys ] 
+        ts <- lift $ mapM te [(y,Return x) | x <- xs | y <- ys ]
hunk ./Grin/Fizz.hs 54
-        z <- f b xs (env' `mappend` env) 
-        case x of 
-            Just (p',a') -> do 
+        z <- f b xs (env' `mappend` env)
+        case x of
+            Just (p',a') -> do
hunk ./Grin/Fizz.hs 67
-    g env x = applySubstE env x 
+    g env x = applySubstE env x
hunk ./Grin/Fizz.hs 75
-        
hunk ./Grin/Fizz.hs 78
-applySubstE env x = f x where 
+
+applySubstE env x = f x where
hunk ./Grin/Fizz.hs 101
-    f (Cast v t) = do 
+    f (Cast v t) = do
hunk ./Grin/Fizz.hs 104
-    f (Case e as) = do 
+    f (Case e as) = do
hunk ./Grin/Fizz.hs 123
-    f Addr {} = error "Address in subst" 
+    f Addr {} = error "Address in subst"
hunk ./Grin/Fizz.hs 126
-renamePattern :: MonadState (WhizState) m => Val ->  m (Val,WhizEnv) 
+renamePattern :: MonadState (WhizState) m => Val ->  m (Val,WhizEnv)
hunk ./Grin/Fizz.hs 130
-        v' <- lift $ newVarName v 
+        v' <- lift $ newVarName v
hunk ./Grin/Fizz.hs 145
-    f Addr {} = error "Address in pattern" 
+    f Addr {} = error "Address in pattern"
hunk ./Grin/Fizz.hs 150
-    s <- get 
-    case s of 
+    s <- get
+    case s of
hunk ./Grin/Fizz.hs 161
-    
+
hunk ./Grin/FromE.hs 59
-    scMap :: Map Int (Atom,[Ty],Ty), 
+    scMap :: Map Int (Atom,[Ty],Ty),
hunk ./Grin/FromE.hs 61
-    tyEnv :: IORef TyEnv, 
+    tyEnv :: IORef TyEnv,
hunk ./Grin/FromE.hs 78
-partialLadder t 
+partialLadder t
hunk ./Grin/FromE.hs 87
-    mapM_ putErrLn  errs 
-    when (not $ null errs) $ fail "There were type errors!" 
+    mapM_ putErrLn  errs
+    when (not $ null errs) $ fail "There were type errors!"
hunk ./Grin/FromE.hs 92
-cafNum n = V $ - atomIndex (partialTag t 0) 
-    where 
+cafNum n = V $ - atomIndex (partialTag t 0)
+    where
hunk ./Grin/FromE.hs 96
---toEntry (n,as,e) 
+--toEntry (n,as,e)
hunk ./Grin/FromE.hs 101
-toEntry (n,as,e) 
+toEntry (n,as,e)
hunk ./Grin/FromE.hs 116
-    let (cc,reqcc) = constantCaf dataTable sc 
+    let (cc,reqcc) = constantCaf dataTable sc
hunk ./Grin/FromE.hs 118
-        putErrLn $ "Found" <+> tshow (length cc) <+> "CAFs to convert to constants," <+> tshow (length reqcc) <+> "of which are recursive."                                  
+        putErrLn $ "Found" <+> tshow (length cc) <+> "CAFs to convert to constants," <+> tshow (length reqcc) <+> "of which are recursive."
hunk ./Grin/FromE.hs 121
-    let doCompile = compile' dataTable CEnv { 
-            funcBaps = funcBaps, 
-            tyEnv = tyEnv, 
-            scMap = scMap, 
-            counter = counter, 
+    let doCompile = compile' dataTable CEnv {
+            funcBaps = funcBaps,
+            tyEnv = tyEnv,
+            scMap = scMap,
+            counter = counter,
hunk ./Grin/FromE.hs 127
-            ccafMap = Map.fromList [ (tvrNum v,e) |(v,_,e) <- cc] 
+            ccafMap = Map.fromList [ (tvrNum v,e) |(v,_,e) <- cc]
hunk ./Grin/FromE.hs 131
-    let tf a = a:tagToFunction a  
+    let tf a = a:tagToFunction a
hunk ./Grin/FromE.hs 136
-    let (main,as,_) = runIdentity $ Map.lookup (tvrNum mt) scMap  
+    let (main,as,_) = runIdentity $ Map.lookup (tvrNum mt) scMap
hunk ./Grin/FromE.hs 141
-        --ap = (funcApply,(createApply te tags))  
+        --ap = (funcApply,(createApply te tags))
hunk ./Grin/FromE.hs 150
-    let grin = Grin { 
-            grinTypeEnv = te, 
-            --grinFunctions = (funcMain ,[], App funcInitCafs [] :>>= (Unit,Store main') :>>= (p1,gEval p1)): ds', 
-            --grinFunctions = (funcMain ,(Tup [] :-> App funcInitCafs [] :>>= unit :-> main' :>>= n3 :-> App funcApply [n3,pworld__] )) : ds', 
-            --grinFunctions = (funcMain ,(Tup [] :-> App funcInitCafs [] :>>= unit :->  main' :>>= n3 :-> App funcApply [n3,pworld__] :>>= n0 :-> Return unit )) : ds', 
-            grinFunctions = (funcMain ,(Tup [] :-> App funcInitCafs [] :>>= unit :->  theMain :>>= n0 :-> Return unit )) : ds', 
+    let grin = Grin {
+            grinTypeEnv = te,
+            --grinFunctions = (funcMain ,[], App funcInitCafs [] :>>= (Unit,Store main') :>>= (p1,gEval p1)): ds',
+            --grinFunctions = (funcMain ,(Tup [] :-> App funcInitCafs [] :>>= unit :-> main' :>>= n3 :-> App funcApply [n3,pworld__] )) : ds',
+            --grinFunctions = (funcMain ,(Tup [] :-> App funcInitCafs [] :>>= unit :->  main' :>>= n3 :-> App funcApply [n3,pworld__] :>>= n0 :-> Return unit )) : ds',
+            grinFunctions = (funcMain ,(Tup [] :-> App funcInitCafs [] :>>= unit :->  theMain :>>= n0 :-> Return unit )) : ds',
hunk ./Grin/FromE.hs 159
-    return grin 
+    return grin
hunk ./Grin/FromE.hs 162
-    initTyEnv = mappend primTyEnv $ TyEnv $ fromList $ [ (a,(b,c)) | (_,(a,b,c)) <-  Map.toList scMap] ++ [con x| x <- Map.elems $ constructorMap dataTable] 
+    initTyEnv = mappend primTyEnv $ TyEnv $ fromList $ [ (a,(b,c)) | (_,(a,b,c)) <-  Map.toList scMap] ++ [con x| x <- Map.elems $ constructorMap dataTable]
hunk ./Grin/FromE.hs 166
-            as = [ TyPtr TyNode |  EVar tvr <- es] 
+            as = [ TyPtr TyNode |  EVar tvr <- es]
hunk ./Grin/FromE.hs 169
-         
+
hunk ./Grin/FromE.hs 172
-    toEntry (n,as,e) 
+    toEntry (n,as,e)
hunk ./Grin/FromE.hs 181
-        (ELit (LitCons _ es t),_) = fromLam $ conExpr c 
+        (ELit (LitCons _ es t),_) = fromLam $ conExpr c
hunk ./Grin/FromE.hs 203
--- constant CAF analysis 
--- In grin, partial applications are constant data, rather than functions. Since 
--- many cafs consist of constant applications, we preprocess them into values 
--- beforehand. This also catches recursive constant toplevel bindings. 
+-- constant CAF analysis
+-- In grin, partial applications are constant data, rather than functions. Since
+-- many cafs consist of constant applications, we preprocess them into values
+-- beforehand. This also catches recursive constant toplevel bindings.
hunk ./Grin/FromE.hs 219
-    coMap = Map.fromList [  (v,ce)| (v,_,ce) <- fst ans] 
+    coMap = Map.fromList [  (v,ce)| (v,_,ce) <- fst ans]
hunk ./Grin/FromE.hs 232
-                                        
-getName' :: (Show a,Monad m) => DataTable -> Lit a E -> m Atom 
-getName' dataTable v@(LitCons n es _) 
-    | conAlias cons = error $ "Alias still exists: " ++ show v 
+
+getName' :: (Show a,Monad m) => DataTable -> Lit a E -> m Atom
+getName' dataTable v@(LitCons n es _)
+    | conAlias cons = error $ "Alias still exists: " ++ show v
hunk ./Grin/FromE.hs 240
-    | otherwise = error $ "Strange name: " ++ show v ++ show nargs ++ show cons 
+    | otherwise = error $ "Strange name: " ++ show v ++ show nargs ++ show cons
hunk ./Grin/FromE.hs 243
-    cons = runIdentity $ getConstructor n dataTable 
+    cons = runIdentity $ getConstructor n dataTable
hunk ./Grin/FromE.hs 251
--- 
+--
hunk ./Grin/FromE.hs 254
--- all functions are assumed to return a TyNode 
+-- all functions are assumed to return a TyNode
hunk ./Grin/FromE.hs 256
--- 
--- right after compilation, everything has type TyNode or (TyPtr TyNode) since 
+--
+-- right after compilation, everything has type TyNode or (TyPtr TyNode) since
hunk ./Grin/FromE.hs 265
-compile' ::  DataTable -> CEnv -> (TVr,[TVr],E) -> IO (Atom,Lam) 
+compile' ::  DataTable -> CEnv -> (TVr,[TVr],E) -> IO (Atom,Lam)
hunk ./Grin/FromE.hs 267
-    funcName = maybe (show $ tvrNum tvr) show (fmap fromAtom ( intToAtom $ tvrNum tvr) :: Maybe Name) 
+    funcName = maybe (show $ tvrNum tvr) show (fmap fromAtom ( intToAtom $ tvrNum tvr) :: Maybe Name)
hunk ./Grin/FromE.hs 269
-    (nn,_,_) = runIdentity $ Map.lookup (tvrNum tvr) (scMap cenv) 
+    (nn,_,_) = runIdentity $ Map.lookup (tvrNum tvr) (scMap cenv)
hunk ./Grin/FromE.hs 276
-        as <- return $ args as 
+        as <- return $ args as
hunk ./Grin/FromE.hs 279
-                case constant (EVar v) of 
+                case constant (EVar v) of
hunk ./Grin/FromE.hs 284
-                        app (gEval var) as   -- CAFs are looked up in global env  
-            Just (v,as',es) 
+                        app (gEval var) as   -- CAFs are looked up in global env
+            Just (v,as',es)
hunk ./Grin/FromE.hs 299
-        b' <- cc b 
+        b' <- cc b
hunk ./Grin/FromE.hs 307
-    ce ep@(EPrim (APrim (PrimPrim s) _) es _) = do 
-        fail $ "Unrecognized PrimPrim: " ++ show ep 
+    ce ep@(EPrim (APrim (PrimPrim s) _) es _) = do
+        fail $ "Unrecognized PrimPrim: " ++ show ep
hunk ./Grin/FromE.hs 311
-        let p = Primitive { primName = Atom.fromString (pprint ap), primRets = Nothing, primType = (TyTup (map (Ty . toAtom) as),tyUnit), primAPrim = ap }  
+        let p = Primitive { primName = Atom.fromString (pprint ap), primRets = Nothing, primType = (TyTup (map (Ty . toAtom) as),tyUnit), primAPrim = ap }
hunk ./Grin/FromE.hs 314
-        let p = Primitive { primName = Atom.fromString (pprint ap), primRets = Nothing, primType = (TyTup (map (Ty . toAtom) as),Ty (toAtom r)), primAPrim = ap }  
-            ptv = Var v2 pt   
+        let p = Primitive { primName = Atom.fromString (pprint ap), primRets = Nothing, primType = (TyTup (map (Ty . toAtom) as),Ty (toAtom r)), primAPrim = ap }
+            ptv = Var v2 pt
hunk ./Grin/FromE.hs 319
-        let p = Primitive { primName = Atom.fromString (pprint ap), primRets = Nothing, primType = (TyTup (map (Ty . toAtom) as),Ty (toAtom r)), primAPrim = ap }  
-        return $ Prim p (args es) 
+        let p = Primitive { primName = Atom.fromString (pprint ap), primRets = Nothing, primType = (TyTup (map (Ty . toAtom) as),Ty (toAtom r)), primAPrim = ap }
+        return $ Prim p (args es)
hunk ./Grin/FromE.hs 322
-        let p = Primitive { primName = Atom.fromString (pprint ap), primRets = Nothing, primType = (TyTup [Ty (toAtom "HsPtr")],pt), primAPrim = ap }  
-            ptv = Var v2 pt   
+        let p = Primitive { primName = Atom.fromString (pprint ap), primRets = Nothing, primType = (TyTup [Ty (toAtom "HsPtr")],pt), primAPrim = ap }
+            ptv = Var v2 pt
hunk ./Grin/FromE.hs 327
-        let p = Primitive { primName = Atom.fromString (pprint ap), primRets = Nothing, primType = (TyTup [Ty (toAtom "HsPtr"),pt],tyUnit), primAPrim = ap }  
+        let p = Primitive { primName = Atom.fromString (pprint ap), primRets = Nothing, primType = (TyTup [Ty (toAtom "HsPtr"),pt],tyUnit), primAPrim = ap }
hunk ./Grin/FromE.hs 332
-            ptype = Ty $ toAtom (show tname) 
-        return $ Prim p [] 
+            ptype = Ty $ toAtom (show tname)
+        return $ Prim p []
hunk ./Grin/FromE.hs 337
-        return $ Prim p [] 
+        return $ Prim p []
hunk ./Grin/FromE.hs 341
---        let p = Primitive { primName = Atom.fromString (pprint ap), primRets = Nothing, primType = (TyTup [Ty (toAtom "HsPtr")],pt), primAPrim = ap }  
---            ptv = Var v2 pt   
+--        let p = Primitive { primName = Atom.fromString (pprint ap), primRets = Nothing, primType = (TyTup [Ty (toAtom "HsPtr")],pt), primAPrim = ap }
+--            ptv = Var v2 pt
hunk ./Grin/FromE.hs 348
---        let p = Primitive { primName = Atom.fromString (pprint ap), primRets = Nothing, primType = (TyTup [Ty (toAtom "HsPtr"),pt],tyUnit), primAPrim = ap }  
---            ptv = Var v2 pt   
+--        let p = Primitive { primName = Atom.fromString (pprint ap), primRets = Nothing, primType = (TyTup [Ty (toAtom "HsPtr"),pt],tyUnit), primAPrim = ap }
+--            ptv = Var v2 pt
hunk ./Grin/FromE.hs 355
---            p = Primitive { primName = Atom.fromString (pprint ap), primRets = Nothing, primType = (TyTup (map (Ty . toAtom) as),tyUnit), primAPrim = ap }  
+--            p = Primitive { primName = Atom.fromString (pprint ap), primRets = Nothing, primType = (TyTup (map (Ty . toAtom) as),tyUnit), primAPrim = ap }
hunk ./Grin/FromE.hs 361
---            p = Primitive { primName = Atom.fromString (pprint ap), primRets = Nothing, primType = (TyTup (map (Ty . toAtom) as),Ty (toAtom r)), primAPrim = ap }  
---            ptv = Var v2 pt   
+--            p = Primitive { primName = Atom.fromString (pprint ap), primRets = Nothing, primType = (TyTup (map (Ty . toAtom) as),Ty (toAtom r)), primAPrim = ap }
+--            ptv = Var v2 pt
hunk ./Grin/FromE.hs 369
-    --    return $ Prim p [] :>>= Var v1 ptype :-> Return (NodeC (toAtom cname) [Var v1 ptype]) 
+    --    return $ Prim p [] :>>= Var v1 ptype :-> Return (NodeC (toAtom cname) [Var v1 ptype])
hunk ./Grin/FromE.hs 374
-    --    return $ Prim p [] :>>= Var v1 ptype :-> Return (NodeC (toAtom cname) [Var v1 ptype]) 
-    ce ee@(EPrim aprim@(APrim (CCast from to) _) [e] t)  = do 
+    --    return $ Prim p [] :>>= Var v1 ptype :-> Return (NodeC (toAtom cname) [Var v1 ptype])
+    ce ee@(EPrim aprim@(APrim (CCast from to) _) [e] t)  = do
hunk ./Grin/FromE.hs 379
-        return $  Prim p (args [e]) 
+        return $  Prim p (args [e])
hunk ./Grin/FromE.hs 381
-        let p = Primitive { primName = Atom.fromString (pprint ap), primRets = Nothing, primType = (TyTup (map (Ty . toAtom) as),Ty (toAtom r)), primAPrim = ap }  
-        return $ Prim p (args es) 
+        let p = Primitive { primName = Atom.fromString (pprint ap), primRets = Nothing, primType = (TyTup (map (Ty . toAtom) as),Ty (toAtom r)), primAPrim = ap }
+        return $ Prim p (args es)
hunk ./Grin/FromE.hs 389
-            p = Primitive { primName = Atom.fromString (pprint ap), primRets = Nothing, primType = (TyTup (map (Ty . toAtom) as),Ty (toAtom r)), primAPrim = ap }  
-            ptv = Var v2 pt   
+            p = Primitive { primName = Atom.fromString (pprint ap), primRets = Nothing, primType = (TyTup (map (Ty . toAtom) as),Ty (toAtom r)), primAPrim = ap }
+            ptv = Var v2 pt
hunk ./Grin/FromE.hs 398
-            p = Primitive { primName = Atom.fromString (pprint ap), primRets = Nothing, primType = (TyTup (map (Ty . toAtom) as),Ty (toAtom r)), primAPrim = ap }  
-            ptv = Var v2 pt   
+            p = Primitive { primName = Atom.fromString (pprint ap), primRets = Nothing, primType = (TyTup (map (Ty . toAtom) as),Ty (toAtom r)), primAPrim = ap }
+            ptv = Var v2 pt
hunk ./Grin/FromE.hs 403
-    ce ee@(EPrim aprim@(APrim (CCast from to) _) [e] t)  = do 
-        fd <- ce e 
+    ce ee@(EPrim aprim@(APrim (CCast from to) _) [e] t)  = do
+        fd <- ce e
hunk ./Grin/FromE.hs 412
-            vfrom = Var v1 ptypefrom' 
+            vfrom = Var v1 ptypefrom'
hunk ./Grin/FromE.hs 415
-        return $ fd :>>= NodeC namecfrom [vfrom] :-> Prim p [vfrom] :>>= vto :-> Return (NodeC namecto [vto]) 
+        return $ fd :>>= NodeC namecfrom [vfrom] :-> Prim p [vfrom] :>>= vto :-> Return (NodeC namecto [vto])
hunk ./Grin/FromE.hs 417
-        x1 <- ce e1 
-        x2 <- ce e2 
+        x1 <- ce e1
+        x2 <- ce e2
hunk ./Grin/FromE.hs 434
-        return $ x1 :>>= node p1 :-> x2 :>>= node p2 :-> Prim p [p1,p2] :>>= p3 :-> Return (node p3) 
+        return $ x1 :>>= node p1 :-> x2 :>>= node p2 :-> Prim p [p1,p2] :>>= p3 :-> Return (node p3)
hunk ./Grin/FromE.hs 440
-        
+
hunk ./Grin/FromE.hs 444
-            e <- ce e 
+            e <- ce e
hunk ./Grin/FromE.hs 447
-            return $ 
+            return $
hunk ./Grin/FromE.hs 449
-        
+
hunk ./Grin/FromE.hs 454
-            e <- ce e 
+            e <- ce e
hunk ./Grin/FromE.hs 457
-            return $ 
-                e :>>= nv :-> 
-                Store nv :>>= toVal b :-> 
-                Return nv :>>= NodeC cons [v] :-> 
+            return $
+                e :>>= nv :->
+                Store nv :>>= toVal b :->
+                Return nv :>>= NodeC cons [v] :->
hunk ./Grin/FromE.hs 466
-        e <- ce e 
+        e <- ce e
hunk ./Grin/FromE.hs 469
-        return $ 
+        return $
hunk ./Grin/FromE.hs 471
-            Store v :>>= toVal b :-> 
+            Store v :>>= toVal b :->
hunk ./Grin/FromE.hs 478
-    cpa :: E -> IO (Val,Val,Exp) 
+    cpa :: E -> IO (Val,Val,Exp)
hunk ./Grin/FromE.hs 480
-        v <- newVar 
+        v <- newVar
hunk ./Grin/FromE.hs 482
-            Right x -> return x 
-            Left m -> fail (m <+> show e) 
+            Right x -> return x
+            Left m -> fail (m <+> show e)
hunk ./Grin/FromE.hs 486
-        return (var,NodeC (toAtom $ 'C':show c) [var],w) 
+        return (var,NodeC (toAtom $ 'C':show c) [var],w)
hunk ./Grin/FromE.hs 488
-    isBasic ( (LitInt _ t)) | Just (c,pt) <- lookupCType dataTable t = return (toAtom $ 'C':show c, Ty $ toAtom pt) 
-    --isBasic ( (LitInt _ (ELit (LitCons c [] _)))) | Just pt <- Prelude.lookup (show c) allCTypes = return (toAtom $ 'C':show c, Ty $ toAtom pt) 
+    isBasic ( (LitInt _ t)) | Just (c,pt) <- lookupCType dataTable t = return (toAtom $ 'C':show c, Ty $ toAtom pt)
+    --isBasic ( (LitInt _ (ELit (LitCons c [] _)))) | Just pt <- Prelude.lookup (show c) allCTypes = return (toAtom $ 'C':show c, Ty $ toAtom pt)
hunk ./Grin/FromE.hs 494
-        nv <- nnv 
+        nv <- nnv
hunk ./Grin/FromE.hs 518
-        
+
hunk ./Grin/FromE.hs 522
-            --z <- const $ ELit l 
+            --z <- const $ ELit l
hunk ./Grin/FromE.hs 528
---            --z <- const $ ELit l 
+--            --z <- const $ ELit l
hunk ./Grin/FromE.hs 548
-    getName v@(LitCons n es _) 
-        | conAlias cons = error $ "Alias still exists: " ++ show v 
+    getName v@(LitCons n es _)
+        | conAlias cons = error $ "Alias still exists: " ++ show v
hunk ./Grin/FromE.hs 556
-        cons = runIdentity $ getConstructor n dataTable 
+        cons = runIdentity $ getConstructor n dataTable
hunk ./Grin/FromE.hs 565
--}        
-    
+-}
+
hunk ./Grin/FromE.hs 576
-            lazy = do 
+            lazy = do
hunk ./Grin/FromE.hs 578
-                app' (Const (NodeC (partialTag (toAtom $ 'f':rs) (n - 1)) (cs ++ [a]))) as 
-        case a of 
-            Const {} -> lazy 
-            Lit {} -> lazy 
-            Var (V n) _ | n < 0 -> lazy 
+                app' (Const (NodeC (partialTag (toAtom $ 'f':rs) (n - 1)) (cs ++ [a]))) as
+        case a of
+            Const {} -> lazy
+            Lit {} -> lazy
+            Var (V n) _ | n < 0 -> lazy
hunk ./Grin/FromE.hs 591
-        let t = toAtom $ "Bap_" ++ show (length as) ++ "_" ++ funcName ++ "_" ++ show vn   
-            tl = toAtom $ "bap_" ++ show (length as) ++ "_" ++  funcName ++ "_" ++ show vn  
+        let t = toAtom $ "Bap_" ++ show (length as) ++ "_" ++ funcName ++ "_" ++ show vn
+            tl = toAtom $ "bap_" ++ show (length as) ++ "_" ++  funcName ++ "_" ++ show vn
hunk ./Grin/FromE.hs 607
-    
+
hunk ./Grin/FromE.hs 613
-        return (s :>>= v :-> r) 
+        return (s :>>= v :-> r)
hunk ./Grin/FromE.hs 620
-    --    b' <- cc b 
+    --    b' <- cc b
hunk ./Grin/FromE.hs 629
-        as <- return $ args as 
+        as <- return $ args as
hunk ./Grin/FromE.hs 632
-            Just (v,as',es) 
+            Just (v,as',es)
hunk ./Grin/FromE.hs 636
-                    nv <- newNodePtrVar 
+                    nv <- newNodePtrVar
hunk ./Grin/FromE.hs 643
-            Nothing 
+            Nothing
hunk ./Grin/FromE.hs 650
---        te <- readIORef (tyEnv cenv) 
+--        te <- readIORef (tyEnv cenv)
hunk ./Grin/FromE.hs 664
-        te <- readIORef (tyEnv cenv) 
+        te <- readIORef (tyEnv cenv)
hunk ./Grin/FromE.hs 677
-    --cc (EPrim (APrim (PrimPrim s) _) es _) = do 
+    --cc (EPrim (APrim (PrimPrim s) _) es _) = do
hunk ./Grin/FromE.hs 680
-    doLet ds e = f (decomposeDefns ds) e where 
+    doLet ds e = f (decomposeDefns ds) e where
hunk ./Grin/FromE.hs 683
-            e <- cc e 
+            e <- cc e
hunk ./Grin/FromE.hs 689
-                    v <- newNodePtrVar 
-                    v' <- newNodeVar 
+                    v <- newNodePtrVar
+                    v' <- newNodeVar
hunk ./Grin/FromE.hs 693
-                    
-                    --return (e :>>= v :-> 
-                    --        Fetch v :>>= v' :-> 
+
+                    --return (e :>>= v :->
+                    --        Fetch v :>>= v' :->
hunk ./Grin/FromE.hs 704
-    doUpdate vr (Store n) = Update vr n 
+    doUpdate vr (Store n) = Update vr n
hunk ./Grin/FromE.hs 715
-    -- Takes an E and returns something constant of type (TyPtr TyNode) 
-    constant :: Monad m =>  E -> m Val 
-    constant (EVar tvr) | Just c <- Map.lookup (tvrNum tvr) (ccafMap cenv) = return c 
-                        | Just (v,as,_) <- Map.lookup (tvrNum tvr) (scMap cenv)  
+    -- Takes an E and returns something constant of type (TyPtr TyNode)
+    constant :: Monad m =>  E -> m Val
+    constant (EVar tvr) | Just c <- Map.lookup (tvrNum tvr) (ccafMap cenv) = return c
+                        | Just (v,as,_) <- Map.lookup (tvrNum tvr) (scMap cenv)
hunk ./Grin/FromE.hs 721
-                            False -> return $ Var (V $ - atomIndex t) (TyPtr TyNode)  
+                            False -> return $ Var (V $ - atomIndex t) (TyPtr TyNode)
hunk ./Grin/FromE.hs 724
-                            --    Nothing -> return $ Var (V $ - atomIndex t) (TyPtr TyNode) 
+                            --    Nothing -> return $ Var (V $ - atomIndex t) (TyPtr TyNode)
hunk ./Grin/FromE.hs 734
-    
+
hunk ./Grin/FromE.hs 736
-    caforconst :: Monad m =>  E -> m Val 
-    caforconst (EVar tvr)  | Just (v,as,_) <- Map.lookup (tvrNum tvr) (scMap cenv)  
+    caforconst :: Monad m =>  E -> m Val
+    caforconst (EVar tvr)  | Just (v,as,_) <- Map.lookup (tvrNum tvr) (scMap cenv)
hunk ./Grin/FromE.hs 740
-                            False -> return $ Var (V $ - atomIndex t) (TyPtr TyNode) 
+                            False -> return $ Var (V $ - atomIndex t) (TyPtr TyNode)
hunk ./Grin/FromE.hs 742
-    
+
hunk ./Grin/FromE.hs 744
-    const (EVar tvr)  | Just (v,as,_) <- Map.lookup (tvrNum tvr) (scMap cenv)  
+    const (EVar tvr)  | Just (v,as,_) <- Map.lookup (tvrNum tvr) (scMap cenv)
hunk ./Grin/FromE.hs 753
-    --const e@(EPi {}) | (ELit (LitCons n as' t),as) <- fromPi e, as == [ v | EVar v <- as'] = const (ELit (LitCons n [] undefined)) 
+    --const e@(EPi {}) | (ELit (LitCons n as' t),as) <- fromPi e, as == [ v | EVar v <- as'] = const (ELit (LitCons n [] undefined))
hunk ./Grin/FromE.hs 761
-    con v@(ELit (LitCons n es _)) 
-        | conAlias cons = error $ "Alias still exists: " ++ show v 
+    con v@(ELit (LitCons n es _))
+        | conAlias cons = error $ "Alias still exists: " ++ show v
hunk ./Grin/FromE.hs 769
-        Just cons = getConstructor n dataTable 
+        Just cons = getConstructor n dataTable
hunk ./Grin/FromE.hs 771
-        
+
hunk ./Grin/FromE.hs 774
-    
-    scInfo tvr | Just n <- Map.lookup (tvrNum tvr) (scMap cenv) = return n 
-    scInfo tvr = fail $ "not a supercombinator:" <+> show tvr 
-    --newVar' = fmap (\x -> Var x TyNode) newVar 
-    newNodeVar =  fmap (\x -> Var x TyNode) newVar 
-    newPrimVar ty =  fmap (\x -> Var x ty) newVar 
-    newNodePtrVar =  fmap (\x -> Var x (TyPtr TyNode)) newVar 
+
+    scInfo tvr | Just n <- Map.lookup (tvrNum tvr) (scMap cenv) = return n
+    scInfo tvr = fail $ "not a supercombinator:" <+> show tvr
+    --newVar' = fmap (\x -> Var x TyNode) newVar
+    newNodeVar =  fmap (\x -> Var x TyNode) newVar
+    newPrimVar ty =  fmap (\x -> Var x ty) newVar
+    newNodePtrVar =  fmap (\x -> Var x (TyPtr TyNode)) newVar
hunk ./Grin/FromE.hs 790
---        f (EVar tvr) 
---            | Just (v,as,_) <- Map.lookup (tvrNum tvr) (scMap cenv) = 
---                    let pt = partialTag v (length as) in  
+--        f (EVar tvr)
+--            | Just (v,as,_) <- Map.lookup (tvrNum tvr) (scMap cenv) =
+--                    let pt = partialTag v (length as) in
hunk ./Grin/FromE.hs 799
- 
+
hunk ./Grin/FromE.hs 801
-    --ce (EPrim "seq" [a,b] _) = do 
+    --ce (EPrim "seq" [a,b] _) = do
hunk ./Grin/FromE.hs 803
-    --    b <- ce b 
+    --    b <- ce b
hunk ./Grin/FromE.hs 810
---        return $ Prim p [] :>>= Var v1 ptype :-> Return (NodeC (toAtom cname) [Var v1 ptype]) 
+--        return $ Prim p [] :>>= Var v1 ptype :-> Return (NodeC (toAtom cname) [Var v1 ptype])
hunk ./Grin/FromE.hs 812
---        x <- ce e 
+--        x <- ce e
hunk ./Grin/FromE.hs 820
---        return $ x :>>= node p1 :-> Prim p [p1] :>>= p2 :-> Return (node p2) 
+--        return $ x :>>= node p1 :-> Prim p [p1] :>>= p2 :-> Return (node p2)
hunk ./Grin/FromE.hs 822
---        x1 <- ce e1 
---        x2 <- ce e2 
+--        x1 <- ce e1
+--        x2 <- ce e2
hunk ./Grin/FromE.hs 832
---        return $ x1 :>>= node p1 :-> x2 :>>= node p2 :-> Prim p [p1,p2] :>>= p3 :-> Return (node p3) 
+--        return $ x1 :>>= node p1 :-> x2 :>>= node p2 :-> Prim p [p1,p2] :>>= p3 :-> Return (node p3)
hunk ./Grin/FromE.hs 834
---        x1 <- ce e1 
---        x2 <- ce e2 
+--        x1 <- ce e1
+--        x2 <- ce e2
hunk ./Grin/FromE.hs 844
---        return $ x1 :>>= node p1 :-> x2 :>>= node p2 :-> Prim p [p1,p2] :>>= p3 :-> Return (node p3) 
+--        return $ x1 :>>= node p1 :-> x2 :>>= node p2 :-> Prim p [p1,p2] :>>= p3 :-> Return (node p3)
hunk ./Grin/FromE.hs 846
---        x1 <- ce e1 
---        x2 <- ce e2 
+--        x1 <- ce e1
+--        x2 <- ce e2
hunk ./Grin/FromE.hs 851
---            p3 = Var v3 intT   
+--            p3 = Var v3 intT
hunk ./Grin/HashConst.hs 9
--- TODO tuples 
+-- TODO tuples
hunk ./Grin/HashConst.hs 11
-data HcNode = HcNode {-# UNPACK #-} !Atom [Either Val Int] 
-    deriving(Show,Ord,Eq) 
+data HcNode = HcNode {-# UNPACK #-} !Atom [Either Val Int]
+    deriving(Show,Ord,Eq)
hunk ./Grin/HashConst.hs 14
-data HcHash = HcHash !Int (Map.Map HcNode Int) 
+data HcHash = HcHash !Int (Map.Map HcNode Int)
hunk ./Grin/HashConst.hs 17
-emptyHcHash = HcHash 1 Map.empty 
+emptyHcHash = HcHash 1 Map.empty
hunk ./Grin/HashConst.hs 21
-newConst :: MonadState HcHash m => Val -> m (Bool,Int) 
+newConst :: MonadState HcHash m => Val -> m (Bool,Int)
hunk ./Grin/HashConst.hs 24
-newConst' :: MonadState HcHash m => Bool -> Val -> m (Bool,Int) 
+newConst' :: MonadState HcHash m => Bool -> Val -> m (Bool,Int)
hunk ./Grin/HashConst.hs 27
-        let g (Lit i ty) 
+        let g (Lit i ty)
hunk ./Grin/HashConst.hs 30
-            g (Tag t)  
-                | fuzzy = return $ Left (Tag tagHole)  
-                | otherwise = return $ Left (Tag t)  
+            g (Tag t)
+                | fuzzy = return $ Left (Tag tagHole)
+                | otherwise = return $ Left (Tag t)
hunk ./Grin/HashConst.hs 38
-        HcHash c h <- get 
+        HcHash c h <- get
hunk ./Grin/HashConst.hs 43
-                put $ HcHash (c + 1) h' 
-                return (False,c) 
+                put $ HcHash (c + 1) h'
+                return (False,c)
hunk ./Grin/HashConst.hs 49
-    gr = newGraph (Map.toList mp) snd (gk . fst)  
+    gr = newGraph (Map.toList mp) snd (gk . fst)
hunk ./Grin/Interpret.hs 26
---    f ((x,y):xs) ys = newIORef (NodeC y []) >>= \y -> f xs ((x,Addr y):ys) 
+--    f ((x,y):xs) ys = newIORef (NodeC y []) >>= \y -> f xs ((x,Addr y):ys)
hunk ./Grin/Interpret.hs 32
-    f ((x,y):xs) ys = newIORef y >>= \y -> f xs ((x,Addr y):ys) 
+    f ((x,y):xs) ys = newIORef y >>= \y -> f xs ((x,Addr y):ys)
hunk ./Grin/Interpret.hs 42
-        g e = f e >>= \x -> case x of 
+        g e = f e >>= \x -> case x of
hunk ./Grin/Interpret.hs 65
-        Stats.tick stats funcCalls 
+        Stats.tick stats funcCalls
hunk ./Grin/Interpret.hs 69
-            Just ((Tup as :-> e)) -> f (Map.fromList (zip [ v | Var v _ <- as] xs')) e 
-            --Just (Right action) -> do action xs' 
+            Just ((Tup as :-> e)) -> f (Map.fromList (zip [ v | Var v _ <- as] xs')) e
+            --Just (Right action) -> do action xs'
hunk ./Grin/Interpret.hs 72
-    f env (Prim p xs) = do 
+    f env (Prim p xs) = do
hunk ./Grin/Interpret.hs 77
-        Stats.tick stats primCalls 
+        Stats.tick stats primCalls
hunk ./Grin/Interpret.hs 81
-            Just action -> do action xs' 
+            Just action -> do action xs'
hunk ./Grin/Interpret.hs 84
-        Stats.tick stats (toAtom "Allocations Performed") 
+        Stats.tick stats (toAtom "Allocations Performed")
hunk ./Grin/Interpret.hs 86
-    f env (Fetch x) 
+    f env (Fetch x)
hunk ./Grin/Interpret.hs 90
-        Stats.tick stats (toAtom "Updates Performed") 
+        Stats.tick stats (toAtom "Updates Performed")
hunk ./Grin/Interpret.hs 95
-    f env (Error s t) = fail $ render $  tshow (s,t) <$> (prettyEnv env) 
---    f env (Eval x) 
---        | otherwise = f env $ App funcEval [x] 
+    f env (Error s t) = fail $ render $  tshow (s,t) <$> (prettyEnv env)
+--    f env (Eval x)
+--        | otherwise = f env $ App funcEval [x]
hunk ./Grin/Interpret.hs 100
---            v <- readIORef ref 
+--            v <- readIORef ref
hunk ./Grin/Interpret.hs 104
---        where 
+--        where
hunk ./Grin/Interpret.hs 106
---    f env (Apply x y) 
---        | True =  f env $ App funcApply [x,y] 
+--    f env (Apply x y)
+--        | True =  f env $ App funcApply [x,y]
hunk ./Grin/Interpret.hs 114
-    f env z = fail $ "cannot interpret: " ++ show (toList env,z)  
+    f env z = fail $ "cannot interpret: " ++ show (toList env,z)
hunk ./Grin/Interpret.hs 126
-    doApply (NodeC t xs) y 
+    doApply (NodeC t xs) y
hunk ./Grin/Interpret.hs 135
-        | 'P':_ <- t' = return x  
-        | 'T':_ <- t' = return x  
-        | 'C':_ <- t' = return x  
---        | t == tagApply = f mempty (Eval (xs !! 0) :>>= (n1, Apply n1 (xs !! 1))) 
+        | 'P':_ <- t' = return x
+        | 'T':_ <- t' = return x
+        | 'C':_ <- t' = return x
+--        | t == tagApply = f mempty (Eval (xs !! 0) :>>= (n1, Apply n1 (xs !! 1)))
hunk ./Grin/Interpret.hs 144
-        
+
hunk ./Grin/Interpret.hs 152
-    bind (NodeV v vs) (NodeC t vs') = do 
-        be <- liftM mconcat $ sequence $  zipWith bind vs vs' 
+    bind (NodeV v vs) (NodeC t vs') = do
+        be <- liftM mconcat $ sequence $  zipWith bind vs vs'
hunk ./Grin/Interpret.hs 155
-    bind (NodeC t vs) (NodeC t' vs') | t == t' = do 
-        liftM mconcat $ sequence $  zipWith bind vs vs' 
+    bind (NodeC t vs) (NodeC t' vs') | t == t' = do
+        liftM mconcat $ sequence $  zipWith bind vs vs'
hunk ./Grin/Parse.hs 11
-   }   
+   }
hunk ./Grin/Parse.hs 14
-exp = 
+exp =
hunk ./Grin/Parse.hs 17
-    unit = symbol "()" >> return Unit 
-    liti = do x <- integer tp; return $ Lit (fromIntegral x) tInt  
+    unit = symbol "()" >> return Unit
+    liti = do x <- integer tp; return $ Lit (fromIntegral x) tInt
hunk ./Grin/Parse.hs 25
-        
+
hunk ./Grin/PointsTo.hs 40
-data Pos = 
-    Union [Pos] 
+data Pos =
+    Union [Pos]
hunk ./Grin/PointsTo.hs 44
-    | Basic 
-    | PCase Pos [(Atom,Pos)] Pos 
+    | Basic
+    | PCase Pos [(Atom,Pos)] Pos
hunk ./Grin/PointsTo.hs 47
-    | Ptr {-# UNPACK #-}!Int 
-    | Down Pos {-# UNPACK #-}!Atom {-# UNPACK #-}!Int 
+    | Ptr {-# UNPACK #-}!Int
+    | Down Pos {-# UNPACK #-}!Atom {-# UNPACK #-}!Int
hunk ./Grin/PointsTo.hs 55
---    | Con Val 
+--    | Con Val
hunk ./Grin/PointsTo.hs 61
-    showsPrec n (Ptr i) xs = '*':showsPrec n i xs 
-    showsPrec n (Down p a i) xs = show p ++ U.dArrow ++ show a ++ U.dArrow ++ show i ++ xs 
-    showsPrec n (DownTup p i) xs = show p ++ U.dArrow ++ show i ++ xs 
-    showsPrec n (Arg p i) xs = show p ++ U.rArrow ++ show i ++ xs 
-    showsPrec n (Con p i) xs = show p ++ show i ++ xs 
+    showsPrec n (Ptr i) xs = '*':showsPrec n i xs
+    showsPrec n (Down p a i) xs = show p ++ U.dArrow ++ show a ++ U.dArrow ++ show i ++ xs
+    showsPrec n (DownTup p i) xs = show p ++ U.dArrow ++ show i ++ xs
+    showsPrec n (Arg p i) xs = show p ++ U.rArrow ++ show i ++ xs
+    showsPrec n (Con p i) xs = show p ++ show i ++ xs
hunk ./Grin/PointsTo.hs 78
-    mappend (Union xs) x = mconcat (x:xs) 
-    mappend x (Union xs) = mconcat (x:xs) 
+    mappend (Union xs) x = mconcat (x:xs)
+    mappend x (Union xs) = mconcat (x:xs)
hunk ./Grin/PointsTo.hs 94
-data OPos = 
+data OPos =
hunk ./Grin/PointsTo.hs 101
-    | OFetch OUnion 
+    | OFetch OUnion
hunk ./Grin/PointsTo.hs 114
-    return $ OApply x y 
+    return $ OApply x y
hunk ./Grin/PointsTo.hs 142
-    return $ ((OUnion $ vs) $ xs) 
+    return $ ((OUnion $ vs) $ xs)
hunk ./Grin/PointsTo.hs 169
-    mempty = VsEmpty 
+    mempty = VsEmpty
hunk ./Grin/PointsTo.hs 184
-    showsPrec x (VsHeaps s) 
-        | Set.size s > 7  = braces (hcat (intersperse (char ',') $ map tshow  (take 7 $ Set.toAscList s)) <> text ",...") 
-        | otherwise  = braces (hcat (intersperse (char ',') $ map tshow  ( Set.toAscList s)) ) 
+    showsPrec x (VsHeaps s)
+        | Set.size s > 7  = braces (hcat (intersperse (char ',') $ map tshow  (take 7 $ Set.toAscList s)) <> text ",...")
+        | otherwise  = braces (hcat (intersperse (char ',') $ map tshow  ( Set.toAscList s)) )
hunk ./Grin/PointsTo.hs 194
-    ptFunc :: Map.Map Atom ValueSet, 
+    ptFunc :: Map.Map Atom ValueSet,
hunk ./Grin/PointsTo.hs 206
-    --        sn "Total" (length xs) <+> 
-    --        sn "Empty" (count isVsEmpty xs) <+>  
-    --        sn "Basic" (count isVsBas xs) <+> 
-    --        sn "Max  " (maximum $ map num xs) <+> 
-    --        sn "Average" (fromIntegral (sum (map num xs)) / fromIntegral (length xs)) 
+    --        sn "Total" (length xs) <+>
+    --        sn "Empty" (count isVsEmpty xs) <+>
+    --        sn "Basic" (count isVsBas xs) <+>
+    --        sn "Max  " (maximum $ map num xs) <+>
+    --        sn "Average" (fromIntegral (sum (map num xs)) / fromIntegral (length xs))
hunk ./Grin/PointsTo.hs 216
-    
hunk ./Grin/PointsTo.hs 219
+
hunk ./Grin/PointsTo.hs 230
-        
-        
hunk ./Grin/PointsTo.hs 232
+
+
hunk ./Grin/PointsTo.hs 248
-    f xs = [ (x, mconcat $ snds xs)  | xs@((x,_):_) <- sortGroupUnder fst xs] 
-    --g xs = [ (x, map mconcat $ transpose (snds xs))  | xs@((x,_):_) <- sortGroupUnder fst xs] 
-    g xs = xs 
-    h xs = [ (x, (t,mconcat $ snds $ snds xs))  | xs@((x,(t,_)):_) <- sortGroupUnder fst xs] 
+    f xs = [ (x, mconcat $ snds xs)  | xs@((x,_):_) <- sortGroupUnder fst xs]
+    --g xs = [ (x, map mconcat $ transpose (snds xs))  | xs@((x,_):_) <- sortGroupUnder fst xs]
+    g xs = xs
+    h xs = [ (x, (t,mconcat $ snds $ snds xs))  | xs@((x,(t,_)):_) <- sortGroupUnder fst xs]
hunk ./Grin/PointsTo.hs 263
-    
hunk ./Grin/PointsTo.hs 265
+
hunk ./Grin/PointsTo.hs 272
-    
+
hunk ./Grin/PointsTo.hs 280
-bind (NodeC t vs) p | sameLength vs vs' = tell mempty { varEq = vs' }  where   
+bind (NodeC t vs) p | sameLength vs vs' = tell mempty { varEq = vs' }  where
hunk ./Grin/PointsTo.hs 285
-bind (Tup vs) p | sameLength vs vs' = tell mempty { varEq = vs'  }  where 
+bind (Tup vs) p | sameLength vs vs' = tell mempty { varEq = vs'  }  where
hunk ./Grin/PointsTo.hs 290
-bind x y = error $ unwords ["bind:",show x,show y] 
+bind x y = error $ unwords ["bind:",show x,show y]
hunk ./Grin/PointsTo.hs 296
-        f (eq,hc) (n,l) = mapFst (mappend eq) $ collect hc (mh eq + 1) n l 
-        mh PointsToEq { heapEq = xs } = maximum $ 1:fsts xs    
+        f (eq,hc) (n,l) = mapFst (mappend eq) $ collect hc (mh eq + 1) n l
+        mh PointsToEq { heapEq = xs } = maximum $ 1:fsts xs
hunk ./Grin/PointsTo.hs 301
-        eq = mempty { 
+        eq = mempty {
hunk ./Grin/PointsTo.hs 307
-        (neq,hc) = mapFst flattenPointsToEq $ foldl f  (eq,hc') grinFunctions         
+        (neq,hc) = mapFst flattenPointsToEq $ foldl f  (eq,hc') grinFunctions
hunk ./Grin/PointsTo.hs 317
-createStore ::  TyEnv -> [Tag] -> Lam   
-createStore  te ts 
+createStore ::  TyEnv -> [Tag] -> Lam
+createStore  te ts
hunk ./Grin/PointsTo.hs 321
-        Case n1 cs 
+        Case n1 cs
hunk ./Grin/PointsTo.hs 323
-    cs = [f t | t <- ts, tagIsTag t ] 
+    cs = [f t | t <- ts, tagIsTag t ]
hunk ./Grin/PointsTo.hs 336
-        g (App a [vr@(Var v _)] :>>= vb :-> Return vb' :>>= node@(NodeC {}) :-> e) 
+        g (App a [vr@(Var v _)] :>>= vb :-> Return vb' :>>= node@(NodeC {}) :-> e)
hunk ./Grin/PointsTo.hs 338
-        g (e1 :>>= l) = g e1 :>>= f l 
-        g (App a [vr@(Var v _)]) 
-            | a == funcEval = Return vr :>>= createEval TrailingUpdate typeEnv (tagsp v) 
+        g (e1 :>>= l) = g e1 :>>= f l
+        g (App a [vr@(Var v _)])
+            | a == funcEval = Return vr :>>= createEval TrailingUpdate typeEnv (tagsp v)
hunk ./Grin/PointsTo.hs 342
-            | a == funcApply = case (tags v) of 
+            | a == funcApply = case (tags v) of
hunk ./Grin/PointsTo.hs 345
-        g n@(App a _) 
+        g n@(App a _)
hunk ./Grin/PointsTo.hs 349
-        g (Case v@(Var vr _) xs) = docase v (map f xs) (tags vr) 
+        g (Case v@(Var vr _) xs) = docase v (map f xs) (tags vr)
hunk ./Grin/PointsTo.hs 387
-collect hc st fname (Tup vs :-> exp') 
-    | sameLength avs vs = (eq { funcEq = (fname,v):funcEq eq, varEq = varEq eq ++ avs },hc')   where   
+collect hc st fname (Tup vs :-> exp')
+    | sameLength avs vs = (eq { funcEq = (fname,v):funcEq eq, varEq = varEq eq ++ avs },hc')   where
hunk ./Grin/PointsTo.hs 390
-    --((v,eq),hc') = execUniq st $ (runStateT ((runWriterT (f exp'))) hc) 
-    ((v,hc'),eq) = execUniq st $ (runWriterT (runStateT (f exp') hc)) 
-    --((v,hc'),eq) = runWriter $ execUniqT st $ (runStateT  (f exp') hc) 
+    --((v,eq),hc') = execUniq st $ (runStateT ((runWriterT (f exp'))) hc)
+    ((v,hc'),eq) = execUniq st $ (runWriterT (runStateT (f exp') hc))
+    --((v,hc'),eq) = runWriter $ execUniqT st $ (runStateT  (f exp') hc)
hunk ./Grin/PointsTo.hs 399
-        
+
hunk ./Grin/PointsTo.hs 402
-        --tell mempty { appEq = [(funcEval,[x])] }   
-        return $ Complex funcEval [Complex funcFetch [x]] 
+        --tell mempty { appEq = [(funcEval,[x])] }
+        return $ Complex funcEval [Complex funcFetch [x]]
hunk ./Grin/PointsTo.hs 407
-        tell mempty { applyEq = [(v,x)] }   
+        tell mempty { applyEq = [(v,x)] }
hunk ./Grin/PointsTo.hs 409
-        --return $ Complex funcEval (Complex funcApply x) 
-        
+        --return $ Complex funcEval (Complex funcApply x)
+
hunk ./Grin/PointsTo.hs 412
-        vs' <- mapM toPos vs 
-        tell mempty { appEq = [(a,vs')] }   
+        vs' <- mapM toPos vs
+        tell mempty { appEq = [(a,vs')] }
hunk ./Grin/PointsTo.hs 418
-            'F':rs -> tell mempty { appEq = [(toAtom ('f':rs),ts)] }   
-            'B':rs -> tell mempty { appEq = [(toAtom ('b':rs),ts)] }   
+            'F':rs -> tell mempty { appEq = [(toAtom ('f':rs),ts)] }
+            'B':rs -> tell mempty { appEq = [(toAtom ('b':rs),ts)] }
hunk ./Grin/PointsTo.hs 428
-            'F':rs -> tell mempty { appEq = [(toAtom ('f':rs),ts)] }   
-            'B':rs -> tell mempty { appEq = [(toAtom ('b':rs),ts)] }   
+            'F':rs -> tell mempty { appEq = [(toAtom ('f':rs),ts)] }
+            'B':rs -> tell mempty { appEq = [(toAtom ('b':rs),ts)] }
hunk ./Grin/PointsTo.hs 436
-        p <- toPos val 
+        p <- toPos val
hunk ./Grin/PointsTo.hs 438
-    g (Prim p vs) 
+    g (Prim p vs)
hunk ./Grin/PointsTo.hs 440
-        | (_,TyTup []) <- primType p = return Basic 
-        | (_,TyTup ts) <- primType p = return $ Tuple (replicate (length ts) Basic)  
+        | (_,TyTup []) <- primType p = return Basic
+        | (_,TyTup ts) <- primType p = return $ Tuple (replicate (length ts) Basic)
hunk ./Grin/PointsTo.hs 461
-              else sequence [ f e | _ :-> e <- ls ] >>= return . mconcat 
+              else sequence [ f e | _ :-> e <- ls ] >>= return . mconcat
hunk ./Grin/PointsTo.hs 466
-        tell mempty { updateEq = [(p,v)] }   
+        tell mempty { updateEq = [(p,v)] }
hunk ./Grin/PointsTo.hs 471
-    vs' <- mapM toPos vs 
+    vs' <- mapM toPos vs
hunk ./Grin/PointsTo.hs 485
-toPos x  = error $ unwords ["toPos:",show x] 
+toPos x  = error $ unwords ["toPos:",show x]
hunk ./Grin/PointsTo.hs 497
-    vars = (Lv app_var,apps):[ (Lv x,cp y) | (x,y) <- varEq eq ] 
+    vars = (Lv app_var,apps):[ (Lv x,cp y) | (x,y) <- varEq eq ]
hunk ./Grin/PointsTo.hs 500
-        z (Right n) = oConst $ setHeaps [(convertHeap (-n))] 
+        z (Right n) = oConst $ setHeaps [(convertHeap (-n))]
hunk ./Grin/PointsTo.hs 506
-    funcs = [ (Lf x,cp y) | (x,y) <- Map.toList $ Map.fromListWith mappend $ funcEq eq ] 
+    funcs = [ (Lf x,cp y) | (x,y) <- Map.toList $ Map.fromListWith mappend $ funcEq eq ]
hunk ./Grin/PointsTo.hs 509
-    heapsMap = Map.fromList [ (v,i) | (i,Lh v,_) <- wholeMap ] 
-    funcsMap = Map.fromList [ (v,i) | (i,Lf v,_) <- wholeMap ] 
+    heapsMap = Map.fromList [ (v,i) | (i,Lh v,_) <- wholeMap ]
+    funcsMap = Map.fromList [ (v,i) | (i,Lf v,_) <- wholeMap ]
hunk ./Grin/PointsTo.hs 512
-    convertVar v | otherwise = error $ "convertVar: " ++ show v 
+    convertVar v | otherwise = error $ "convertVar: " ++ show v
hunk ./Grin/PointsTo.hs 518
-        let e (x,c) = OIf (cp x) (Left p) (cp c) 
-        in OUnion mempty (map e (updateEq eq)) 
+        let e (x,c) = OIf (cp x) (Left p) (cp c)
+        in OUnion mempty (map e (updateEq eq))
hunk ./Grin/PointsTo.hs 524
-    cp (Union ps) = mconcat $ map cp ps 
+    cp (Union ps) = mconcat $ map cp ps
hunk ./Grin/PointsTo.hs 528
-    cp (Down x a i) = oVal (ODown (cp x) a i) 
-    cp (DownTup x i) = oVal (ODown (cp x) (toAtom "") i) 
+    cp (Down x a i) = oVal (ODown (cp x) a i)
+    cp (DownTup x i) = oVal (ODown (cp x) (toAtom "") i)
hunk ./Grin/PointsTo.hs 534
-    cp (Complex a [p]) 
+    cp (Complex a [p])
hunk ./Grin/PointsTo.hs 541
-            Just ps -> cp (ps !! i) 
+            Just ps -> cp (ps !! i)
hunk ./Grin/PointsTo.hs 547
-        --f (v,x) 
-        --    | i == length as - 1 =  oVal (OIf (cp v) (Right pt) (cp x)) 
-        --    | otherwise = oVal (ODown (cp (v)) pt i) 
-        f (v,x) = oVal (OIf (cp v) (Right pt) (dpt v x)) 
+        --f (v,x)
+        --    | i == length as - 1 =  oVal (OIf (cp v) (Right pt) (cp x))
+        --    | otherwise = oVal (ODown (cp (v)) pt i)
+        f (v,x) = oVal (OIf (cp v) (Right pt) (dpt v x))
hunk ./Grin/PointsTo.hs 552
-        dpt v x = oVal (ODown (cp (v)) pt i) 
-        Identity (as,_) = findArgsType (grinTypeEnv grin) a 
+        dpt v x = oVal (ODown (cp (v)) pt i)
+        Identity (as,_) = findArgsType (grinTypeEnv grin) a
hunk ./Grin/PointsTo.hs 557
-    
+
hunk ./Grin/PointsTo.hs 560
-findFixpoint'' :: Grin -> HcHash -> PointsToEq -> IO PointsTo 
+findFixpoint'' :: Grin -> HcHash -> PointsToEq -> IO PointsTo
hunk ./Grin/PointsTo.hs 569
-    let zs = map (go ptagMap) xs 
-    rs <- solve' mempty zs 
+    let zs = map (go ptagMap) xs
+    rs <- solve' mempty zs
hunk ./Grin/PointsTo.hs 575
-    return  PointsTo { 
+    return  PointsTo {
hunk ./Grin/PointsTo.hs 585
-            return (mconcat (v:xs)) 
+            return (mconcat (v:xs))
hunk ./Grin/PointsTo.hs 598
-            v <- liftM getNodes $ getVal' env i 
-            let f (t,x) = case Map.lookup t v of 
+            v <- liftM getNodes $ getVal' env i
+            let f (t,x) = case Map.lookup t v of
hunk ./Grin/PointsTo.hs 608
-        cp exp@(ODown x t i) = do     
-            nds <- liftM getNodes $ cu x 
+        cp exp@(ODown x t i) = do
+            nds <- liftM getNodes $ cu x
hunk ./Grin/PointsTo.hs 622
-            vs <- cu p 
-            return $ VsNodes (Map.filterWithKey (\t _ -> tagIsWHNF t) (getNodes vs)) 
+            vs <- cu p
+            return $ VsNodes (Map.filterWithKey (\t _ -> tagIsWHNF t) (getNodes vs))
hunk ./Grin/PointsTo.hs 625
-            vs <- cu v 
+            vs <- cu v
hunk ./Grin/PointsTo.hs 632
-                
-        papp t _ _ | Just x <- Map.lookup t ptagMap = getVal' env x 
+
+        papp t _ _ | Just x <- Map.lookup t ptagMap = getVal' env x
hunk ./Grin/PointsTo.hs 636
-findFixpoint' :: HcHash -> PointsToEq -> IO PointsTo 
-findFixpoint' (HcHash _ mp) eq = fmap cpt (solve' mempty (snds fs)) where 
-    cpt xs = PointsTo { 
+findFixpoint' :: HcHash -> PointsToEq -> IO PointsTo
+findFixpoint' (HcHash _ mp) eq = fmap cpt (solve' mempty (snds fs)) where
+    cpt xs = PointsTo {
hunk ./Grin/PointsTo.hs 646
-    vars = [ (Lv x,cp' y) | (x,y) <- varEq eq ] 
-    heaps = [ (Lh x,\env -> cp' y env >>= \z -> getUpdates env x >>= return . mappend z ) | (x,(_,y)) <- heapEq eq ] ++ cheaps 
+    vars = [ (Lv x,cp' y) | (x,y) <- varEq eq ]
+    heaps = [ (Lh x,\env -> cp' y env >>= \z -> getUpdates env x >>= return . mappend z ) | (x,(_,y)) <- heapEq eq ] ++ cheaps
hunk ./Grin/PointsTo.hs 649
-        z (Right n) = setHeaps [(-n)] 
+        z (Right n) = setHeaps [(-n)]
hunk ./Grin/PointsTo.hs 651
-    funcs = [ (Lf x,cp' y) | (x,y) <- funcEq eq ] 
+    funcs = [ (Lf x,cp' y) | (x,y) <- funcEq eq ]
hunk ./Grin/PointsTo.hs 655
-    heapsMap = Map.fromList [ (v,i) | (Lh v,_) <- heaps | i <- [length vars ..]] 
-    funcsMap = Map.fromList [ (v,i) | (Lf v,_) <- funcs | i <- [length vars + length heaps ..]] 
+    heapsMap = Map.fromList [ (v,i) | (Lh v,_) <- heaps | i <- [length vars ..]]
+    funcsMap = Map.fromList [ (v,i) | (Lf v,_) <- funcs | i <- [length vars + length heaps ..]]
hunk ./Grin/PointsTo.hs 663
-        ep <-  mapM e (updateEq eq) 
+        ep <-  mapM e (updateEq eq)
hunk ./Grin/PointsTo.hs 692
-            xs <- sequence [ maybe (cp e) cp (Map.lookup t mp) |  t <-  Map.keys $ getNodes w] 
+            xs <- sequence [ maybe (cp e) cp (Map.lookup t mp) |  t <-  Map.keys $ getNodes w]
hunk ./Grin/PointsTo.hs 695
-            vs <-  cp p 
-            when (vs == VsBas) $ fail ("VsBas: " ++ show x)  
+            vs <-  cp p
+            when (vs == VsBas) $ fail ("VsBas: " ++ show x)
hunk ./Grin/PointsTo.hs 702
-        cp z@(Arg a i) = do 
+        cp z@(Arg a i) = do
hunk ./Grin/PointsTo.hs 706
-            ep <- return [] 
+            ep <- return []
hunk ./Grin/PointsTo.hs 708
-            ea <- case Map.lookup funcEval fmp of 
+            ea <- case Map.lookup funcEval fmp of
hunk ./Grin/PointsTo.hs 710
-                    ns <-   cp p 
+                    ns <-   cp p
hunk ./Grin/PointsTo.hs 718
-                    ns <-  cp v 
-                    when (ns == VsBas) $ fail ("VsBas: " ++ show z)  
+                    ns <-  cp v
+                    when (ns == VsBas) $ fail ("VsBas: " ++ show z)
hunk ./Grin/PointsTo.hs 728
-            return $ setNodes [(a,ps')] 
+            return $ setNodes [(a,ps')]
hunk ./Grin/PointsTo.hs 731
-        cp (Complex a [p]) 
+        cp (Complex a [p])
hunk ./Grin/PointsTo.hs 733
-                hs <- cp p 
-                vs <- mapM (getVal' env) [ maybe (error "Can't find heap") id $ Map.lookup n heapsMap | n <- Set.toAscList $ getHeaps hs] 
+                hs <- cp p
+                vs <- mapM (getVal' env) [ maybe (error "Can't find heap") id $ Map.lookup n heapsMap | n <- Set.toAscList $ getHeaps hs]
hunk ./Grin/PointsTo.hs 737
-                vs <-  cp p 
-                return $ VsNodes (Map.filterWithKey (\t _ -> tagIsWHNF t) (getNodes vs)) 
-        cp (Complex a [v,x]) 
+                vs <-  cp p
+                return $ VsNodes (Map.filterWithKey (\t _ -> tagIsWHNF t) (getNodes vs))
+        cp (Complex a [v,x])
hunk ./Grin/PointsTo.hs 741
-                vs <-  cp v 
+                vs <-  cp v
hunk ./Grin/PointsTo.hs 748
-                
+
hunk ./Grin/PointsTo.hs 751
-        
hunk ./Grin/PointsTo.hs 752
+
hunk ./Grin/PointsTo.hs 764
-data Value = 
-    Node Atom [ValueSet] 
-    | Bas 
-    | Heap Int 
+data Value =
+    Node Atom [ValueSet]
+    | Bas
+    | Heap Int
hunk ./Grin/PointsTo.hs 777
-    
+
hunk ./Grin/PointsTo.hs 783
-    showsPrec x (Heap n) = showsPrec x n 
+    showsPrec x (Heap n) = showsPrec x n
hunk ./Grin/PointsTo.hs 785
-    showsPrec x (Node a vs) 
-        | a == toAtom "" = tupled  (map (showsPrec x) vs) 
-        | otherwise = showsPrec x a . tupled (map (showsPrec x) vs) 
+    showsPrec x (Node a vs)
+        | a == toAtom "" = tupled  (map (showsPrec x) vs)
+        | otherwise = showsPrec x a . tupled (map (showsPrec x) vs)
hunk ./Grin/PointsTo.hs 790
-    showsPrec x vs' 
+    showsPrec x vs'
hunk ./Grin/PointsTo.hs 822
-findFixpoint :: HcHash -> PointsToEq -> IO PointsTo 
-findFixpoint (HcHash _ mp) eq = fmap cpt (solve mempty fs) where 
-    cpt xs = PointsTo { 
+findFixpoint :: HcHash -> PointsToEq -> IO PointsTo
+findFixpoint (HcHash _ mp) eq = fmap cpt (solve mempty fs) where
+    cpt xs = PointsTo {
hunk ./Grin/PointsTo.hs 831
-    vars = [ (Lv x,cp y) | (x,y) <- varEq eq ] 
-    heaps = [ (Lh x,cp y) | (x,(_,y)) <- heapEq eq ] ++ cheaps 
+    vars = [ (Lv x,cp y) | (x,y) <- varEq eq ]
+    heaps = [ (Lh x,cp y) | (x,(_,y)) <- heapEq eq ] ++ cheaps
hunk ./Grin/PointsTo.hs 834
-        z (Right n) = valueSet [Heap (-n)] 
+        z (Right n) = valueSet [Heap (-n)]
hunk ./Grin/PointsTo.hs 836
-    funcs = [ (Lf x,cp y) | (x,y) <- funcEq eq ] 
+    funcs = [ (Lf x,cp y) | (x,y) <- funcEq eq ]
hunk ./Grin/PointsTo.hs 839
-    cp (Variable v) = getVal (Lv v) 
+    cp (Variable v) = getVal (Lv v)
hunk ./Grin/PointsTo.hs 844
-        vs <- fmap valueSetToList $ cp p 
+        vs <- fmap valueSetToList $ cp p
hunk ./Grin/PointsTo.hs 847
-        vs <- fmap valueSetToList $ cp p 
+        vs <- fmap valueSetToList $ cp p
hunk ./Grin/PointsTo.hs 849
-    cp (Arg a i) = do 
+    cp (Arg a i) = do
hunk ./Grin/PointsTo.hs 853
-        ea <- case Map.lookup funcEval fmp of 
+        ea <- case Map.lookup funcEval fmp of
hunk ./Grin/PointsTo.hs 855
-                ns <- fmap valueSetToList $  cp p 
+                ns <- fmap valueSetToList $  cp p
hunk ./Grin/PointsTo.hs 860
-        ep <- case Map.lookup funcApply fmp of 
+        ep <- case Map.lookup funcApply fmp of
hunk ./Grin/PointsTo.hs 862
-                ns <- fmap valueSetToList $ cp v 
+                ns <- fmap valueSetToList $ cp v
hunk ./Grin/PointsTo.hs 870
-        return $ valueSet [Node a ps'] 
+        return $ valueSet [Node a ps']
hunk ./Grin/PointsTo.hs 873
-        return $ valueSet [Node (toAtom "") ps'] 
-    cp (Complex a [p]) 
+        return $ valueSet [Node (toAtom "") ps']
+    cp (Complex a [p])
hunk ./Grin/PointsTo.hs 876
-            vs <- fmap valueSetToList $  cp p 
-            vs <- mapM getVal [ Lh n | Heap n <- vs] 
+            vs <- fmap valueSetToList $  cp p
+            vs <- mapM getVal [ Lh n | Heap n <- vs]
hunk ./Grin/PointsTo.hs 880
-            vs <- fmap valueSetToList $  cp p 
+            vs <- fmap valueSetToList $  cp p
hunk ./Grin/PointsTo.hs 882
-    cp (Complex a [v,x]) 
+    cp (Complex a [v,x])
hunk ./Grin/PointsTo.hs 884
-            vs <- fmap valueSetToList $  cp v 
-            x' <- cp x 
-            xs <- sequence [ papp (fromAtom t) as x' | Node t as <- vs, tagIsPartialAp t ]  
+            vs <- fmap valueSetToList $  cp v
+            x' <- cp x
+            xs <- sequence [ papp (fromAtom t) as x' | Node t as <- vs, tagIsPartialAp t ]
hunk ./Grin/PointsTo.hs 888
-            
+
hunk ./Grin/PointsTo.hs 891
-findFixpoint :: HcHash -> PointsToEq -> IO PointsTo 
-findFixpoint (HcHash _ mp) eq = fmap cpt (solve mempty fs) where 
-    cpt xs = PointsTo { 
+findFixpoint :: HcHash -> PointsToEq -> IO PointsTo
+findFixpoint (HcHash _ mp) eq = fmap cpt (solve mempty fs) where
+    cpt xs = PointsTo {
hunk ./Grin/PointsTo.hs 900
-    vars = [ (Lv x,cp y) | (x,y) <- varEq eq ] 
-    heaps = [ (Lh x,cp y >>= \z -> getUpdates x >>= return . mappend z ) | (x,(_,y)) <- heapEq eq ] ++ cheaps 
+    vars = [ (Lv x,cp y) | (x,y) <- varEq eq ]
+    heaps = [ (Lh x,cp y >>= \z -> getUpdates x >>= return . mappend z ) | (x,(_,y)) <- heapEq eq ] ++ cheaps
hunk ./Grin/PointsTo.hs 903
-        z (Right n) = setHeaps [(-n)] 
+        z (Right n) = setHeaps [(-n)]
hunk ./Grin/PointsTo.hs 905
-    funcs = [ (Lf x,cp y) | (x,y) <- funcEq eq ] 
+    funcs = [ (Lf x,cp y) | (x,y) <- funcEq eq ]
hunk ./Grin/PointsTo.hs 909
-                ns <- cp v 
+                ns <- cp v
hunk ./Grin/PointsTo.hs 913
-        ep <-  mapM e (updateEq eq) 
+        ep <-  mapM e (updateEq eq)
hunk ./Grin/PointsTo.hs 916
-    cp (Variable v) = getVal (Lv v) 
+    cp (Variable v) = getVal (Lv v)
hunk ./Grin/PointsTo.hs 921
-        vs <-  cp p 
-        when (vs == VsBas) $ fail ("VsBas: " ++ show x)  
+        vs <-  cp p
+        when (vs == VsBas) $ fail ("VsBas: " ++ show x)
hunk ./Grin/PointsTo.hs 928
-    cp z@(Arg a i) = do 
+    cp z@(Arg a i) = do
hunk ./Grin/PointsTo.hs 932
-        ep <- return [] 
+        ep <- return []
hunk ./Grin/PointsTo.hs 934
-        ea <- case Map.lookup funcEval fmp of 
+        ea <- case Map.lookup funcEval fmp of
hunk ./Grin/PointsTo.hs 936
-                ns <-   cp p 
+                ns <-   cp p
hunk ./Grin/PointsTo.hs 944
-                ns <-  cp v 
-                when (ns == VsBas) $ fail ("VsBas: " ++ show z)  
+                ns <-  cp v
+                when (ns == VsBas) $ fail ("VsBas: " ++ show z)
hunk ./Grin/PointsTo.hs 955
-        return $ setNodes [(a,ps')] 
+        return $ setNodes [(a,ps')]
hunk ./Grin/PointsTo.hs 958
-    cp (Complex a [p]) 
+    cp (Complex a [p])
hunk ./Grin/PointsTo.hs 960
-            hs <- cp p 
-            vs <- mapM getVal [ Lh n | n <- Set.toAscList $ getHeaps hs] 
+            hs <- cp p
+            vs <- mapM getVal [ Lh n | n <- Set.toAscList $ getHeaps hs]
hunk ./Grin/PointsTo.hs 964
-            vs <-  cp p 
-            return $ VsNodes (Map.filterWithKey (\t _ -> tagIsWHNF t) (getNodes vs)) 
-    cp (Complex a [v,x]) 
+            vs <-  cp p
+            return $ VsNodes (Map.filterWithKey (\t _ -> tagIsWHNF t) (getNodes vs))
+    cp (Complex a [v,x])
hunk ./Grin/PointsTo.hs 968
-            vs <-  cp v 
-            x' <- cp x 
-            xs <- sequence [ papp (fromAtom t) as x' | (t,as) <- Map.toList (getNodes vs), tagIsPartialAp t ]  
+            vs <-  cp v
+            x' <- cp x
+            xs <- sequence [ papp (fromAtom t) as x' | (t,as) <- Map.toList (getNodes vs), tagIsPartialAp t ]
hunk ./Grin/PointsTo.hs 972
-            
+
hunk ./Grin/PointsTo.hs 975
-    
+
hunk ./Grin/Primitives.hs 15
-    n = toAtom $ "b" ++ name 
+    n = toAtom $ "b" ++ name
hunk ./Grin/Primitives.hs 24
-    n = toAtom $ "b" ++ name 
+    n = toAtom $ "b" ++ name
hunk ./Grin/Primitives.hs 30
-    n = toAtom $ "@" ++ name 
+    n = toAtom $ "@" ++ name
hunk ./Grin/Primitives.hs 34
-    f [] e = e 
-    f ((a@(Var n _)):as) e = Return a :>>= NodeC tag [var n] :-> f as e 
+    f [] e = e
+    f ((a@(Var n _)):as) e = Return a :>>= NodeC tag [var n] :-> f as e
hunk ./Grin/Primitives.hs 41
-    n = toAtom $ "@" ++ name 
+    n = toAtom $ "@" ++ name
hunk ./Grin/Primitives.hs 44
-    f ((a@(Var (V n) _)):as) e = Return a :>>= NodeC tag [var n] :-> f as e 
+    f ((a@(Var (V n) _)):as) e = Return a :>>= NodeC tag [var n] :-> f as e
hunk ./Grin/Primitives.hs 51
-    n = toAtom $ "@" ++ name 
+    n = toAtom $ "@" ++ name
hunk ./Grin/Primitives.hs 53
-    f [] e = e 
-    f ((a@(Var (V n) _)):as) e = Return a :>>= NodeC tag [var n] :-> f as e 
+    f [] e = e
+    f ((a@(Var (V n) _)):as) e = Return a :>>= NodeC tag [var n] :-> f as e
hunk ./Grin/Primitives.hs 58
-    
+
hunk ./Grin/Primitives.hs 61
-    n = toAtom $ "@" ++ name 
+    n = toAtom $ "@" ++ name
hunk ./Grin/Primitives.hs 63
-    f [] e = 
-        e :>>= Tup rs' :-> 
-        Store (NodeC tag [rs' !! 0]) :>>= p1 :-> 
-        Store (NodeC tag [rs' !! 1]) :>>= p2 :-> 
+    f [] e =
+        e :>>= Tup rs' :->
+        Store (NodeC tag [rs' !! 0]) :>>= p1 :->
+        Store (NodeC tag [rs' !! 1]) :>>= p2 :->
hunk ./Grin/Primitives.hs 68
-    f ((a@(Var (V n) _)):as) e = Return a :>>= NodeC tag [var n] :-> f as e 
+    f ((a@(Var (V n) _)):as) e = Return a :>>= NodeC tag [var n] :-> f as e
hunk ./Grin/Primitives.hs 75
---    f [Lit x tx,Lit y ty] | tx == ty = return $  let (a,b) = (quotRem x y) in Tup [Lit a tx, Lit b tx]  
+--    f [Lit x tx,Lit y ty] | tx == ty = return $  let (a,b) = (quotRem x y) in Tup [Lit a tx, Lit b tx]
hunk ./Grin/Primitives.hs 82
---    f [Lit x tx,Lit y ty] | tx == ty = return $  Lit (x `op` y) tx  
+--    f [Lit x tx,Lit y ty] | tx == ty = return $  Lit (x `op` y) tx
hunk ./Grin/Primitives.hs 93
-    f [NodeC tx [Lit x tx'],NodeC ty [Lit y ty']] 
-        | tx == ty && tx' == ty' = return $ NodeC tx [Lit (x + y) tx']  
+    f [NodeC tx [Lit x tx'],NodeC ty [Lit y ty']]
+        | tx == ty && tx' == ty' = return $ NodeC tx [Lit (x + y) tx']
hunk ./Grin/Primitives.hs 96
-    f [NodeC tx [Lit x tx'],NodeC ty [Lit y ty']] 
-        | tx == ty && tx' == ty' = return $ NodeC tx [Lit (x - y) tx']  
+    f [NodeC tx [Lit x tx'],NodeC ty [Lit y ty']]
+        | tx == ty && tx' == ty' = return $ NodeC tx [Lit (x - y) tx']
hunk ./Grin/Primitives.hs 100
---    f [Lit x tx] = return $ Lit (negate x) tx  
+--    f [Lit x tx] = return $ Lit (negate x) tx
hunk ./Grin/Primitives.hs 103
-    f [Lit x tx,Lit y ty] 
-        | tx == ty  = return $ if x == y then vTrue else vFalse 
+    f [Lit x tx,Lit y ty]
+        | tx == ty  = return $ if x == y then vTrue else vFalse
hunk ./Grin/Primitives.hs 106
-    f [Lit x tx',Lit y ty'] 
+    f [Lit x tx',Lit y ty']
hunk ./Grin/Primitives.hs 115
---    primEq "Int", 
---    primEq "Char", 
---    primCompare "Int", 
---    primCompare "Char", 
---    primTimes, 
+--    primEq "Int",
+--    primEq "Char",
+--    primCompare "Int",
+--    primCompare "Char",
+--    primTimes,
hunk ./Grin/Primitives.hs 124
-    ] 
+    ]
hunk ./Grin/Primitives.hs 133
---    createPrim "error" [p1] (Error "error call" TyNode), 
+--    createPrim "error" [p1] (Error "error call" TyNode),
hunk ./Grin/Primitives.hs 139
-    gEval p1 :>>= NodeC c1 [Var v2 t1] :-> 
-    Cast (Var v2 t1) t2 :>>= Var v3 t2 :-> 
+    gEval p1 :>>= NodeC c1 [Var v2 t1] :->
+    Cast (Var v2 t1) t2 :>>= Var v3 t2 :->
hunk ./Grin/Primitives.hs 161
-    Store (NodeC cChar [c1]) :>>= p2 :-> 
+    Store (NodeC cChar [c1]) :>>= p2 :->
hunk ./Grin/Primitives.hs 167
-    gEval p1 :>>= NodeC cChar [c1] :-> 
+    gEval p1 :>>= NodeC cChar [c1] :->
hunk ./Grin/Primitives.hs 175
--- binOp fn = 
+-- binOp fn =
hunk ./Grin/Primitives.hs 209
-    as' = [ Var | a <- as ++ [TyNode] | v <- [v1 ..]] 
-    exp = Prim Primitive { primName = pn, primType =  
-    pn = toAtom $ "@" ++ name 
+    as' = [ Var | a <- as ++ [TyNode] | v <- [v1 ..]]
+    exp = Prim Primitive { primName = pn, primType =
+    pn = toAtom $ "@" ++ name
hunk ./Grin/Primitives.hs 213
-    
+
hunk ./Grin/Show.hs 26
-pVar v  = pVal v <+> operator "<- " 
+pVar v  = pVal v <+> operator "<- "
hunk ./Grin/Show.hs 28
-pVar' v  = pVal v <+> operator "<- " 
+pVar' v  = pVal v <+> operator "<- "
hunk ./Grin/Show.hs 41
-keyword = bold . text 
+keyword = bold . text
hunk ./Grin/Show.hs 85
-pVal (Const v) = char '&' <> pVal v 
+pVal (Const v) = char '&' <> pVal v
hunk ./Grin/Show.hs 100
-    when (not $ null cafs) $ do 
+    when (not $ null cafs) $ do
hunk ./Grin/Show.hs 102
-        mapM_ (putErrLn) $ map (\(x,y) -> show x ++ " = " ++  render (prettyVal y))  cafs 
+        mapM_ (putErrLn) $ map (\(x,y) -> show x ++ " = " ++  render (prettyVal y))  cafs
hunk ./Grin/Simplify.hs 18
--- perform a number of simple simplifications. 
+-- perform a number of simple simplifications.
hunk ./Grin/Simplify.hs 42
-        x <- m 
+        x <- m
hunk ./Grin/Simplify.hs 54
-    gv (p,Case x ds) = do 
-        (env,_) <- get 
+    gv (p,Case x ds) = do
+        (env,_) <- get
hunk ./Grin/Simplify.hs 63
-    gv (NodeC t xs,Return (NodeC t' xs')) | t == t' = do 
+    gv (NodeC t xs,Return (NodeC t' xs')) | t == t' = do
hunk ./Grin/Simplify.hs 66
-    gv (NodeC t xs,Return (NodeC t' xs')) | t /= t' = do 
+    gv (NodeC t xs,Return (NodeC t' xs')) | t /= t' = do
hunk ./Grin/Simplify.hs 70
-        (env,_) <- get 
+        (env,_) <- get
hunk ./Grin/Simplify.hs 78
-                e <- inline e 
+                e <- inline e
hunk ./Grin/Simplify.hs 83
-    doInline (a,fn) 
+    doInline (a,fn)
hunk ./Grin/Simplify.hs 85
-        --  | "fInstance@" `isPrefixOf` n = True 
+        --  | "fInstance@" `isPrefixOf` n = True
hunk ./Grin/Simplify.hs 88
-      --  where n = fromAtom a 
-    inline app@(App fn as) 
+      --  where n = fromAtom a
+    inline app@(App fn as)
hunk ./Grin/Simplify.hs 97
-        case Map.lookup x ce of 
+        case Map.lookup x ce of
hunk ./Grin/Simplify.hs 102
-    --getCS (b,app@(App ev _)) | ev == funcEval = return $ Map.single app (Return b)  
-    --getCS (b,app@(App ev _)) | ev == funcApply = return $ Map.single app (Return b)  
+    --getCS (b,app@(App ev _)) | ev == funcEval = return $ Map.single app (Return b)
+    --getCS (b,app@(App ev _)) | ev == funcApply = return $ Map.single app (Return b)
hunk ./Grin/Simplify.hs 105
-    getCS (b,app@App{})  = return $ Map.singleton app (Return b)  
-    getCS (b@Var {},Store v@(Var _ _)) = return $ Map.singleton (App funcEval [b]) (Return v)     -- TODO - only works if node stores have always been evaluated. 
-    getCS (b@Var {},Store v@(NodeC t _)) | tagIsWHNF t, t /= tagHole = return $ Map.fromList [(Store v,Return b),(Fetch b,Return v),(App funcEval [b],Return v)]  
-    getCS (b@Var {},Store v@(NodeC t _)) | t /= tagHole = return $ Map.fromList [(Store v,Return b)]  
+    getCS (b,app@App{})  = return $ Map.singleton app (Return b)
+    getCS (b@Var {},Store v@(Var _ _)) = return $ Map.singleton (App funcEval [b]) (Return v)     -- TODO - only works if node stores have always been evaluated.
+    getCS (b@Var {},Store v@(NodeC t _)) | tagIsWHNF t, t /= tagHole = return $ Map.fromList [(Store v,Return b),(Fetch b,Return v),(App funcEval [b],Return v)]
+    getCS (b@Var {},Store v@(NodeC t _)) | t /= tagHole = return $ Map.fromList [(Store v,Return b)]
hunk ./Grin/Simplify.hs 125
---varBind (NodeV v vs) (NodeV t vs') = do 
---    be <- sequence $  zipWith varBind vs vs' 
+--varBind (NodeV v vs) (NodeV t vs') = do
+--    be <- sequence $  zipWith varBind vs vs'
hunk ./Grin/Simplify.hs 129
-varBind grin (NodeC t vs) (NodeC t' vs') | t == t' = do 
-    liftM mconcat $ sequence $  zipWith (varBind grin) vs vs' 
+varBind grin (NodeC t vs) (NodeC t' vs') | t == t' = do
+    liftM mconcat $ sequence $  zipWith (varBind grin) vs vs'
hunk ./Grin/Simplify.hs 138
-    f _ (_ :-> Case {}) = False 
+    f _ (_ :-> Case {}) = False
hunk ./Grin/Simplify.hs 146
- f x| App fn' _ <- x , fn /= fn' = True 
+ f x| App fn' _ <- x , fn /= fn' = True
hunk ./Grin/Simplify.hs 154
-    | z :>>= _ :-> Return {} <- x = f z 
-    | Return {} :>>= _ :-> z <- x = f z 
-    | Fetch {} :>>= _ :-> z <- x = f z 
-    | Store {} :>>= _ :-> z <- x = f z 
-    | Prim {} :>>= _ :-> z <- x = f z 
-    | Update {} :>>= _ :-> z <- x = f z 
-    | z :>>= _ :-> Error {} <- x = f z 
-    | Cast {} :>>= _ :-> z <- x = f z 
-    | z :>>= _ :-> Cast {} <- x = f z 
+    | z :>>= _ :-> Return {} <- x = f z
+    | Return {} :>>= _ :-> z <- x = f z
+    | Fetch {} :>>= _ :-> z <- x = f z
+    | Store {} :>>= _ :-> z <- x = f z
+    | Prim {} :>>= _ :-> z <- x = f z
+    | Update {} :>>= _ :-> z <- x = f z
+    | z :>>= _ :-> Error {} <- x = f z
+    | Cast {} :>>= _ :-> z <- x = f z
+    | z :>>= _ :-> Cast {} <- x = f z
hunk ./Grin/Simplify.hs 175
-        put $ (Set.union uv (freeVars x)) 
+        put $ (Set.union uv (freeVars x))
hunk ./Grin/Simplify.hs 178
-        (uv) <- get 
-        if  any (`Set.member` uv) (freeVars v) then 
+        (uv) <- get
+        if  any (`Set.member` uv) (freeVars v) then
hunk ./Grin/Simplify.hs 184
-        put $ (Set.union uv (freeVars x)) 
+        put $ (Set.union uv (freeVars x))
hunk ./Grin/Val.hs 6
-import VConsts 
+import VConsts
hunk ./Grin/Val.hs 19
-    toVal :: a -> Val 
+    toVal :: a -> Val
hunk ./Grin/Val.hs 24
-    fromVal :: Monad m => Val -> m a 
-    fromUnVal :: Monad m => Val -> m a 
+    fromVal :: Monad m => Val -> m a
+    fromUnVal :: Monad m => Val -> m a
hunk ./Grin/Val.hs 43
-    toVal (x,y) = NodeC (toAtom "CPrelude.(,)") [x,y] 
+    toVal (x,y) = NodeC (toAtom "CPrelude.(,)") [x,y]
hunk ./Grin/Val.hs 59
-    fromVal n = fail $ "Val is not Int: " ++ show n 
+    fromVal n = fail $ "Val is not Int: " ++ show n
hunk ./Grin/Val.hs 61
-    fromUnVal n = fail $ "Val is not UnInt: " ++ show n 
+    fromUnVal n = fail $ "Val is not UnInt: " ++ show n
hunk ./Grin/Val.hs 66
-    fromUnVal n = fail $ "Val is not UnChar: " ++ show n 
+    fromUnVal n = fail $ "Val is not UnChar: " ++ show n
hunk ./Grin/Val.hs 81
-    
-instance FromVal Bool  where 
-    fromVal n 
-        | n == toVal True = return True 
-        | n == toVal False = return False 
+
+instance FromVal Bool  where
+    fromVal n
+        | n == toVal True = return True
+        | n == toVal False = return False
hunk ./Grin/Whiz.hs 23
---        (Identity ((NodeC _ vs',fn'),set')) = whiz return return set (NodeC tagHole vs , fn) 
+--        (Identity ((NodeC _ vs',fn'),set')) = whiz return return set (NodeC tagHole vs , fn)
hunk ./Grin/Whiz.hs 28
-        (Identity (lm',set')) = fizz (grinTypeEnv grin) (\_ x -> x) (return . Just) return set lm 
+        (Identity (lm',set')) = fizz (grinTypeEnv grin) (\_ x -> x) (return . Just) return set lm
hunk ./Grin/Whiz.hs 34
-        (Identity (lm',_)) = whiz (\_ x -> x) (return . Just) return (Right 1) lm 
+        (Identity (lm',_)) = whiz (\_ x -> x) (return . Just) return (Right 1) lm
hunk ./Grin/Whiz.hs 36
-whizExps :: Monad m => (Exp -> m Exp) -> Lam -> m Lam 
-whizExps f l = liftM fst $ whiz (\_ x -> x) (\(p,e) -> f e >>= \e' -> return  (Just (p,e'))) f whizState l  
+whizExps :: Monad m => (Exp -> m Exp) -> Lam -> m Lam
+whizExps f l = liftM fst $ whiz (\_ x -> x) (\(p,e) -> f e >>= \e' -> return  (Just (p,e'))) f whizState l
hunk ./Grin/Whiz.hs 50
-whiz :: Monad m => 
+whiz :: Monad m =>
hunk ./Grin/Whiz.hs 57
-whiz sub te tf inState start = res where 
-    res = runStateT (dc mempty start) inState 
+whiz sub te tf inState start = res where
+    res = runStateT (dc mempty start) inState
hunk ./Grin/Whiz.hs 61
-        Return (Tup xs) <- g env a 
+        Return (Tup xs) <- g env a
hunk ./Grin/Whiz.hs 63
-        ts <- lift $ mapM te [(y,Return x) | x <- xs | y <- ys ] 
+        ts <- lift $ mapM te [(y,Return x) | x <- xs | y <- ys ]
hunk ./Grin/Whiz.hs 72
-        z <- f b xs (env' `mappend` senv) 
-        case x of 
-            Just (p',a') -> do 
+        z <- f b xs (env' `mappend` senv)
+        case x of
+            Just (p',a') -> do
hunk ./Grin/Whiz.hs 85
-    g env x = applySubstE env x 
+    g env x = applySubstE env x
hunk ./Grin/Whiz.hs 93
-        
+
hunk ./Grin/Whiz.hs 107
-fizz :: Monad m => 
-    TyEnv -> 
+fizz :: Monad m =>
+    TyEnv ->
hunk ./Grin/Whiz.hs 115
-fizz tyEnv sub te tf inState start = res where 
-    res = runStateT (dc mempty start) inState 
+fizz tyEnv sub te tf inState start = res where
+    res = runStateT (dc mempty start) inState
hunk ./Grin/Whiz.hs 119
-        Return (Tup xs) <- g env a 
+        Return (Tup xs) <- g env a
hunk ./Grin/Whiz.hs 122
-        ts <- lift $ mapM te (reverse [(y,Return x) | x <- xs | y <- ys ]) 
+        ts <- lift $ mapM te (reverse [(y,Return x) | x <- xs | y <- ys ])
hunk ./Grin/Whiz.hs 131
-        z <- f b xs (env' `mappend` senv) 
+        z <- f b xs (env' `mappend` senv)
hunk ./Grin/Whiz.hs 133
-        case x of 
-            Just (p',a') -> do 
+        case x of
+            Just (p',a') -> do
hunk ./Grin/Whiz.hs 145
-    g env x = applySubstE env x 
+    g env x = applySubstE env x
hunk ./Grin/Whiz.hs 155
-applySubstE env x = f x where 
+applySubstE env x = f x where
hunk ./Grin/Whiz.hs 177
-    f (Cast v t) = do 
+    f (Cast v t) = do
hunk ./Grin/Whiz.hs 180
-    f (Case e as) = do 
+    f (Case e as) = do
hunk ./Grin/Whiz.hs 199
-    f Addr {} = error "Address in subst" 
+    f Addr {} = error "Address in subst"
hunk ./Grin/Whiz.hs 202
-renamePattern :: MonadState (WhizState) m => Val ->  m (Val,WhizEnv) 
+renamePattern :: MonadState (WhizState) m => Val ->  m (Val,WhizEnv)
hunk ./Grin/Whiz.hs 206
-        v' <- lift $ newVarName v 
+        v' <- lift $ newVarName v
hunk ./Grin/Whiz.hs 221
-    f Addr {} = error "Address in pattern" 
+    f Addr {} = error "Address in pattern"
hunk ./Grin/Whiz.hs 226
-    s <- get 
-    case s of 
+    s <- get
+    case s of
hunk ./Grin/Whiz.hs 237
-    
+
hunk ./HasSize.hs 16
-    sizeEQ s x = size x == s 
+    sizeEQ s x = size x == s
hunk ./HasSize.hs 21
-     
+
hunk ./HasSize.hs 23
-genSize = fromIntegral . HasSize.size  
+genSize = fromIntegral . HasSize.size
hunk ./HasSize.hs 32
-    
+
hunk ./HasSize.hs 49
-    sizeEQ s (Left x)  = sizeEQ s x 
+    sizeEQ s (Left x)  = sizeEQ s x
hunk ./HasSize.hs 51
-    sizeLT s (Left x)  = sizeLT s x 
+    sizeLT s (Left x)  = sizeLT s x
hunk ./HasSize.hs 53
-    sizeGT s (Left x)  = sizeGT s x 
+    sizeGT s (Left x)  = sizeGT s x
hunk ./Info.hs 23
-        bss = Set.fromList $ map show bs 
+        bss = Set.fromList $ map show bs
hunk ./MapBinaryInstance.hs 12
-        mapM_ (put_ bh) (Map.toList x) 
+        mapM_ (put_ bh) (Map.toList x)
hunk ./MapBinaryInstance.hs 20
-   put_ bh x = put_ bh (fmToList x) 
+   put_ bh x = put_ bh (fmToList x)
hunk ./MonadUtil.hs 6
-import Data.Monoid
hunk ./MonadUtil.hs 22
-    
+
hunk ./MonoidUtil.hs 20
---    mappend (a,b) (c,d) = (mappend a c, mappend b d) 
---    mconcat xs = case unzip xs of (a,b) -> (mconcat a,mconcat b) 
+--    mappend (a,b) (c,d) = (mappend a c, mappend b d)
+--    mconcat xs = case unzip xs of (a,b) -> (mconcat a,mconcat b)
hunk ./MonoidUtil.hs 25
---    mappend (a,b,c) (a',b',c') = (mappend a a', mappend b b', mappend c c') 
---    mconcat xs = case unzip3 xs of (a,b,c) -> (mconcat a,mconcat b,mconcat c) 
+--    mappend (a,b,c) (a',b',c') = (mappend a a', mappend b b', mappend c c')
+--    mconcat xs = case unzip3 xs of (a,b,c) -> (mconcat a,mconcat b,mconcat c)
hunk ./MonoidUtil.hs 49
-    isEmpty = not 
+    isEmpty = not
hunk ./Name.hs 2
-    NameType(..), 
-    Name, 
-    nameName, 
+    NameType(..),
+    Name,
+    nameName,
hunk ./Name.hs 32
-data NameType = 
-    TypeConstructor 
-    | DataConstructor 
-    | ClassName 
-    | TypeVal 
-    | Val 
-    | SortName  
+data NameType =
+    TypeConstructor
+    | DataConstructor
+    | ClassName
+    | TypeVal
+    | Val
+    | SortName
hunk ./Name.hs 40
-    | RawType 
+    | RawType
hunk ./Name.hs 44
-newtype Name = Name Atom 
+newtype Name = Name Atom
hunk ./Name.hs 68
-    
-    
+
+
hunk ./Name.hs 72
-fromTypishHsName name 
+fromTypishHsName name
hunk ./Name.hs 75
-    where x = head (hsIdentString . hsNameIdent  $ name) 
-fromValishHsName name 
+    where x = head (hsIdentString . hsNameIdent  $ name)
+fromValishHsName name
hunk ./Name.hs 79
-    where x = head (hsIdentString . hsNameIdent  $ name) 
+    where x = head (hsIdentString . hsNameIdent  $ name)
hunk ./Name.hs 82
-    toName :: NameType -> a -> Name 
+    toName :: NameType -> a -> Name
hunk ./Name.hs 90
-    fromName n = (nameType n, nameName n) 
+    fromName n = (nameType n, nameName n)
hunk ./Name.hs 93
-    toName nt (m,i) = Name $ toAtom $ (chr $ fromEnum nt):m ++ "\NUL" ++ i 
+    toName nt (m,i) = Name $ toAtom $ (chr $ fromEnum nt):m ++ "\NUL" ++ i
hunk ./Name.hs 96
-        mi  | Qual (Module m) (HsIdent i) <- nn = (m,i) 
+        mi  | Qual (Module m) (HsIdent i) <- nn = (m,i)
hunk ./Name.hs 100
-    toName nt i = Name $ toAtom $ (chr $ fromEnum nt):"\NUL" ++ i 
+    toName nt i = Name $ toAtom $ (chr $ fromEnum nt):"\NUL" ++ i
hunk ./Name.hs 103
-        (m,i)  | Qual (Module m) (HsIdent i) <- nn = (m ++ ".",i) 
+        (m,i)  | Qual (Module m) (HsIdent i) <- nn = (m ++ ".",i)
hunk ./Name.hs 113
-toUnqualified n = case fromName n of 
+toUnqualified n = case fromName n of
hunk ./Name.hs 118
-qualifyName m n = case fromName n of 
-    (t,UnQual n) -> toName t (Qual m n) 
+qualifyName m n = case fromName n of
+    (t,UnQual n) -> toName t (Qual m n)
hunk ./Name.hs 123
-setModule m n = qualifyName m  $ toUnqualified n 
+setModule m n = qualifyName m  $ toUnqualified n
+
hunk ./Name.hs 126
-    
-parseName :: NameType -> String -> Name 
+parseName :: NameType -> String -> Name
hunk ./Name.hs 128
-    sn = (split (== '.') name) 
-    (ms,ns) = span validMod (init sn) 
-    validMod (c:cs) = isUpper c && all (\c -> isAlphaNum c || c `elem` "_'") cs 
+    sn = (split (== '.') name)
+    (ms,ns) = span validMod (init sn)
+    validMod (c:cs) = isUpper c && all (\c -> isAlphaNum c || c `elem` "_'") cs
hunk ./Name.hs 132
-    
-    
+
+
hunk ./Name.hs 137
-nameType (Name a) = toEnum (ord (head (toString a))) 
+nameType (Name a) = toEnum (ord (head (toString a)))
hunk ./Name.hs 158
---unboxedNameTuple t n = toName t $ "(#": replicate (n - 1) ',' ++ "#)" 
+--unboxedNameTuple t n = toName t $ "(#": replicate (n - 1) ',' ++ "#)"
hunk ./Name.hs 162
-    _ -> fail $ "Not unboxed tuple: " ++ show n 
+    _ -> fail $ "Not unboxed tuple: " ++ show n
hunk ./Name.hs 196
-instance ClassNames Name where 
+instance ClassNames Name where
hunk ./Name.hs 216
-nameValue m n = atomIndex $ toAtom (toName Val (m,n)) 
+nameValue m n = atomIndex $ toAtom (toName Val (m,n))
hunk ./NameMonad.hs 1
-module NameMonad(NameMonad(..), GenName(..), NameMT, runNameMT, freeNames) where 
+module NameMonad(NameMonad(..), GenName(..), NameMT, runNameMT, freeNames) where
hunk ./NameMonad.hs 14
-class Monad m => NameMonad n m | m -> n  where 
+class Monad m => NameMonad n m | m -> n  where
hunk ./NameMonad.hs 18
-    newName :: m n     
+    newName :: m n
hunk ./NameMonad.hs 20
-    newNameFrom :: [n] -> m n 
+    newNameFrom :: [n] -> m n
hunk ./NameMonad.hs 22
-    uniqueName :: n -> m n 
+    uniqueName :: n -> m n
hunk ./NameMonad.hs 40
-    
+
hunk ./NameMonad.hs 46
-    addNames n = lift $ addNames n 
-    newName = lift  newName 
+    addNames n = lift $ addNames n
+    newName = lift  newName
hunk ./NameMonad.hs 66
-    addNames ns = NameMT $ do 
+    addNames ns = NameMT $ do
hunk ./NameMonad.hs 72
-        (used,bound) <- get 
+        (used,bound) <- get
hunk ./NameMonad.hs 78
-        put (Set.insert nn used, Set.insert nn bound) 
+        put (Set.insert nn used, Set.insert nn bound)
hunk ./NameMonad.hs 83
-        
+
hunk ./NameMonad.hs 85
-    --    fmap Set.toList get 
-        
-    
+    --    fmap Set.toList get
+
+
hunk ./Number.hs 4
-import Name 
+import Name
hunk ./Number.hs 12
-    typeType :: NumType, 
+    typeType :: NumType,
hunk ./Number.hs 17
-signed v n = (toName RawType v,TypeInfo Signed (Known n)) 
-unsigned v n = (toName RawType v,TypeInfo Unsigned (Known n)) 
+signed v n = (toName RawType v,TypeInfo Signed (Known n))
+unsigned v n = (toName RawType v,TypeInfo Unsigned (Known n))
hunk ./Number.hs 22
-    signed "int8_t" 1, 
-    signed "int16_t" 2, 
-    signed "int32_t" 4, 
-    signed "int64_t" 8, 
+    signed "int8_t" 1,
+    signed "int16_t" 2,
+    signed "int32_t" 4,
+    signed "int64_t" 8,
hunk ./Number.hs 28
-    unsigned "uint8_t" 1, 
-    unsigned "uint16_t" 2, 
-    unsigned "uint32_t" 4, 
-    unsigned "uint64_t" 8, 
+    unsigned "uint8_t" 1,
+    unsigned "uint16_t" 2,
+    unsigned "uint32_t" 4,
+    unsigned "uint64_t" 8,
hunk ./Number.hs 44
- -}   
-    
-newtype Number = Number Rational 
+ -}
+
+newtype Number = Number Rational
hunk ./Number.hs 57
-    showsPrec n (Number r) = case denominator r of 
+    showsPrec n (Number r) = case denominator r of
hunk ./Number.hs 62
-toIntegral (Number r) = case denominator r of 
+toIntegral (Number r) = case denominator r of
hunk ./Number.hs 66
---instance Show Number where 
+--instance Show Number where
hunk ./Number.hs 69
---    numberValue :: Ratio, 
---    numberType :: Atom 
+--    numberValue :: Ratio,
+--    numberType :: Atom
hunk ./PackedString.hs 6
--- 
+--
hunk ./PackedString.hs 15
--- Original GHC implementation by Bryan O\'Sullivan, 
+-- Original GHC implementation by Bryan O\'Sullivan,
hunk ./PackedString.hs 27
-        -- toString,   
+        -- toString,
hunk ./PackedString.hs 99
-    mappend x y = appendPS x y 
+    mappend x y = appendPS x y
hunk ./PackedString.hs 216
-foldrPS f b (PS (UArray _ (I# e) ba)) = unpackFoldrUtf8# ba (e +# 1#) (\x y -> f (C# x)  y) b 
+foldrPS f b (PS (UArray _ (I# e) ba)) = unpackFoldrUtf8# ba (e +# 1#) (\x y -> f (C# x)  y) b
hunk ./PackedString.hs 223
-    f m (c:cs) = n `seq` f n cs where 
-        n = ((m `shiftL` 5) + m ) `xor` fromIntegral c 
+    f m (c:cs) = n `seq` f n cs where
+        n = ((m `shiftL` 5) + m ) `xor` fromIntegral c
hunk ./PackedString.hs 228
-    f m c = ((m `shiftL` 5) + m ) `xor` I# (ord# c) 
+    f m c = ((m `shiftL` 5) + m ) `xor` I# (ord# c)
hunk ./PackedString.hs 233
-    f m c 
+    f m c
hunk ./PackedString.hs 235
-        | otherwise = f (((m `uncheckedShiftL#` 5#) `plusWord#` m ) `xor#`  (((indexWord8Array# ba c)))) (c +# 1#) 
-            
-       
+        | otherwise = f (((m `uncheckedShiftL#` 5#) `plusWord#` m ) `xor#`  (((indexWord8Array# ba c)))) (c +# 1#)
+
+
hunk ./PackedString.hs 314
-  * splitPS x ls = ls'   
+  * splitPS x ls = ls'
hunk ./PackedString.hs 331
-  
---  splitify n 
+
+--  splitify n
hunk ./PackedString.hs 341
---      else 
+--      else
hunk ./PackedString.hs 345
---first_pos_that_satisfies pred ps len n = 
+--first_pos_that_satisfies pred ps len n =
hunk ./PackedString.hs 382
--- and then using 'packString'.  
+-- and then using 'packString'.
hunk ./PackedString.hs 384
--- NOTE: as with 'hPutPS', the string representation in the file is 
+-- NOTE: as with 'hPutPS', the string representation in the file is
hunk ./PackedString.hs 397
-    uc n (x:xs) 
-        | ord x <= 0x7f = uc (n +# 1#) xs 
+    uc n (x:xs)
+        | ord x <= 0x7f = uc (n +# 1#) xs
hunk ./PackedString.hs 425
-unpackFoldrUtf8# :: ByteArray# -> Int# -> (Char# -> b -> b) -> b -> b 
+unpackFoldrUtf8# :: ByteArray# -> Int# -> (Char# -> b -> b) -> b -> b
hunk ./PackedString.hs 457
-      | ch `leChar#` '\xEF'# = 
+      | ch `leChar#` '\xEF'# =
hunk ./PackedString.hs 461
-      | otherwise            = 
+      | otherwise            =
hunk ./PackedString.hs 480
-fromUTF xs = fromUTF' (map fromIntegral xs) where 
+fromUTF xs = fromUTF' (map fromIntegral xs) where
hunk ./PackedString.hs 482
-    fromUTF' (all@(x:xs)) 
+    fromUTF' (all@(x:xs))
hunk ./PackedString.hs 495
-    threeBytes _ = error "fromUTF: illegal three byte sequence" 
-    
+    threeBytes _ = error "fromUTF: illegal three byte sequence"
+
hunk ./Relation.hs 11
-domain r = fromAscList (map fst (toAscList r)) 
+domain r = fromAscList (map fst (toAscList r))
hunk ./Relation.hs 15
-restrictDomain f r = Set.filter (f . fst) r 
-restrictRange f r = Set.filter (f . snd) r 
+restrictDomain f r = Set.filter (f . fst) r
+restrictRange f r = Set.filter (f . snd) r
hunk ./Relation.hs 26
-applyRelation r a = map snd (toList $ restrictDomain (== a) r) 
+applyRelation r a = map snd (toList $ restrictDomain (== a) r)
hunk ./Relation.hs 29
-toRelationList rel = [ (x, applyRelation rel x) | x <- toList (domain rel)] 
+toRelationList rel = [ (x, applyRelation rel x) | x <- toList (domain rel)]
hunk ./SameShape.hs 14
-    
+
hunk ./Seq.hs 70
-singleton x = single x  
+singleton x = single x
hunk ./Seq.hs 104
-concat :: Seq (Seq a) -> Seq a 
-concat (Seq f) = (foldr Seq.append Seq.empty (f [])) 
+concat :: Seq (Seq a) -> Seq a
+concat (Seq f) = (foldr Seq.append Seq.empty (f []))
hunk ./Stats.hs 25
-    
-                    
+
+
hunk ./Stats.hs 39
-    mapM_ f ls 
-    
+    mapM_ f ls
+
hunk ./Stats.hs 43
-    h <- H.new (==) (fromIntegral . atomIndex) 
+    h <- H.new (==) (fromIntegral . atomIndex)
hunk ./Stats.hs 49
-    xs <- H.toList h 
+    xs <- H.toList h
hunk ./Stats.hs 54
-getTicks (Stats r _)  = readIORef r 
+getTicks (Stats r _)  = readIORef r
hunk ./Stats.hs 89
-    --[Node (concat $ intersperse "." (xs),y) [] | (xs,y) <- xs] 
+    --[Node (concat $ intersperse "." (xs),y) [] | (xs,y) <- xs]
hunk ./Stats.hs 106
-        
+
hunk ./Stats.hs 110
-runStatIO :: MonadIO m =>  Stats -> StatT m a -> m a 
+runStatIO :: MonadIO m =>  Stats -> StatT m a -> m a
hunk ./Stats.hs 116
-instance MonadStats IO where 
+instance MonadStats IO where
hunk ./Stats.hs 120
-        
+
hunk ./Stats.hs 122
-    
+
hunk ./Stats.hs 130
-instance DocLike d => PPrint d Stat where 
+instance DocLike d => PPrint d Stat where
hunk ./Stats.hs 141
-    
-    
+
+
hunk ./Stats.hs 145
-    
-runStatT (StatT m) =  runWriterT m 
+
+runStatT (StatT m) =  runWriterT m
hunk ./Stats.hs 151
--- These are inlined so the 'toAtom' can become a caf and be shared 
+-- These are inlined so the 'toAtom' can become a caf and be shared
hunk ./Stats.hs 158
---    ask = lift $ ask 
+--    ask = lift $ ask
hunk ./Stats.hs 167
-instance MonadReader r m => MonadReader r (StatT m) where 
+instance MonadReader r m => MonadReader r (StatT m) where
hunk ./Stats.hs 170
-    
+
hunk ./Stats.hs 173
-    
+
hunk ./UTF8.hs 27
-fromUTF xs = fromUTF' (map fromIntegral xs) where 
+fromUTF xs = fromUTF' (map fromIntegral xs) where
hunk ./UTF8.hs 29
-    fromUTF' (all@(x:xs)) 
+    fromUTF' (all@(x:xs))
hunk ./UTF8.hs 42
-    threeBytes _ = error "fromUTF: illegal three byte sequence" 
-    
+    threeBytes _ = error "fromUTF: illegal three byte sequence"
+
hunk ./UniqueMonad.hs 12
-instance UniqueProducer IO where 
+instance UniqueProducer IO where
hunk ./UniqueMonad.hs 32
-execUniq1 x = fst $ runUniq 1 x  
+execUniq1 x = fst $ runUniq 1 x
hunk ./UniqueMonad.hs 36
-execUniq st x = fst $ runUniq st x  
+execUniq st x = fst $ runUniq st x
hunk ./Unparse.hs 10
-    unparseConcat = foldl1 unparseCat 
+    unparseConcat = foldl1 unparseCat
hunk ./Unparse.hs 49
-bop f s a (b,bf) | not (lts R f bf)  = bop f s a (mkatom (b,bf)) 
+bop f s a (b,bf) | not (lts R f bf)  = bop f s a (mkatom (b,bf))
hunk ./Unparse.hs 105
-abcdr = foldl1 plus [a,b,c,d] 
+abcdr = foldl1 plus [a,b,c,d]
hunk ./Unparse.hs 112
-g = minus (plus (times (plus a b) (plus b c)) abcdr) abcdl  
+g = minus (plus (times (plus a b) (plus b c)) abcdr) abcdl
hunk ./VConsts.hs 8
-    tInt :: a 
-    tRational :: a 
+    tInt :: a
+    tRational :: a
hunk ./VConsts.hs 19
-    tWorld__ :: a 
+    tWorld__ :: a
hunk ./VConsts.hs 42
-    
+
hunk ./VConsts.hs 62
-class ToTuple a where 
+class ToTuple a where
hunk ./VConsts.hs 66
-    toTuple n = '(': replicate (n - 1) ',' ++ ")" 
+    toTuple n = '(': replicate (n - 1) ',' ++ ")"
hunk ./VConsts.hs 118
-    } 
+    }
hunk ./data/PrimitiveOperators-in.hs 29
-    tvra' = tVr 2 t 
+    tvra' = tVr 2 t
hunk ./data/PrimitiveOperators-in.hs 31
-    tvra = tVr 6 st 
+    tvra = tVr 6 st
hunk ./data/PrimitiveOperators-in.hs 33
-    tvrc = tVr 10 st 
+    tvrc = tVr 10 st
hunk ./data/PrimitiveOperators-in.hs 36
-    rebox x = ELit (LitCons cn [x] t) 
+    rebox x = ELit (LitCons cn [x] t)
hunk ./data/PrimitiveOperators-in.hs 38
-    tvra' = tVr 2 t 
-    tvrb' = tVr 4 t 
-    tvra = tVr 6 st 
-    tvrb = tVr 8 st 
-    tvrc = tVr 10 st 
+    tvra' = tVr 2 t
+    tvrb' = tVr 4 t
+    tvra = tVr 6 st
+    tvrb = tVr 8 st
+    tvrc = tVr 10 st
hunk ./data/PrimitiveOperators-in.hs 45
-    rebox x = ELit (LitCons cn [x] t) 
+    rebox x = ELit (LitCons cn [x] t)
hunk ./data/PrimitiveOperators-in.hs 47
-    tvra' = tVr 2 t 
-    tvra = tVr 6 st 
-    tvrc = tVr 10 st 
+    tvra' = tVr 2 t
+    tvra = tVr 6 st
+    tvrc = tVr 10 st
hunk ./data/PrimitiveOperators-in.hs 52
-    rebox x = ELit (LitCons cn [x] t) 
+    rebox x = ELit (LitCons cn [x] t)
hunk ./data/PrimitiveOperators-in.hs 54
-    tvra' = tVr 2 t 
-    tvrb' = tVr 4 t 
-    tvra = tVr 6 st 
-    tvrb = tVr 8 st 
+    tvra' = tVr 2 t
+    tvrb' = tVr 4 t
+    tvra = tVr 6 st
+    tvrb = tVr 8 st
hunk ./data/PrimitiveOperators-in.hs 61
-    rebox x = ELit (LitCons d_Prelude_Int [x] t) 
+    rebox x = ELit (LitCons d_Prelude_Int [x] t)
hunk ./data/PrimitiveOperators-in.hs 64
-    tvra' = tVr 2 t 
-    tvrb' = tVr 4 t 
-    tvra = tVr 6 st 
-    tvrb = tVr 8 st 
+    tvra' = tVr 2 t
+    tvrb' = tVr 4 t
+    tvra = tVr 6 st
+    tvrb = tVr 8 st
hunk ./data/PrimitiveOperators-in.hs 77
-    tvra = tVr 2 st  
-    tvrb = tVr 4 st  
+    tvra = tVr 2 st
+    tvrb = tVr 4 st
hunk ./data/PrimitiveOperators-in.hs 83
-    rebox x = ELit (LitCons cn [x] te) 
+    rebox x = ELit (LitCons cn [x] te)
hunk ./data/PrimitiveOperators-in.hs 87
-    tvra = tVr 2 st 
+    tvra = tVr 2 st
hunk ./data/PrimitiveOperators-in.hs 94
-    rebox x = ELit (LitCons cn [x] te) 
+    rebox x = ELit (LitCons cn [x] te)
hunk ./data/PrimitiveOperators-in.hs 124
---toIO t x = prim_unsafeCoerce x (tIO t) 
+--toIO t x = prim_unsafeCoerce x (tIO t)
hunk ./data/PrimitiveOperators-in.hs 139
-    
+