Make the package -Wall clean
authorIan Lynagh <igloo@earth.li>
Wed, 18 Jun 2008 23:36:27 +0000 (23:36 +0000)
committerIan Lynagh <igloo@earth.li>
Wed, 18 Jun 2008 23:36:27 +0000 (23:36 +0000)
Data/Graph.hs
Data/IntMap.hs
Data/IntSet.hs
Data/Map.hs
Data/Sequence.hs
Data/Set.hs
Data/Tree.hs
include/Typeable.h

index 701675c..4779ca4 100644 (file)
@@ -374,9 +374,13 @@ scc g = dfs g (reverse (postOrd (transposeG g)))
 -- Algorithm 5: Classifying edges
 ------------------------------------------------------------
 
+{-
+XXX unused code
+
 tree              :: Bounds -> Forest Vertex -> Graph
 tree bnds ts       = buildG bnds (concat (map flat ts))
- where flat (Node v ts) = [ (v, w) | Node w _us <- ts ] ++ concat (map flat ts)
+ where flat (Node v ts') = [ (v, w) | Node w _us <- ts' ]
+                        ++ concat (map flat ts')
 
 back              :: Graph -> Table Int -> Graph
 back g post        = mapT select g
@@ -387,8 +391,9 @@ cross g pre post   = mapT select g
  where select v ws = [ w | w <- ws, post!v > post!w, pre!v > pre!w ]
 
 forward           :: Graph -> Graph -> Table Int -> Graph
-forward g tree pre = mapT select g
- where select v ws = [ w | w <- ws, pre!v < pre!w ] \\ tree!v
+forward g tree' pre = mapT select g
+ where select v ws = [ w | w <- ws, pre!v < pre!w ] \\ tree' ! v
+-}
 
 ------------------------------------------------------------
 -- Algorithm 6: Finding reachable vertices
@@ -418,15 +423,15 @@ do_label :: Graph -> Table Int -> Tree Vertex -> Tree (Vertex,Int,Int)
 do_label g dnum (Node v ts) = Node (v,dnum!v,lv) us
  where us = map (do_label g dnum) ts
        lv = minimum ([dnum!v] ++ [dnum!w | w <- g!v]
-                     ++ [lu | Node (u,du,lu) xs <- us])
+                     ++ [lu | Node (_,_,lu) _ <- us])
 
 bicomps :: Tree (Vertex,Int,Int) -> Forest [Vertex]
 bicomps (Node (v,_,_) ts)
-      = [ Node (v:vs) us | (l,Node vs us) <- map collect ts]
+      = [ Node (v:vs) us | (_,Node vs us) <- map collect ts]
 
 collect :: Tree (Vertex,Int,Int) -> (Int, Tree [Vertex])
 collect (Node (v,dv,lv) ts) = (lv, Node (v:vs) cs)
  where collected = map collect ts
-       vs = concat [ ws | (lw, Node ws us) <- collected, lw<dv]
+       vs = concat [ ws | (lw, Node ws _) <- collected, lw<dv]
        cs = concat [ if lw<dv then us else [Node (v:ws) us]
                         | (lw, Node ws us) <- collected ]
index beadaaa..8eb1982 100644 (file)
@@ -168,7 +168,6 @@ import Data.Monoid (Monoid(..))
 import Data.Typeable
 import Data.Foldable (Foldable(foldMap))
 import Control.Monad ( liftM )
-import Control.Arrow (ArrowZero)
 {-
 -- just for testing
 import qualified Prelude
@@ -249,7 +248,7 @@ instance Monoid (IntMap a) where
     mconcat = unions
 
 instance Foldable IntMap where
-    foldMap f Nil = mempty
+    foldMap _ Nil = mempty
     foldMap f (Tip _k v) = f v
     foldMap f (Bin _ _ l r) = foldMap f l `mappend` foldMap f r
 
@@ -280,8 +279,8 @@ instance Data a => Data (IntMap a) where
 -- > Data.IntMap.null (singleton 1 'a') == False
 
 null :: IntMap a -> Bool
-null Nil   = True
-null other = False
+null Nil = True
+null _   = False
 
 -- | /O(n)/. Number of elements in the map.
 --
@@ -291,8 +290,8 @@ null other = False
 size :: IntMap a -> Int
 size t
   = case t of
-      Bin p m l r -> size l + size r
-      Tip k x -> 1
+      Bin _ _ l r -> size l + size r
+      Tip _ _ -> 1
       Nil     -> 0
 
 -- | /O(min(n,W))/. Is the key a member of the map?
@@ -304,8 +303,8 @@ member :: Key -> IntMap a -> Bool
 member k m
   = case lookup k m of
       Nothing -> False
-      Just x  -> True
-    
+      Just _  -> True
+
 -- | /O(log n)/. Is the key not a member of the map?
 --
 -- > notMember 5 (fromList [(5,'a'), (3,'b')]) == False
@@ -327,7 +326,7 @@ lookup' k t
 lookupN :: Nat -> IntMap a -> Maybe a
 lookupN k t
   = case t of
-      Bin p m l r 
+      Bin _ m l r 
         | zeroN k (natFromInt m) -> lookupN k l
         | otherwise              -> lookupN k r
       Tip kx x 
@@ -395,7 +394,7 @@ insert k x t
         | nomatch k p m -> join k (Tip k x) p t
         | zero k m      -> Bin p m (insert k x l) r
         | otherwise     -> Bin p m l (insert k x r)
-      Tip ky 
+      Tip ky _
         | k==ky         -> Tip k x
         | otherwise     -> join k (Tip k x) ky t
       Nil -> Tip k x
@@ -413,7 +412,7 @@ insert k x t
 
 insertWith :: (a -> a -> a) -> Key -> a -> IntMap a -> IntMap a
 insertWith f k x t
-  = insertWithKey (\k x y -> f x y) k x t
+  = insertWithKey (\_ x' y' -> f x' y') k x t
 
 -- | /O(min(n,W))/. Insert with a combining function.
 -- @'insertWithKey' f key value mp@ 
@@ -485,7 +484,7 @@ delete k t
         | nomatch k p m -> t
         | zero k m      -> bin p m (delete k l) r
         | otherwise     -> bin p m l (delete k r)
-      Tip ky 
+      Tip ky _
         | k==ky         -> Nil
         | otherwise     -> t
       Nil -> Nil
@@ -499,7 +498,7 @@ delete k t
 
 adjust ::  (a -> a) -> Key -> IntMap a -> IntMap a
 adjust f k m
-  = adjustWithKey (\k x -> f x) k m
+  = adjustWithKey (\_ x -> f x) k m
 
 -- | /O(min(n,W))/. Adjust a value at a specific key. When the key is not
 -- a member of the map, the original map is returned.
@@ -511,7 +510,7 @@ adjust f k m
 
 adjustWithKey ::  (Key -> a -> a) -> Key -> IntMap a -> IntMap a
 adjustWithKey f k m
-  = updateWithKey (\k x -> Just (f k x)) k m
+  = updateWithKey (\k' x -> Just (f k' x)) k m
 
 -- | /O(min(n,W))/. The expression (@'update' f k map@) updates the value @x@
 -- at @k@ (if it is in the map). If (@f x@) is 'Nothing', the element is
@@ -524,7 +523,7 @@ adjustWithKey f k m
 
 update ::  (a -> Maybe a) -> Key -> IntMap a -> IntMap a
 update f k m
-  = updateWithKey (\k x -> f x) k m
+  = updateWithKey (\_ x -> f x) k m
 
 -- | /O(min(n,W))/. The expression (@'update' f k map@) updates the value @x@
 -- at @k@ (if it is in the map). If (@f k x@) is 'Nothing', the element is
@@ -644,7 +643,7 @@ union t1@(Bin p1 m1 l1 r1) t2@(Bin p2 m2 l2 r2)
             | otherwise         = Bin p2 m2 l2 (union t1 r2)
 
 union (Tip k x) t = insert k x t
-union t (Tip k x) = insertWith (\x y -> y) k x t  -- right bias
+union t (Tip k x) = insertWith (\_ y -> y) k x t  -- right bias
 union Nil t       = t
 union t Nil       = t
 
@@ -654,7 +653,7 @@ union t Nil       = t
 
 unionWith :: (a -> a -> a) -> IntMap a -> IntMap a -> IntMap a
 unionWith f m1 m2
-  = unionWithKey (\k x y -> f x y) m1 m2
+  = unionWithKey (\_ x y -> f x y) m1 m2
 
 -- | /O(n+m)/. The union with a combining function.
 --
@@ -677,9 +676,9 @@ unionWithKey f t1@(Bin p1 m1 l1 r1) t2@(Bin p2 m2 l2 r2)
             | otherwise         = Bin p2 m2 l2 (unionWithKey f t1 r2)
 
 unionWithKey f (Tip k x) t = insertWithKey f k x t
-unionWithKey f t (Tip k x) = insertWithKey (\k x y -> f k y x) k x t  -- right bias
-unionWithKey f Nil t  = t
-unionWithKey f t Nil  = t
+unionWithKey f t (Tip k x) = insertWithKey (\k' x' y' -> f k' y' x') k x t  -- right bias
+unionWithKey _ Nil t  = t
+unionWithKey _ t Nil  = t
 
 {--------------------------------------------------------------------
   Difference
@@ -703,12 +702,12 @@ difference t1@(Bin p1 m1 l1 r1) t2@(Bin p2 m2 l2 r2)
                 | zero p1 m2        = difference t1 l2
                 | otherwise         = difference t1 r2
 
-difference t1@(Tip k x) t2 
+difference t1@(Tip k _) t2
   | member k t2  = Nil
   | otherwise    = t1
 
-difference Nil t       = Nil
-difference t (Tip k x) = delete k t
+difference Nil _       = Nil
+difference t (Tip k _) = delete k t
 difference t Nil       = t
 
 -- | /O(n+m)/. Difference with a combining function.
@@ -719,7 +718,7 @@ difference t Nil       = t
 
 differenceWith :: (a -> b -> Maybe a) -> IntMap a -> IntMap b -> IntMap a
 differenceWith f m1 m2
-  = differenceWithKey (\k x y -> f x y) m1 m2
+  = differenceWithKey (\_ x y -> f x y) m1 m2
 
 -- | /O(n+m)/. Difference with a combining function. When two equal keys are
 -- encountered, the combining function is applied to the key and both values.
@@ -752,9 +751,9 @@ differenceWithKey f t1@(Tip k x) t2
                    Nothing -> Nil
       Nothing -> t1
 
-differenceWithKey f Nil t       = Nil
-differenceWithKey f t (Tip k y) = updateWithKey (\k x -> f k x y) k t
-differenceWithKey f t Nil       = t
+differenceWithKey _ Nil _       = Nil
+differenceWithKey f t (Tip k y) = updateWithKey (\k' x -> f k' x y) k t
+differenceWithKey _ t Nil       = t
 
 
 {--------------------------------------------------------------------
@@ -779,15 +778,15 @@ intersection t1@(Bin p1 m1 l1 r1) t2@(Bin p2 m2 l2 r2)
                   | zero p1 m2        = intersection t1 l2
                   | otherwise         = intersection t1 r2
 
-intersection t1@(Tip k x) t2 
+intersection t1@(Tip k _) t2
   | member k t2  = t1
   | otherwise    = Nil
-intersection t (Tip k x) 
+intersection t (Tip k _)
   = case lookup k t of
       Just y  -> Tip k y
       Nothing -> Nil
-intersection Nil t = Nil
-intersection t Nil = Nil
+intersection Nil _ = Nil
+intersection _ Nil = Nil
 
 -- | /O(n+m)/. The intersection with a combining function.
 --
@@ -795,7 +794,7 @@ intersection t Nil = Nil
 
 intersectionWith :: (a -> b -> a) -> IntMap a -> IntMap b -> IntMap a
 intersectionWith f m1 m2
-  = intersectionWithKey (\k x y -> f x y) m1 m2
+  = intersectionWithKey (\_ x y -> f x y) m1 m2
 
 -- | /O(n+m)/. The intersection with a combining function.
 --
@@ -817,7 +816,7 @@ intersectionWithKey f t1@(Bin p1 m1 l1 r1) t2@(Bin p2 m2 l2 r2)
                   | zero p1 m2        = intersectionWithKey f t1 l2
                   | otherwise         = intersectionWithKey f t1 r2
 
-intersectionWithKey f t1@(Tip k x) t2 
+intersectionWithKey f (Tip k x) t2
   = case lookup k t2 of
       Just y  -> Tip k (f k x y)
       Nothing -> Nil
@@ -825,8 +824,8 @@ intersectionWithKey f t1 (Tip k y)
   = case lookup k t1 of
       Just x  -> Tip k (f k x y)
       Nothing -> Nil
-intersectionWithKey f Nil t = Nil
-intersectionWithKey f t Nil = Nil
+intersectionWithKey _ Nil _ = Nil
+intersectionWithKey _ _ Nil = Nil
 
 
 {--------------------------------------------------------------------
@@ -846,10 +845,12 @@ updateMinWithKey f t
         Tip k y -> Tip k (f k y)
         Nil -> error "maxView: empty map has no maximal element"
 
+updateMinWithKeyUnsigned :: (Key -> a -> a) -> IntMap a -> IntMap a
 updateMinWithKeyUnsigned f t
     = case t of
         Bin p m l r -> let t' = updateMinWithKeyUnsigned f r in Bin p m l t'
         Tip k y -> Tip k (f k y)
+        Nil -> error "updateMinWithKeyUnsigned Nil"
 
 -- | /O(log n)/. Update the value at the maximal key.
 --
@@ -859,15 +860,17 @@ updateMinWithKeyUnsigned f t
 updateMaxWithKey :: (Key -> a -> a) -> IntMap a -> IntMap a
 updateMaxWithKey f t
     = case t of
-        Bin p m l r | m < 0 -> let t' = updateMaxWithKeyUnsigned f r in Bin p m r t'
-        Bin p m l r         -> let t' = updateMaxWithKeyUnsigned f l in Bin p m t' l
+        Bin p m _ r | m < 0 -> let t' = updateMaxWithKeyUnsigned f r in Bin p m r t'
+        Bin p m l _         -> let t' = updateMaxWithKeyUnsigned f l in Bin p m t' l
         Tip k y -> Tip k (f k y)
         Nil -> error "maxView: empty map has no maximal element"
 
+updateMaxWithKeyUnsigned :: (Key -> a -> a) -> IntMap a -> IntMap a
 updateMaxWithKeyUnsigned f t
     = case t of
         Bin p m l r -> let t' = updateMaxWithKeyUnsigned f r in Bin p m l t'
         Tip k y -> Tip k (f k y)
+        Nil -> error "updateMaxWithKeyUnsigned Nil"
 
 
 -- | /O(log n)/. Retrieves the maximal (key,value) couple of the map, and the map stripped from that element.
@@ -885,10 +888,12 @@ maxViewWithKey t
         Tip k y -> return ((k,y), Nil)
         Nil -> fail "maxViewWithKey: empty map has no maximal element"
 
+maxViewUnsigned :: IntMap a -> ((Key, a), IntMap a)
 maxViewUnsigned t 
     = case t of
         Bin p m l r -> let (result,t') = maxViewUnsigned r in (result,bin p m l t')
         Tip k y -> ((k,y), Nil)
+        Nil -> error "maxViewUnsigned Nil"
 
 -- | /O(log n)/. Retrieves the minimal (key,value) couple of the map, and the map stripped from that element.
 -- @fail@s (in the monad) when passed an empty map.
@@ -905,10 +910,12 @@ minViewWithKey t
         Tip k y -> return ((k,y),Nil)
         Nil -> fail "minViewWithKey: empty map has no minimal element"
 
+minViewUnsigned :: IntMap a -> ((Key, a), IntMap a)
 minViewUnsigned t 
     = case t of
         Bin p m l r -> let (result,t') = minViewUnsigned l in (result,bin p m t' r)
         Tip k y -> ((k,y),Nil)
+        Nil -> error "minViewUnsigned Nil"
 
 
 -- | /O(log n)/. Update the value at the maximal key.
@@ -934,6 +941,7 @@ instance Monad Identity where
        return a = Identity a
        m >>= k  = k (runIdentity m)
 -- Similar to the Arrow instance.
+first :: (a -> c) -> (a, b) -> (c, b)
 first f (x,y) = (f x,y)
 
 
@@ -998,36 +1006,37 @@ isProperSubmapOf m1 m2
   > isProperSubmapOfBy (<)  (fromList [(1,1)])       (fromList [(1,1),(2,2)])
 -}
 isProperSubmapOfBy :: (a -> b -> Bool) -> IntMap a -> IntMap b -> Bool
-isProperSubmapOfBy pred t1 t2
-  = case submapCmp pred t1 t2 of 
+isProperSubmapOfBy predicate t1 t2
+  = case submapCmp predicate t1 t2 of
       LT -> True
-      ge -> False
+       -> False
 
-submapCmp pred t1@(Bin p1 m1 l1 r1) t2@(Bin p2 m2 l2 r2)
+submapCmp :: (a -> b -> Bool) -> IntMap a -> IntMap b -> Ordering
+submapCmp predicate t1@(Bin p1 m1 l1 r1) (Bin p2 m2 l2 r2)
   | shorter m1 m2  = GT
   | shorter m2 m1  = submapCmpLt
   | p1 == p2       = submapCmpEq
   | otherwise      = GT  -- disjoint
   where
     submapCmpLt | nomatch p1 p2 m2  = GT
-                | zero p1 m2        = submapCmp pred t1 l2
-                | otherwise         = submapCmp pred t1 r2
-    submapCmpEq = case (submapCmp pred l1 l2, submapCmp pred r1 r2) of
+                | zero p1 m2        = submapCmp predicate t1 l2
+                | otherwise         = submapCmp predicate t1 r2
+    submapCmpEq = case (submapCmp predicate l1 l2, submapCmp predicate r1 r2) of
                     (GT,_ ) -> GT
                     (_ ,GT) -> GT
                     (EQ,EQ) -> EQ
-                    other   -> LT
+                    _       -> LT
 
-submapCmp pred (Bin p m l r) t  = GT
-submapCmp pred (Tip kx x) (Tip ky y)  
-  | (kx == ky) && pred x y = EQ
-  | otherwise              = GT  -- disjoint
-submapCmp pred (Tip k x) t      
+submapCmp _         (Bin _ _ _ _) _  = GT
+submapCmp predicate (Tip kx x) (Tip ky y)
+  | (kx == ky) && predicate x y = EQ
+  | otherwise                   = GT  -- disjoint
+submapCmp predicate (Tip k x) t
   = case lookup k t of
-     Just y  | pred x y -> LT
-     other   -> GT -- disjoint
-submapCmp pred Nil Nil = EQ
-submapCmp pred Nil t   = LT
+     Just y | predicate x y -> LT
+     _                      -> GT -- disjoint
+submapCmp _    Nil Nil = EQ
+submapCmp _    Nil _   = LT
 
 -- | /O(n+m)/. Is this a submap?
 -- Defined as (@'isSubmapOf' = 'isSubmapOfBy' (==)@).
@@ -1052,16 +1061,16 @@ isSubmapOf m1 m2
   > isSubmapOfBy (==) (fromList [(1,1),(2,2)]) (fromList [(1,1)])
 -}
 isSubmapOfBy :: (a -> b -> Bool) -> IntMap a -> IntMap b -> Bool
-isSubmapOfBy pred t1@(Bin p1 m1 l1 r1) t2@(Bin p2 m2 l2 r2)
+isSubmapOfBy predicate t1@(Bin p1 m1 l1 r1) (Bin p2 m2 l2 r2)
   | shorter m1 m2  = False
-  | shorter m2 m1  = match p1 p2 m2 && (if zero p1 m2 then isSubmapOfBy pred t1 l2
-                                                      else isSubmapOfBy pred t1 r2)                     
-  | otherwise      = (p1==p2) && isSubmapOfBy pred l1 l2 && isSubmapOfBy pred r1 r2
-isSubmapOfBy pred (Bin p m l r) t  = False
-isSubmapOfBy pred (Tip k x) t      = case lookup k t of
-                                   Just y  -> pred x y
-                                   Nothing -> False 
-isSubmapOfBy pred Nil t            = True
+  | shorter m2 m1  = match p1 p2 m2 && (if zero p1 m2 then isSubmapOfBy predicate t1 l2
+                                                      else isSubmapOfBy predicate t1 r2)                     
+  | otherwise      = (p1==p2) && isSubmapOfBy predicate l1 l2 && isSubmapOfBy predicate r1 r2
+isSubmapOfBy _         (Bin _ _ _ _) _ = False
+isSubmapOfBy predicate (Tip k x) t     = case lookup k t of
+                                         Just y  -> predicate x y
+                                         Nothing -> False
+isSubmapOfBy _         Nil _           = True
 
 {--------------------------------------------------------------------
   Mapping
@@ -1072,7 +1081,7 @@ isSubmapOfBy pred Nil t            = True
 
 map :: (a -> b) -> IntMap a -> IntMap b
 map f m
-  = mapWithKey (\k x -> f x) m
+  = mapWithKey (\_ x -> f x) m
 
 -- | /O(n)/. Map a function over all values in the map.
 --
@@ -1094,7 +1103,7 @@ mapWithKey f t
 
 mapAccum :: (a -> b -> (a,c)) -> a -> IntMap b -> (a,IntMap c)
 mapAccum f a m
-  = mapAccumWithKey (\a k x -> f a x) a m
+  = mapAccumWithKey (\a' _ x -> f a' x) a m
 
 -- | /O(n)/. The function @'mapAccumWithKey'@ threads an accumulating
 -- argument through the map in ascending order of keys.
@@ -1117,6 +1126,8 @@ mapAccumL f a t
       Tip k x     -> let (a',x') = f a k x in (a',Tip k x')
       Nil         -> (a,Nil)
 
+{-
+XXX unused code
 
 -- | /O(n)/. The function @'mapAccumR'@ threads an accumulating
 -- argument throught the map in descending order of keys.
@@ -1128,6 +1139,7 @@ mapAccumR f a t
                      in (a2,Bin p m l' r')
       Tip k x     -> let (a',x') = f a k x in (a',Tip k x')
       Nil         -> (a,Nil)
+-}
 
 {--------------------------------------------------------------------
   Filter
@@ -1140,20 +1152,20 @@ mapAccumR f a t
 
 filter :: (a -> Bool) -> IntMap a -> IntMap a
 filter p m
-  = filterWithKey (\k x -> p x) m
+  = filterWithKey (\_ x -> p x) m
 
 -- | /O(n)/. Filter all keys\/values that satisfy some predicate.
 --
 -- > filterWithKey (\k _ -> k > 4) (fromList [(5,"a"), (3,"b")]) == singleton 5 "a"
 
 filterWithKey :: (Key -> a -> Bool) -> IntMap a -> IntMap a
-filterWithKey pred t
+filterWithKey predicate t
   = case t of
       Bin p m l r 
-        -> bin p m (filterWithKey pred l) (filterWithKey pred r)
+        -> bin p m (filterWithKey predicate l) (filterWithKey predicate r)
       Tip k x 
-        | pred k x  -> t
-        | otherwise -> Nil
+        | predicate k x -> t
+        | otherwise     -> Nil
       Nil -> Nil
 
 -- | /O(n)/. Partition the map according to some predicate. The first
@@ -1166,7 +1178,7 @@ filterWithKey pred t
 
 partition :: (a -> Bool) -> IntMap a -> (IntMap a,IntMap a)
 partition p m
-  = partitionWithKey (\k x -> p x) m
+  = partitionWithKey (\_ x -> p x) m
 
 -- | /O(n)/. Partition the map according to some predicate. The first
 -- map contains all elements that satisfy the predicate, the second all
@@ -1177,15 +1189,15 @@ partition p m
 -- > partitionWithKey (\ k _ -> k > 7) (fromList [(5,"a"), (3,"b")]) == (empty, fromList [(3, "b"), (5, "a")])
 
 partitionWithKey :: (Key -> a -> Bool) -> IntMap a -> (IntMap a,IntMap a)
-partitionWithKey pred t
+partitionWithKey predicate t
   = case t of
       Bin p m l r 
-        -> let (l1,l2) = partitionWithKey pred l
-               (r1,r2) = partitionWithKey pred r
+        -> let (l1,l2) = partitionWithKey predicate l
+               (r1,r2) = partitionWithKey predicate r
            in (bin p m l1 r1, bin p m l2 r2)
       Tip k x 
-        | pred k x  -> (t,Nil)
-        | otherwise -> (Nil,t)
+        | predicate k x -> (t,Nil)
+        | otherwise     -> (Nil,t)
       Nil -> (Nil,Nil)
 
 -- | /O(n)/. Map values and collect the 'Just' results.
@@ -1195,7 +1207,7 @@ partitionWithKey pred t
 
 mapMaybe :: (a -> Maybe b) -> IntMap a -> IntMap b
 mapMaybe f m
-  = mapMaybeWithKey (\k x -> f x) m
+  = mapMaybeWithKey (\_ x -> f x) m
 
 -- | /O(n)/. Map keys\/values and collect the 'Just' results.
 --
@@ -1208,7 +1220,7 @@ mapMaybeWithKey f (Bin p m l r)
 mapMaybeWithKey f (Tip k x) = case f k x of
   Just y  -> Tip k y
   Nothing -> Nil
-mapMaybeWithKey f Nil = Nil
+mapMaybeWithKey _ Nil = Nil
 
 -- | /O(n)/. Map values and separate the 'Left' and 'Right' results.
 --
@@ -1221,7 +1233,7 @@ mapMaybeWithKey f Nil = Nil
 
 mapEither :: (a -> Either b c) -> IntMap a -> (IntMap b, IntMap c)
 mapEither f m
-  = mapEitherWithKey (\k x -> f x) m
+  = mapEitherWithKey (\_ x -> f x) m
 
 -- | /O(n)/. Map keys\/values and separate the 'Left' and 'Right' results.
 --
@@ -1241,7 +1253,7 @@ mapEitherWithKey f (Bin p m l r)
 mapEitherWithKey f (Tip k x) = case f k x of
   Left y  -> (Tip k y, Nil)
   Right z -> (Nil, Tip k z)
-mapEitherWithKey f Nil = (Nil, Nil)
+mapEitherWithKey _ Nil = (Nil, Nil)
 
 -- | /O(log n)/. The expression (@'split' k map@) is a pair @(map1,map2)@
 -- where all keys in @map1@ are lower than @k@ and all keys in
@@ -1256,12 +1268,12 @@ mapEitherWithKey f Nil = (Nil, Nil)
 split :: Key -> IntMap a -> (IntMap a,IntMap a)
 split k t
   = case t of
-      Bin p m l r 
+      Bin _ m l r
           | m < 0 -> (if k >= 0 -- handle negative numbers.
                       then let (lt,gt) = split' k l in (union r lt, gt)
                       else let (lt,gt) = split' k r in (lt, union gt l))
           | otherwise   -> split' k t
-      Tip ky 
+      Tip ky _
         | k>ky      -> (t,Nil)
         | k<ky      -> (Nil,t)
         | otherwise -> (Nil,Nil)
@@ -1274,7 +1286,7 @@ split' k t
         | nomatch k p m -> if k>p then (t,Nil) else (Nil,t)
         | zero k m  -> let (lt,gt) = split k l in (lt,union gt r)
         | otherwise -> let (lt,gt) = split k r in (union l lt,gt)
-      Tip ky 
+      Tip ky _
         | k>ky      -> (t,Nil)
         | k<ky      -> (Nil,t)
         | otherwise -> (Nil,Nil)
@@ -1292,7 +1304,7 @@ split' k t
 splitLookup :: Key -> IntMap a -> (IntMap a,Maybe a,IntMap a)
 splitLookup k t
   = case t of
-      Bin p m l r
+      Bin _ m l r
           | m < 0 -> (if k >= 0 -- handle negative numbers.
                       then let (lt,found,gt) = splitLookup' k l in (union r lt,found, gt)
                       else let (lt,found,gt) = splitLookup' k r in (lt,found, union gt l))
@@ -1330,7 +1342,7 @@ splitLookup' k t
 
 fold :: (a -> b -> b) -> b -> IntMap a -> b
 fold f z t
-  = foldWithKey (\k x y -> f x y) z t
+  = foldWithKey (\_ x y -> f x y) z t
 
 -- | /O(n)/. Fold the keys and values in the map, such that
 -- @'foldWithKey' f z == 'Prelude.foldr' ('uncurry' f) z . 'toAscList'@.
@@ -1356,7 +1368,7 @@ foldr f z t
 foldr' :: (Key -> a -> b -> b) -> b -> IntMap a -> b
 foldr' f z t
   = case t of
-      Bin p m l r -> foldr' f (foldr' f z r) l
+      Bin _ _ l r -> foldr' f (foldr' f z r) l
       Tip k x     -> f k x z
       Nil         -> z
 
@@ -1373,7 +1385,7 @@ foldr' f z t
 
 elems :: IntMap a -> [a]
 elems m
-  = foldWithKey (\k x xs -> x:xs) [] m  
+  = foldWithKey (\_ x xs -> x:xs) [] m
 
 -- | /O(n)/. Return all keys of the map in ascending order.
 --
@@ -1382,7 +1394,7 @@ elems m
 
 keys  :: IntMap a -> [Key]
 keys m
-  = foldWithKey (\k x ks -> k:ks) [] m
+  = foldWithKey (\k _ ks -> k:ks) [] m
 
 -- | /O(n*min(n,W))/. The set of all keys of the map.
 --
@@ -1423,7 +1435,7 @@ toList t
 toAscList :: IntMap a -> [(Key,a)]
 toAscList t   
   = -- NOTE: the following algorithm only works for big-endian trees
-    let (pos,neg) = span (\(k,x) -> k >=0) (foldr (\k x xs -> (k,x):xs) [] t) in neg ++ pos
+    let (pos,neg) = span (\(k,_) -> k >=0) (foldr (\k x xs -> (k,x):xs) [] t) in neg ++ pos
 
 -- | /O(n*min(n,W))/. Create a map from a list of key\/value pairs.
 --
@@ -1444,7 +1456,7 @@ fromList xs
 
 fromListWith :: (a -> a -> a) -> [(Key,a)] -> IntMap a 
 fromListWith f xs
-  = fromListWithKey (\k x y -> f x y) xs
+  = fromListWithKey (\_ x y -> f x y) xs
 
 -- | /O(n*min(n,W))/. Build a map from a list of key\/value pairs with a combining function. See also fromAscListWithKey'.
 --
@@ -1508,7 +1520,7 @@ equal (Bin p1 m1 l1 r1) (Bin p2 m2 l2 r2)
 equal (Tip kx x) (Tip ky y)
   = (kx == ky) && (x==y)
 equal Nil Nil = True
-equal t1 t2   = False
+equal _   _   = False
 
 nequal :: Eq a => IntMap a -> IntMap a -> Bool
 nequal (Bin p1 m1 l1 r1) (Bin p2 m2 l2 r2)
@@ -1516,7 +1528,7 @@ nequal (Bin p1 m1 l1 r1) (Bin p2 m2 l2 r2)
 nequal (Tip kx x) (Tip ky y)
   = (kx /= ky) || (x/=y)
 nequal Nil Nil = False
-nequal t1 t2   = True
+nequal _   _   = True
 
 {--------------------------------------------------------------------
   Ord 
@@ -1540,6 +1552,9 @@ instance Show a => Show (IntMap a) where
   showsPrec d m   = showParen (d > 10) $
     showString "fromList " . shows (toList m)
 
+{-
+XXX unused code
+
 showMap :: (Show a) => [(Key,a)] -> ShowS
 showMap []     
   = showString "{}" 
@@ -1547,9 +1562,10 @@ showMap (x:xs)
   = showChar '{' . showElem x . showTail xs
   where
     showTail []     = showChar '}'
-    showTail (x:xs) = showChar ',' . showElem x . showTail xs
+    showTail (x':xs') = showChar ',' . showElem x' . showTail xs'
     
-    showElem (k,x)  = shows k . showString ":=" . shows x
+    showElem (k,v)  = shows k . showString ":=" . shows v
+-}
 
 {--------------------------------------------------------------------
   Read
@@ -1621,10 +1637,12 @@ showsTreeHang wide bars t
       Tip k x
           -> showsBars bars . showString " " . shows k . showString ":=" . shows x . showString "\n" 
       Nil -> showsBars bars . showString "|\n" 
-      
-showBin p m
+
+showBin :: Prefix -> Mask -> String
+showBin _ _
   = "*" -- ++ show (p,m)
 
+showWide :: Bool -> [String] -> String -> String
 showWide wide bars 
   | wide      = showString (concat (reverse bars)) . showString "|\n" 
   | otherwise = id
@@ -1635,7 +1653,10 @@ showsBars bars
       [] -> id
       _  -> showString (concat (reverse (tail bars))) . showString node
 
+node :: String
 node           = "+--"
+
+withBar, withEmpty :: [String] -> [String]
 withBar bars   = "|  ":bars
 withEmpty bars = "   ":bars
 
@@ -1658,8 +1679,8 @@ join p1 t1 p2 t2
   @bin@ assures that we never have empty trees within a tree.
 --------------------------------------------------------------------}
 bin :: Prefix -> Mask -> IntMap a -> IntMap a -> IntMap a
-bin p m l Nil = l
-bin p m Nil r = r
+bin _ _ l Nil = l
+bin _ _ Nil r = r
 bin p m l r   = Bin p m l r
 
   
@@ -1743,19 +1764,20 @@ branchMask p1 p2
   machine code. The algorithm is derived from Jorg Arndt's FXT library.
 ----------------------------------------------------------------------}
 highestBitMask :: Nat -> Nat
-highestBitMask x
-  = case (x .|. shiftRL x 1) of 
-     x -> case (x .|. shiftRL x 2) of 
-      x -> case (x .|. shiftRL x 4) of 
-       x -> case (x .|. shiftRL x 8) of 
-        x -> case (x .|. shiftRL x 16) of 
-         x -> case (x .|. shiftRL x 32) of   -- for 64 bit platforms
-          x -> (x `xor` (shiftRL x 1))
+highestBitMask x0
+  = case (x0 .|. shiftRL x0 1) of
+     x1 -> case (x1 .|. shiftRL x1 2) of
+      x2 -> case (x2 .|. shiftRL x2 4) of
+       x3 -> case (x3 .|. shiftRL x3 8) of
+        x4 -> case (x3 .|. shiftRL x4 16) of
+         x5 -> case (x4 .|. shiftRL x5 32) of   -- for 64 bit platforms
+          x6 -> (x6 `xor` (shiftRL x6 1))
 
 
 {--------------------------------------------------------------------
   Utilities 
 --------------------------------------------------------------------}
+foldlStrict :: (a -> b -> a) -> a -> [b] -> a
 foldlStrict f z xs
   = case xs of
       []     -> z
index 7ae90f9..34f533d 100644 (file)
@@ -206,15 +206,15 @@ instance Data IntSet where
 --------------------------------------------------------------------}
 -- | /O(1)/. Is the set empty?
 null :: IntSet -> Bool
-null Nil   = True
-null other = False
+null Nil = True
+null _   = False
 
 -- | /O(n)/. Cardinality of the set.
 size :: IntSet -> Int
 size t
   = case t of
-      Bin p m l r -> size l + size r
-      Tip y -> 1
+      Bin _ _ l r -> size l + size r
+      Tip _ -> 1
       Nil   -> 0
 
 -- | /O(min(n,W))/. Is the value a member of the set?
@@ -240,10 +240,10 @@ lookup k t
 lookupN :: Nat -> IntSet -> Maybe Int
 lookupN k t
   = case t of
-      Bin p m l r 
+      Bin _ m l r
         | zeroN k (natFromInt m) -> lookupN k l
         | otherwise              -> lookupN k r
-      Tip kx 
+      Tip kx
         | (k == natFromInt kx)  -> Just kx
         | otherwise             -> Nothing
       Nil -> Nothing
@@ -361,7 +361,7 @@ difference t1@(Tip x) t2
   | member x t2  = Nil
   | otherwise    = t1
 
-difference Nil t     = Nil
+difference Nil _     = Nil
 difference t (Tip x) = delete x t
 difference t Nil     = t
 
@@ -393,8 +393,8 @@ intersection t (Tip x)
   = case lookup x t of
       Just y  -> Tip y
       Nothing -> Nil
-intersection Nil t = Nil
-intersection t Nil = Nil
+intersection Nil _ = Nil
+intersection _ Nil = Nil
 
 
 
@@ -406,9 +406,10 @@ isProperSubsetOf :: IntSet -> IntSet -> Bool
 isProperSubsetOf t1 t2
   = case subsetCmp t1 t2 of 
       LT -> True
-      ge -> False
+       -> False
 
-subsetCmp t1@(Bin p1 m1 l1 r1) t2@(Bin p2 m2 l2 r2)
+subsetCmp :: IntSet -> IntSet -> Ordering
+subsetCmp t1@(Bin p1 m1 l1 r1) (Bin p2 m2 l2 r2)
   | shorter m1 m2  = GT
   | shorter m2 m1  = case subsetCmpLt of
                        GT -> GT
@@ -423,9 +424,9 @@ subsetCmp t1@(Bin p1 m1 l1 r1) t2@(Bin p2 m2 l2 r2)
                     (GT,_ ) -> GT
                     (_ ,GT) -> GT
                     (EQ,EQ) -> EQ
-                    other   -> LT
+                    _       -> LT
 
-subsetCmp (Bin p m l r) t  = GT
+subsetCmp (Bin _ _ _ _) _  = GT
 subsetCmp (Tip x) (Tip y)  
   | x==y       = EQ
   | otherwise  = GT  -- disjoint
@@ -433,20 +434,20 @@ subsetCmp (Tip x) t
   | member x t = LT
   | otherwise  = GT  -- disjoint
 subsetCmp Nil Nil = EQ
-subsetCmp Nil t   = LT
+subsetCmp Nil _   = LT
 
 -- | /O(n+m)/. Is this a subset?
 -- @(s1 `isSubsetOf` s2)@ tells whether @s1@ is a subset of @s2@.
 
 isSubsetOf :: IntSet -> IntSet -> Bool
-isSubsetOf t1@(Bin p1 m1 l1 r1) t2@(Bin p2 m2 l2 r2)
+isSubsetOf t1@(Bin p1 m1 l1 r1) (Bin p2 m2 l2 r2)
   | shorter m1 m2  = False
   | shorter m2 m1  = match p1 p2 m2 && (if zero p1 m2 then isSubsetOf t1 l2
                                                       else isSubsetOf t1 r2)                     
   | otherwise      = (p1==p2) && isSubsetOf l1 l2 && isSubsetOf r1 r2
-isSubsetOf (Bin p m l r) t  = False
+isSubsetOf (Bin _ _ _ _) _  = False
 isSubsetOf (Tip x) t        = member x t
-isSubsetOf Nil t            = True
+isSubsetOf Nil _            = True
 
 
 {--------------------------------------------------------------------
@@ -454,26 +455,26 @@ isSubsetOf Nil t            = True
 --------------------------------------------------------------------}
 -- | /O(n)/. Filter all elements that satisfy some predicate.
 filter :: (Int -> Bool) -> IntSet -> IntSet
-filter pred t
+filter predicate t
   = case t of
       Bin p m l r 
-        -> bin p m (filter pred l) (filter pred r)
+        -> bin p m (filter predicate l) (filter predicate r)
       Tip x 
-        | pred x    -> t
-        | otherwise -> Nil
+        | predicate x -> t
+        | otherwise   -> Nil
       Nil -> Nil
 
 -- | /O(n)/. partition the set according to some predicate.
 partition :: (Int -> Bool) -> IntSet -> (IntSet,IntSet)
-partition pred t
+partition predicate t
   = case t of
       Bin p m l r 
-        -> let (l1,l2) = partition pred l
-               (r1,r2) = partition pred r
+        -> let (l1,l2) = partition predicate l
+               (r1,r2) = partition predicate r
            in (bin p m l1 r1, bin p m l2 r2)
       Tip x 
-        | pred x    -> (t,Nil)
-        | otherwise -> (Nil,t)
+        | predicate x -> (t,Nil)
+        | otherwise   -> (Nil,t)
       Nil -> (Nil,Nil)
 
 
@@ -485,7 +486,7 @@ partition pred t
 split :: Int -> IntSet -> (IntSet,IntSet)
 split x t
   = case t of
-      Bin p m l r
+      Bin _ m l r
         | m < 0       -> if x >= 0 then let (lt,gt) = split' x l in (union r lt, gt)
                                    else let (lt,gt) = split' x r in (lt, union gt l)
                                    -- handle negative numbers.
@@ -515,7 +516,7 @@ split' x t
 splitMember :: Int -> IntSet -> (IntSet,Bool,IntSet)
 splitMember x t
   = case t of
-      Bin p m l r
+      Bin _ m l r
         | m < 0       -> if x >= 0 then let (lt,found,gt) = splitMember' x l in (union r lt, found, gt)
                                    else let (lt,found,gt) = splitMember' x r in (lt, found, union gt l)
                                    -- handle negative numbers.
@@ -559,6 +560,7 @@ maxViewUnsigned t
     = case t of
         Bin p m l r -> let (result,t') = maxViewUnsigned r in (result, bin p m l t')
         Tip y -> (y, Nil)
+        Nil -> error "maxViewUnsigned Nil"
 
 -- | /O(min(n,W))/. Retrieves the minimal key of the set, and the set stripped from that element
 -- @fail@s (in the monad) when passed an empty set.
@@ -575,6 +577,7 @@ minViewUnsigned t
     = case t of
         Bin p m l r -> let (result,t') = minViewUnsigned l in (result, bin p m t' r)
         Tip y -> (y, Nil)
+        Nil -> error "minViewUnsigned Nil"
 
 
 -- Duplicate the Identity monad here because base < mtl.
@@ -639,14 +642,14 @@ fold f z t
   = case t of
       Bin 0 m l r | m < 0 -> foldr f (foldr f z l) r  
       -- put negative numbers before.
-      Bin p m l r -> foldr f z t
+      Bin _ _ _ _ -> foldr f z t
       Tip x       -> f x z
       Nil         -> z
 
 foldr :: (Int -> b -> b) -> b -> IntSet -> b
 foldr f z t
   = case t of
-      Bin p m l r -> foldr f (foldr f z r) l
+      Bin _ _ l r -> foldr f (foldr f z r) l
       Tip x       -> f x z
       Nil         -> z
           
@@ -701,7 +704,7 @@ equal (Bin p1 m1 l1 r1) (Bin p2 m2 l2 r2)
 equal (Tip x) (Tip y)
   = (x==y)
 equal Nil Nil = True
-equal t1 t2   = False
+equal _   _   = False
 
 nequal :: IntSet -> IntSet -> Bool
 nequal (Bin p1 m1 l1 r1) (Bin p2 m2 l2 r2)
@@ -709,7 +712,7 @@ nequal (Bin p1 m1 l1 r1) (Bin p2 m2 l2 r2)
 nequal (Tip x) (Tip y)
   = (x/=y)
 nequal Nil Nil = False
-nequal t1 t2   = True
+nequal _   _   = True
 
 {--------------------------------------------------------------------
   Ord 
@@ -726,6 +729,8 @@ instance Show IntSet where
   showsPrec p xs = showParen (p > 10) $
     showString "fromList " . shows (toList xs)
 
+{-
+XXX unused code
 showSet :: [Int] -> ShowS
 showSet []     
   = showString "{}" 
@@ -733,7 +738,8 @@ showSet (x:xs)
   = showChar '{' . shows x . showTail xs
   where
     showTail []     = showChar '}'
-    showTail (x:xs) = showChar ',' . shows x . showTail xs
+    showTail (x':xs') = showChar ',' . shows x' . showTail xs'
+-}
 
 {--------------------------------------------------------------------
   Read
@@ -805,10 +811,12 @@ showsTreeHang wide bars t
       Tip x
           -> showsBars bars . showString " " . shows x . showString "\n" 
       Nil -> showsBars bars . showString "|\n" 
-      
-showBin p m
+
+showBin :: Prefix -> Mask -> String
+showBin _ _
   = "*" -- ++ show (p,m)
 
+showWide :: Bool -> [String] -> String -> String
 showWide wide bars 
   | wide      = showString (concat (reverse bars)) . showString "|\n" 
   | otherwise = id
@@ -819,7 +827,10 @@ showsBars bars
       [] -> id
       _  -> showString (concat (reverse (tail bars))) . showString node
 
+node :: String
 node           = "+--"
+
+withBar, withEmpty :: [String] -> [String]
 withBar bars   = "|  ":bars
 withEmpty bars = "   ":bars
 
@@ -842,8 +853,8 @@ join p1 t1 p2 t2
   @bin@ assures that we never have empty trees within a tree.
 --------------------------------------------------------------------}
 bin :: Prefix -> Mask -> IntSet -> IntSet -> IntSet
-bin p m l Nil = l
-bin p m Nil r = r
+bin _ _ l Nil = l
+bin _ _ Nil r = r
 bin p m l r   = Bin p m l r
 
   
@@ -928,19 +939,20 @@ branchMask p1 p2
   machine code. The algorithm is derived from Jorg Arndt's FXT library.
 ----------------------------------------------------------------------}
 highestBitMask :: Nat -> Nat
-highestBitMask x
-  = case (x .|. shiftRL x 1) of 
-     x -> case (x .|. shiftRL x 2) of 
-      x -> case (x .|. shiftRL x 4) of 
-       x -> case (x .|. shiftRL x 8) of 
-        x -> case (x .|. shiftRL x 16) of 
-         x -> case (x .|. shiftRL x 32) of   -- for 64 bit platforms
-          x -> (x `xor` (shiftRL x 1))
+highestBitMask x0
+  = case (x0 .|. shiftRL x0 1) of
+     x1 -> case (x1 .|. shiftRL x1 2) of
+      x2 -> case (x2 .|. shiftRL x2 4) of
+       x3 -> case (x3 .|. shiftRL x3 8) of
+        x4 -> case (x4 .|. shiftRL x4 16) of
+         x5 -> case (x5 .|. shiftRL x5 32) of   -- for 64 bit platforms
+          x6 -> (x6 `xor` (shiftRL x6 1))
 
 
 {--------------------------------------------------------------------
   Utilities 
 --------------------------------------------------------------------}
+foldlStrict :: (a -> b -> a) -> a -> [b] -> a
 foldlStrict f z xs
   = case xs of
       []     -> z
index a3cc318..d8aaeb2 100644 (file)
@@ -174,7 +174,6 @@ import Prelude hiding (lookup,map,filter,foldr,foldl,null)
 import qualified Data.Set as Set
 import qualified Data.List as List
 import Data.Monoid (Monoid(..))
-import Data.Typeable
 import Control.Applicative (Applicative(..), (<$>))
 import Data.Traversable (Traversable(traverse))
 import Data.Foldable (Foldable(foldMap))
@@ -190,7 +189,7 @@ import List(nub,sort)
 #if __GLASGOW_HASKELL__
 import Text.Read
 import Data.Generics.Basics
-import Data.Generics.Instances
+import Data.Generics.Instances ()
 #endif
 
 {--------------------------------------------------------------------
@@ -235,7 +234,7 @@ instance (Ord k) => Monoid (Map k v) where
 -- We omit reflection services for the sake of data abstraction.
 
 instance (Data k, Data a, Ord k) => Data (Map k a) where
-  gfoldl f z map = z fromList `f` (toList map)
+  gfoldl f z m   = z fromList `f` toList m
   toConstr _     = error "toConstr"
   gunfold _ _    = error "gunfold"
   dataTypeOf _   = mkNorepType "Data.Map.Map"
@@ -254,8 +253,8 @@ instance (Data k, Data a, Ord k) => Data (Map k a) where
 null :: Map k a -> Bool
 null t
   = case t of
-      Tip             -> True
-      Bin sz k x l r  -> False
+      Tip    -> True
+      Bin {} -> False
 
 -- | /O(1)/. The number of elements in the map.
 --
@@ -267,7 +266,7 @@ size :: Map k a -> Int
 size t
   = case t of
       Tip             -> 0
-      Bin sz k x l r  -> sz
+      Bin sz _ _ _ _  -> sz
 
 
 -- | /O(log n)/. Lookup the value at a key in the map.
@@ -316,7 +315,7 @@ lookup' :: Ord k => k -> Map k a -> Maybe a
 lookup' k t
   = case t of
       Tip -> Nothing
-      Bin sz kx x l r
+      Bin _ kx x l r
           -> case compare k kx of
                LT -> lookup' k l
                GT -> lookup' k r
@@ -326,7 +325,7 @@ lookupAssoc :: Ord k => k -> Map k a -> Maybe (k,a)
 lookupAssoc  k t
   = case t of
       Tip -> Nothing
-      Bin sz kx x l r
+      Bin _ kx x l r
           -> case compare k kx of
                LT -> lookupAssoc k l
                GT -> lookupAssoc k r
@@ -341,7 +340,7 @@ member :: Ord k => k -> Map k a -> Bool
 member k m
   = case lookup k m of
       Nothing -> False
-      Just x  -> True
+      Just _  -> True
 
 -- | /O(log n)/. Is the key not a member of the map? See also 'member'.
 --
@@ -429,12 +428,12 @@ insert kx x t
 
 insertWith :: Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
 insertWith f k x m          
-  = insertWithKey (\k x y -> f x y) k x m
+  = insertWithKey (\_ x' y' -> f x' y') k x m
 
 -- | Same as 'insertWith', but the combining function is applied strictly.
 insertWith' :: Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
 insertWith' f k x m          
-  = insertWithKey' (\k x y -> f x y) k x m
+  = insertWithKey' (\_ x' y' -> f x' y') k x m
 
 
 -- | /O(log n)/. Insert with a function, combining key, new value and old value.
@@ -512,7 +511,7 @@ delete :: Ord k => k -> Map k a -> Map k a
 delete k t
   = case t of
       Tip -> Tip
-      Bin sx kx x l r 
+      Bin _ kx x l r
           -> case compare k kx of
                LT -> balance kx x (delete k l) r
                GT -> balance kx x l (delete k r)
@@ -528,7 +527,7 @@ delete k t
 
 adjust :: Ord k => (a -> a) -> k -> Map k a -> Map k a
 adjust f k m
-  = adjustWithKey (\k x -> f x) k m
+  = adjustWithKey (\_ x -> f x) k m
 
 -- | /O(log n)/. Adjust a value at a specific key. When the key is not
 -- a member of the map, the original map is returned.
@@ -540,7 +539,7 @@ adjust f k m
 
 adjustWithKey :: Ord k => (k -> a -> a) -> k -> Map k a -> Map k a
 adjustWithKey f k m
-  = updateWithKey (\k x -> Just (f k x)) k m
+  = updateWithKey (\k' x' -> Just (f k' x')) k m
 
 -- | /O(log n)/. The expression (@'update' f k map@) updates the value @x@
 -- at @k@ (if it is in the map). If (@f x@) is 'Nothing', the element is
@@ -553,7 +552,7 @@ adjustWithKey f k m
 
 update :: Ord k => (a -> Maybe a) -> k -> Map k a -> Map k a
 update f k m
-  = updateWithKey (\k x -> f x) k m
+  = updateWithKey (\_ x -> f x) k m
 
 -- | /O(log n)/. The expression (@'updateWithKey' f k map@) updates the
 -- value @x@ at @k@ (if it is in the map). If (@f k x@) is 'Nothing',
@@ -651,15 +650,15 @@ findIndex k t
 -- > isJust (lookupIndex 6 (fromList [(5,"a"), (3,"b")]))   == False
 
 lookupIndex :: (Monad m,Ord k) => k -> Map k a -> m Int
-lookupIndex k t = case lookup 0 t of
+lookupIndex k t = case f 0 t of
     Nothing -> fail "Data.Map.lookupIndex: Key not found."
     Just x -> return x
   where
-    lookup idx Tip  = Nothing
-    lookup idx (Bin _ kx x l r)
+    f _   Tip  = Nothing
+    f idx (Bin _ kx _ l r)
       = case compare k kx of
-          LT -> lookup idx l
-          GT -> lookup (idx + size l + 1) r 
+          LT -> f idx l
+          GT -> f (idx + size l + 1) r 
           EQ -> Just (idx + size l)
 
 -- | /O(log n)/. Retrieve an element by /index/. Calls 'error' when an
@@ -670,7 +669,7 @@ lookupIndex k t = case lookup 0 t of
 -- > elemAt 2 (fromList [(5,"a"), (3,"b")])    Error: index out of range
 
 elemAt :: Int -> Map k a -> (k,a)
-elemAt i Tip = error "Map.elemAt: index out of range"
+elemAt _ Tip = error "Map.elemAt: index out of range"
 elemAt i (Bin _ kx x l r)
   = case compare i sizeL of
       LT -> elemAt i l
@@ -692,7 +691,7 @@ elemAt i (Bin _ kx x l r)
 -- > updateAt (\_ _  -> Nothing)  (-1) (fromList [(5,"a"), (3,"b")])    Error: index out of range
 
 updateAt :: (k -> a -> Maybe a) -> Int -> Map k a -> Map k a
-updateAt f i Tip  = error "Map.updateAt: index out of range"
+updateAt _ _ Tip  = error "Map.updateAt: index out of range"
 updateAt f i (Bin sx kx x l r)
   = case compare i sizeL of
       LT -> balance kx x (updateAt f i l) r
@@ -712,8 +711,8 @@ updateAt f i (Bin sx kx x l r)
 -- > deleteAt (-1) (fromList [(5,"a"), (3,"b")])  Error: index out of range
 
 deleteAt :: Int -> Map k a -> Map k a
-deleteAt i map
-  = updateAt (\k x -> Nothing) i map
+deleteAt i m
+  = updateAt (\_ _ -> Nothing) i m
 
 
 {--------------------------------------------------------------------
@@ -725,8 +724,8 @@ deleteAt i map
 -- > findMin empty                            Error: empty map has no minimal element
 
 findMin :: Map k a -> (k,a)
-findMin (Bin _ kx x Tip r)  = (kx,x)
-findMin (Bin _ kx x l r)    = findMin l
+findMin (Bin _ kx x Tip _)  = (kx,x)
+findMin (Bin _ _  _ l _)    = findMin l
 findMin Tip                 = error "Map.findMin: empty map has no minimal element"
 
 -- | /O(log n)/. The maximal key of the map. Calls 'error' is the map is empty.
@@ -735,8 +734,8 @@ findMin Tip                 = error "Map.findMin: empty map has no minimal eleme
 -- > findMax empty                            Error: empty map has no maximal element
 
 findMax :: Map k a -> (k,a)
-findMax (Bin _ kx x l Tip)  = (kx,x)
-findMax (Bin _ kx x l r)    = findMax r
+findMax (Bin _ kx x _ Tip)  = (kx,x)
+findMax (Bin _ _  _ _ r)    = findMax r
 findMax Tip                 = error "Map.findMax: empty map has no maximal element"
 
 -- | /O(log n)/. Delete the minimal key. Returns an empty map if the map is empty.
@@ -745,7 +744,7 @@ findMax Tip                 = error "Map.findMax: empty map has no maximal eleme
 -- > deleteMin empty == empty
 
 deleteMin :: Map k a -> Map k a
-deleteMin (Bin _ kx x Tip r)  = r
+deleteMin (Bin _ _  _ Tip r)  = r
 deleteMin (Bin _ kx x l r)    = balance kx x (deleteMin l) r
 deleteMin Tip                 = Tip
 
@@ -755,7 +754,7 @@ deleteMin Tip                 = Tip
 -- > deleteMax empty == empty
 
 deleteMax :: Map k a -> Map k a
-deleteMax (Bin _ kx x l Tip)  = l
+deleteMax (Bin _ _  _ l Tip)  = l
 deleteMax (Bin _ kx x l r)    = balance kx x l (deleteMax r)
 deleteMax Tip                 = Tip
 
@@ -766,7 +765,7 @@ deleteMax Tip                 = Tip
 
 updateMin :: (a -> Maybe a) -> Map k a -> Map k a
 updateMin f m
-  = updateMinWithKey (\k x -> f x) m
+  = updateMinWithKey (\_ x -> f x) m
 
 -- | /O(log n)/. Update the value at the maximal key.
 --
@@ -775,7 +774,7 @@ updateMin f m
 
 updateMax :: (a -> Maybe a) -> Map k a -> Map k a
 updateMax f m
-  = updateMaxWithKey (\k x -> f x) m
+  = updateMaxWithKey (\_ x -> f x) m
 
 
 -- | /O(log n)/. Update the value at the minimal key.
@@ -789,7 +788,7 @@ updateMinWithKey f t
       Bin sx kx x Tip r  -> case f kx x of
                               Nothing -> r
                               Just x' -> Bin sx kx x' Tip r
-      Bin sx kx x l r    -> balance kx x (updateMinWithKey f l) r
+      Bin _ kx x l r     -> balance kx x (updateMinWithKey f l) r
       Tip                -> Tip
 
 -- | /O(log n)/. Update the value at the maximal key.
@@ -803,7 +802,7 @@ updateMaxWithKey f t
       Bin sx kx x l Tip  -> case f kx x of
                               Nothing -> l
                               Just x' -> Bin sx kx x' l Tip
-      Bin sx kx x l r    -> balance kx x l (updateMaxWithKey f r)
+      Bin _ kx x l r     -> balance kx x l (updateMaxWithKey f r)
       Tip                -> Tip
 
 -- | /O(log n)/. Retrieves the minimal (key,value) pair of the map, and the map stripped from that element
@@ -894,7 +893,10 @@ union t1 Tip  = t1
 union t1 t2 = hedgeUnionL (const LT) (const GT) t1 t2
 
 -- left-biased hedge union
-hedgeUnionL cmplo cmphi t1 Tip 
+hedgeUnionL :: Ord a
+            => (a -> Ordering) -> (a -> Ordering) -> Map a b -> Map a b
+            -> Map a b
+hedgeUnionL _     _     t1 Tip
   = t1
 hedgeUnionL cmplo cmphi Tip (Bin _ kx x l r)
   = join kx x (filterGt cmplo l) (filterLt cmphi r)
@@ -904,8 +906,14 @@ hedgeUnionL cmplo cmphi (Bin _ kx x l r) t2
   where
     cmpkx k  = compare kx k
 
+{-
+XXX unused code
+
 -- right-biased hedge union
-hedgeUnionR cmplo cmphi t1 Tip 
+hedgeUnionR :: Ord a
+            => (a -> Ordering) -> (a -> Ordering) -> Map a b -> Map a b
+            -> Map a b
+hedgeUnionR _     _     t1 Tip
   = t1
 hedgeUnionR cmplo cmphi Tip (Bin _ kx x l r)
   = join kx x (filterGt cmplo l) (filterLt cmphi r)
@@ -919,6 +927,7 @@ hedgeUnionR cmplo cmphi (Bin _ kx x l r) t2
     newx        = case found of
                     Nothing -> x
                     Just (_,y) -> y
+-}
 
 {--------------------------------------------------------------------
   Union with a combining function
@@ -929,7 +938,7 @@ hedgeUnionR cmplo cmphi (Bin _ kx x l r) t2
 
 unionWith :: Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
 unionWith f m1 m2
-  = unionWithKey (\k x y -> f x y) m1 m2
+  = unionWithKey (\_ x y -> f x y) m1 m2
 
 -- | /O(n+m)/.
 -- Union with a combining function. The implementation uses the efficient /hedge-union/ algorithm.
@@ -939,13 +948,18 @@ unionWith f m1 m2
 -- > unionWithKey f (fromList [(5, "a"), (3, "b")]) (fromList [(5, "A"), (7, "C")]) == fromList [(3, "b"), (5, "5:a|A"), (7, "C")]
 
 unionWithKey :: Ord k => (k -> a -> a -> a) -> Map k a -> Map k a -> Map k a
-unionWithKey f Tip t2  = t2
-unionWithKey f t1 Tip  = t1
+unionWithKey _ Tip t2  = t2
+unionWithKey _ t1 Tip  = t1
 unionWithKey f t1 t2 = hedgeUnionWithKey f (const LT) (const GT) t1 t2
 
-hedgeUnionWithKey f cmplo cmphi t1 Tip 
+hedgeUnionWithKey :: Ord a
+                  => (a -> b -> b -> b)
+                  -> (a -> Ordering) -> (a -> Ordering)
+                  -> Map a b -> Map a b
+                  -> Map a b
+hedgeUnionWithKey _ _     _     t1 Tip
   = t1
-hedgeUnionWithKey f cmplo cmphi Tip (Bin _ kx x l r)
+hedgeUnionWithKey _ cmplo cmphi Tip (Bin _ kx x l r)
   = join kx x (filterGt cmplo l) (filterLt cmphi r)
 hedgeUnionWithKey f cmplo cmphi (Bin _ kx x l r) t2
   = join kx newx (hedgeUnionWithKey f cmplo cmpkx l lt) 
@@ -968,15 +982,18 @@ hedgeUnionWithKey f cmplo cmphi (Bin _ kx x l r) t2
 -- > difference (fromList [(5, "a"), (3, "b")]) (fromList [(5, "A"), (7, "C")]) == singleton 3 "b"
 
 difference :: Ord k => Map k a -> Map k b -> Map k a
-difference Tip t2  = Tip
+difference Tip   = Tip
 difference t1 Tip  = t1
 difference t1 t2   = hedgeDiff (const LT) (const GT) t1 t2
 
-hedgeDiff cmplo cmphi Tip t     
+hedgeDiff :: Ord a
+          => (a -> Ordering) -> (a -> Ordering) -> Map a b -> Map a c
+          -> Map a b
+hedgeDiff _     _     Tip _
   = Tip
 hedgeDiff cmplo cmphi (Bin _ kx x l r) Tip 
   = join kx x (filterGt cmplo l) (filterLt cmphi r)
-hedgeDiff cmplo cmphi t (Bin _ kx x l r) 
+hedgeDiff cmplo cmphi t (Bin _ kx _ l r) 
   = merge (hedgeDiff cmplo cmpkx (trim cmplo cmpkx t) l) 
           (hedgeDiff cmpkx cmphi (trim cmpkx cmphi t) r)
   where
@@ -995,7 +1012,7 @@ hedgeDiff cmplo cmphi t (Bin _ kx x l r)
 
 differenceWith :: Ord k => (a -> b -> Maybe a) -> Map k a -> Map k b -> Map k a
 differenceWith f m1 m2
-  = differenceWithKey (\k x y -> f x y) m1 m2
+  = differenceWithKey (\_ x y -> f x y) m1 m2
 
 -- | /O(n+m)/. Difference with a combining function. When two equal keys are
 -- encountered, the combining function is applied to the key and both values.
@@ -1008,13 +1025,18 @@ differenceWith f m1 m2
 -- >     == singleton 3 "3:b|B"
 
 differenceWithKey :: Ord k => (k -> a -> b -> Maybe a) -> Map k a -> Map k b -> Map k a
-differenceWithKey f Tip t2  = Tip
-differenceWithKey f t1 Tip  = t1
+differenceWithKey _ Tip _   = Tip
+differenceWithKey _ t1 Tip  = t1
 differenceWithKey f t1 t2   = hedgeDiffWithKey f (const LT) (const GT) t1 t2
 
-hedgeDiffWithKey f cmplo cmphi Tip t     
+hedgeDiffWithKey :: Ord a
+                 => (a -> b -> c -> Maybe b)
+                 -> (a -> Ordering) -> (a -> Ordering)
+                 -> Map a b -> Map a c
+                 -> Map a b
+hedgeDiffWithKey _ _     _     Tip _
   = Tip
-hedgeDiffWithKey f cmplo cmphi (Bin _ kx x l r) Tip 
+hedgeDiffWithKey _ cmplo cmphi (Bin _ kx x l r) Tip
   = join kx x (filterGt cmplo l) (filterLt cmphi r)
 hedgeDiffWithKey f cmplo cmphi t (Bin _ kx x l r) 
   = case found of
@@ -1043,7 +1065,7 @@ hedgeDiffWithKey f cmplo cmphi t (Bin _ kx x l r)
 
 intersection :: Ord k => Map k a -> Map k b -> Map k a
 intersection m1 m2
-  = intersectionWithKey (\k x y -> x) m1 m2
+  = intersectionWithKey (\_ x _ -> x) m1 m2
 
 -- | /O(n+m)/. Intersection with a combining function.
 --
@@ -1051,7 +1073,7 @@ intersection m1 m2
 
 intersectionWith :: Ord k => (a -> b -> c) -> Map k a -> Map k b -> Map k c
 intersectionWith f m1 m2
-  = intersectionWithKey (\k x y -> f x y) m1 m2
+  = intersectionWithKey (\_ x y -> f x y) m1 m2
 
 -- | /O(n+m)/. Intersection with a combining function.
 -- Intersection is more efficient on (bigset \``intersection`\` smallset).
@@ -1076,8 +1098,8 @@ intersectionWith f m1 m2
 --    tr            = intersectWithKey f gt r
 
 intersectionWithKey :: Ord k => (k -> a -> b -> c) -> Map k a -> Map k b -> Map k c
-intersectionWithKey f Tip t = Tip
-intersectionWithKey f t Tip = Tip
+intersectionWithKey _ Tip _ = Tip
+intersectionWithKey _ _ Tip = Tip
 intersectionWithKey f t1@(Bin s1 k1 x1 l1 r1) t2@(Bin s2 k2 x2 l2 r2) =
    if s1 >= s2 then
       let (lt,found,gt) = splitLookupWithKey k2 t1
@@ -1127,8 +1149,9 @@ isSubmapOfBy :: Ord k => (a->b->Bool) -> Map k a -> Map k b -> Bool
 isSubmapOfBy f t1 t2
   = (size t1 <= size t2) && (submap' f t1 t2)
 
-submap' f Tip t = True
-submap' f t Tip = False
+submap' :: Ord a => (b -> c -> Bool) -> Map a b -> Map a c -> Bool
+submap' _ Tip _ = True
+submap' _ _ Tip = False
 submap' f (Bin _ kx x l r) t
   = case found of
       Nothing -> False
@@ -1175,14 +1198,14 @@ isProperSubmapOfBy f t1 t2
 
 filter :: Ord k => (a -> Bool) -> Map k a -> Map k a
 filter p m
-  = filterWithKey (\k x -> p x) m
+  = filterWithKey (\_ x -> p x) m
 
 -- | /O(n)/. Filter all keys\/values that satisfy the predicate.
 --
 -- > filterWithKey (\k _ -> k > 4) (fromList [(5,"a"), (3,"b")]) == singleton 5 "a"
 
 filterWithKey :: Ord k => (k -> a -> Bool) -> Map k a -> Map k a
-filterWithKey p Tip = Tip
+filterWithKey _ Tip = Tip
 filterWithKey p (Bin _ kx x l r)
   | p kx x    = join kx x (filterWithKey p l) (filterWithKey p r)
   | otherwise = merge (filterWithKey p l) (filterWithKey p r)
@@ -1198,7 +1221,7 @@ filterWithKey p (Bin _ kx x l r)
 
 partition :: Ord k => (a -> Bool) -> Map k a -> (Map k a,Map k a)
 partition p m
-  = partitionWithKey (\k x -> p x) m
+  = partitionWithKey (\_ x -> p x) m
 
 -- | /O(n)/. Partition the map according to a predicate. The first
 -- map contains all elements that satisfy the predicate, the second all
@@ -1209,7 +1232,7 @@ partition p m
 -- > partitionWithKey (\ k _ -> k > 7) (fromList [(5,"a"), (3,"b")]) == (empty, fromList [(3, "b"), (5, "a")])
 
 partitionWithKey :: Ord k => (k -> a -> Bool) -> Map k a -> (Map k a,Map k a)
-partitionWithKey p Tip = (Tip,Tip)
+partitionWithKey _ Tip = (Tip,Tip)
 partitionWithKey p (Bin _ kx x l r)
   | p kx x    = (join kx x l1 r1,merge l2 r2)
   | otherwise = (merge l1 r1,join kx x l2 r2)
@@ -1224,7 +1247,7 @@ partitionWithKey p (Bin _ kx x l r)
 
 mapMaybe :: Ord k => (a -> Maybe b) -> Map k a -> Map k b
 mapMaybe f m
-  = mapMaybeWithKey (\k x -> f x) m
+  = mapMaybeWithKey (\_ x -> f x) m
 
 -- | /O(n)/. Map keys\/values and collect the 'Just' results.
 --
@@ -1232,7 +1255,7 @@ mapMaybe f m
 -- > mapMaybeWithKey f (fromList [(5,"a"), (3,"b")]) == singleton 3 "key : 3"
 
 mapMaybeWithKey :: Ord k => (k -> a -> Maybe b) -> Map k a -> Map k b
-mapMaybeWithKey f Tip = Tip
+mapMaybeWithKey _ Tip = Tip
 mapMaybeWithKey f (Bin _ kx x l r) = case f kx x of
   Just y  -> join kx y (mapMaybeWithKey f l) (mapMaybeWithKey f r)
   Nothing -> merge (mapMaybeWithKey f l) (mapMaybeWithKey f r)
@@ -1248,7 +1271,7 @@ mapMaybeWithKey f (Bin _ kx x l r) = case f kx x of
 
 mapEither :: Ord k => (a -> Either b c) -> Map k a -> (Map k b, Map k c)
 mapEither f m
-  = mapEitherWithKey (\k x -> f x) m
+  = mapEitherWithKey (\_ x -> f x) m
 
 -- | /O(n)/. Map keys\/values and separate the 'Left' and 'Right' results.
 --
@@ -1261,7 +1284,7 @@ mapEither f m
 
 mapEitherWithKey :: Ord k =>
   (k -> a -> Either b c) -> Map k a -> (Map k b, Map k c)
-mapEitherWithKey f Tip = (Tip, Tip)
+mapEitherWithKey _ Tip = (Tip, Tip)
 mapEitherWithKey f (Bin _ kx x l r) = case f kx x of
   Left y  -> (join kx y l1 r1, merge l2 r2)
   Right z -> (merge l1 r1, join kx z l2 r2)
@@ -1278,7 +1301,7 @@ mapEitherWithKey f (Bin _ kx x l r) = case f kx x of
 
 map :: (a -> b) -> Map k a -> Map k b
 map f m
-  = mapWithKey (\k x -> f x) m
+  = mapWithKey (\_ x -> f x) m
 
 -- | /O(n)/. Map a function over all values in the map.
 --
@@ -1286,7 +1309,7 @@ map f m
 -- > mapWithKey f (fromList [(5,"a"), (3,"b")]) == fromList [(3, "3:b"), (5, "5:a")]
 
 mapWithKey :: (k -> a -> b) -> Map k a -> Map k b
-mapWithKey f Tip = Tip
+mapWithKey _ Tip = Tip
 mapWithKey f (Bin sx kx x l r) 
   = Bin sx kx (f kx x) (mapWithKey f l) (mapWithKey f r)
 
@@ -1298,7 +1321,7 @@ mapWithKey f (Bin sx kx x l r)
 
 mapAccum :: (a -> b -> (a,c)) -> a -> Map k b -> (a,Map k c)
 mapAccum f a m
-  = mapAccumWithKey (\a k x -> f a x) a m
+  = mapAccumWithKey (\a' _ x' -> f a' x') a m
 
 -- | /O(n)/. The function 'mapAccumWithKey' threads an accumulating
 -- argument through the map in ascending order of keys.
@@ -1322,6 +1345,9 @@ mapAccumL f a t
                  (a3,r') = mapAccumL f a2 r
              in (a3,Bin sx kx x' l' r')
 
+{-
+XXX unused code
+
 -- | /O(n)/. The function 'mapAccumR' threads an accumulating
 -- argument throught the map in descending order of keys.
 mapAccumR :: (a -> k -> b -> (a,c)) -> a -> Map k b -> (a,Map k c)
@@ -1333,6 +1359,7 @@ mapAccumR f a t
                  (a2,x') = f a1 kx x
                  (a3,l') = mapAccumR f a2 l
              in (a3,Bin sx kx x' l' r')
+-}
 
 -- | /O(n*log n)/.
 -- @'mapKeys' f s@ is the map obtained by applying @f@ to each key of @s@.
@@ -1346,7 +1373,7 @@ mapAccumR f a t
 -- > mapKeys (\ _ -> 3) (fromList [(1,"b"), (2,"a"), (3,"d"), (4,"c")]) == singleton 3 "c"
 
 mapKeys :: Ord k2 => (k1->k2) -> Map k1 a -> Map k2 a
-mapKeys = mapKeysWith (\x y->x)
+mapKeys = mapKeysWith (\x _ -> x)
 
 -- | /O(n*log n)/.
 -- @'mapKeysWith' c f s@ is the map obtained by applying @f@ to each key of @s@.
@@ -1382,7 +1409,7 @@ mapKeysWith c f = fromListWith c . List.map fFirst . toList
 -- > valid (mapKeysMonotonic (\ _ -> 1)     (fromList [(5,"a"), (3,"b")])) == False
 
 mapKeysMonotonic :: (k1->k2) -> Map k1 a -> Map k2 a
-mapKeysMonotonic f Tip = Tip
+mapKeysMonotonic _ Tip = Tip
 mapKeysMonotonic f (Bin sz k x l r) =
     Bin sz (f k) x (mapKeysMonotonic f l) (mapKeysMonotonic f r)
 
@@ -1401,7 +1428,7 @@ mapKeysMonotonic f (Bin sz k x l r) =
 
 fold :: (a -> b -> b) -> b -> Map k a -> b
 fold f z m
-  = foldWithKey (\k x z -> f x z) z m
+  = foldWithKey (\_ x' z' -> f x' z') z m
 
 -- | /O(n)/. Fold the keys and values in the map, such that
 -- @'foldWithKey' f z == 'Prelude.foldr' ('uncurry' f) z . 'toAscList'@.
@@ -1416,20 +1443,28 @@ foldWithKey :: (k -> a -> b -> b) -> b -> Map k a -> b
 foldWithKey f z t
   = foldr f z t
 
+{-
+XXX unused code
+
 -- | /O(n)/. In-order fold.
 foldi :: (k -> a -> b -> b -> b) -> b -> Map k a -> b 
-foldi f z Tip               = z
+foldi _ z Tip               = z
 foldi f z (Bin _ kx x l r)  = f kx x (foldi f z l) (foldi f z r)
+-}
 
 -- | /O(n)/. Post-order fold.
 foldr :: (k -> a -> b -> b) -> b -> Map k a -> b
-foldr f z Tip              = z
+foldr _ z Tip              = z
 foldr f z (Bin _ kx x l r) = foldr f (f kx x (foldr f z r)) l
 
+{-
+XXX unused code
+
 -- | /O(n)/. Pre-order fold.
 foldl :: (b -> k -> a -> b) -> b -> Map k a -> b
-foldl f z Tip              = z
+foldl _ z Tip              = z
 foldl f z (Bin _ kx x l r) = foldl f (f (foldl f z l) kx x) r
+-}
 
 {--------------------------------------------------------------------
   List variations 
@@ -1442,7 +1477,7 @@ foldl f z (Bin _ kx x l r) = foldl f (f (foldl f z l) kx x) r
 
 elems :: Map k a -> [a]
 elems m
-  = [x | (k,x) <- assocs m]
+  = [x | (_,x) <- assocs m]
 
 -- | /O(n)/. Return all keys of the map in ascending order.
 --
@@ -1451,7 +1486,7 @@ elems m
 
 keys  :: Map k a -> [k]
 keys m
-  = [k | (k,x) <- assocs m]
+  = [k | (k,_) <- assocs m]
 
 -- | /O(n)/. The set of all keys of the map.
 --
@@ -1495,7 +1530,7 @@ fromList xs
 
 fromListWith :: Ord k => (a -> a -> a) -> [(k,a)] -> Map k a 
 fromListWith f xs
-  = fromListWithKey (\k x y -> f x y) xs
+  = fromListWithKey (\_ x y -> f x y) xs
 
 -- | /O(n*log n)/. Build a map from a list of key\/value pairs with a combining function. See also 'fromAscListWithKey'.
 --
@@ -1524,10 +1559,13 @@ toList t      = toAscList t
 toAscList :: Map k a -> [(k,a)]
 toAscList t   = foldr (\k x xs -> (k,x):xs) [] t
 
+{-
+XXX unused code
+
 -- | /O(n)/.
 toDescList :: Map k a -> [(k,a)]
 toDescList t  = foldl (\xs k x -> (k,x):xs) [] t
-
+-}
 
 {--------------------------------------------------------------------
   Building trees from ascending/descending lists can be done in linear time.
@@ -1546,7 +1584,7 @@ toDescList t  = foldl (\xs k x -> (k,x):xs) [] t
 
 fromAscList :: Eq k => [(k,a)] -> Map k a 
 fromAscList xs
-  = fromAscListWithKey (\k x y -> x) xs
+  = fromAscListWithKey (\_ x _ -> x) xs
 
 -- | /O(n)/. Build a map from an ascending list in linear time with a combining function for equal keys.
 -- /The precondition (input list is ascending) is not checked./
@@ -1557,7 +1595,7 @@ fromAscList xs
 
 fromAscListWith :: Eq k => (a -> a -> a) -> [(k,a)] -> Map k a 
 fromAscListWith f xs
-  = fromAscListWithKey (\k x y -> f x y) xs
+  = fromAscListWithKey (\_ x y -> f x y) xs
 
 -- | /O(n)/. Build a map from an ascending list in linear time with a
 -- combining function for equal keys.
@@ -1573,16 +1611,16 @@ fromAscListWithKey f xs
   = fromDistinctAscList (combineEq f xs)
   where
   -- [combineEq f xs] combines equal elements with function [f] in an ordered list [xs]
-  combineEq f xs
-    = case xs of
+  combineEq _ xs'
+    = case xs' of
         []     -> []
         [x]    -> [x]
         (x:xx) -> combineEq' x xx
 
   combineEq' z [] = [z]
-  combineEq' z@(kz,zz) (x@(kx,xx):xs)
-    | kx==kz    = let yy = f kx xx zz in combineEq' (kx,yy) xs
-    | otherwise = z:combineEq' x xs
+  combineEq' z@(kz,zz) (x@(kx,xx):xs')
+    | kx==kz    = let yy = f kx xx zz in combineEq' (kx,yy) xs'
+    | otherwise = z:combineEq' x xs'
 
 
 -- | /O(n)/. Build a map from an ascending list of distinct elements in linear time.
@@ -1598,16 +1636,18 @@ fromDistinctAscList xs
   where
     -- 1) use continutations so that we use heap space instead of stack space.
     -- 2) special case for n==5 to build bushier trees. 
-    build c 0 xs   = c Tip xs 
-    build c 5 xs   = case xs of
+    build c 0 xs'  = c Tip xs'
+    build c 5 xs'  = case xs' of
                        ((k1,x1):(k2,x2):(k3,x3):(k4,x4):(k5,x5):xx) 
                             -> c (bin k4 x4 (bin k2 x2 (singleton k1 x1) (singleton k3 x3)) (singleton k5 x5)) xx
-    build c n xs   = seq nr $ build (buildR nr c) nl xs
+                       _ -> error "fromDistinctAscList build"
+    build c n xs'  = seq nr $ build (buildR nr c) nl xs'
                    where
                      nl = n `div` 2
                      nr = n - nl - 1
 
     buildR n c l ((k,x):ys) = build (buildB l k x c) n ys
+    buildR _ _ _ []         = error "fromDistinctAscList buildR []"
     buildB l k x c r zs     = c (bin k x l r) zs
                       
 
@@ -1635,21 +1675,21 @@ fromDistinctAscList xs
   empty or the key of the root is between @lo@ and @hi@.
 --------------------------------------------------------------------}
 trim :: (k -> Ordering) -> (k -> Ordering) -> Map k a -> Map k a
-trim cmplo cmphi Tip = Tip
-trim cmplo cmphi t@(Bin sx kx x l r)
+trim _     _     Tip = Tip
+trim cmplo cmphi t@(Bin _ kx _ l r)
   = case cmplo kx of
       LT -> case cmphi kx of
               GT -> t
-              le -> trim cmplo cmphi l
-      ge -> trim cmplo cmphi r
+               -> trim cmplo cmphi l
+       -> trim cmplo cmphi r
               
 trimLookupLo :: Ord k => k -> (k -> Ordering) -> Map k a -> (Maybe (k,a), Map k a)
-trimLookupLo lo cmphi Tip = (Nothing,Tip)
-trimLookupLo lo cmphi t@(Bin sx kx x l r)
+trimLookupLo _  _     Tip = (Nothing,Tip)
+trimLookupLo lo cmphi t@(Bin _ kx x l r)
   = case compare lo kx of
       LT -> case cmphi kx of
               GT -> (lookupAssoc lo t, t)
-              le -> trimLookupLo lo cmphi l
+               -> trimLookupLo lo cmphi l
       GT -> trimLookupLo lo cmphi r
       EQ -> (Just (kx,x),trim (compare lo) cmphi r)
 
@@ -1659,16 +1699,16 @@ trimLookupLo lo cmphi t@(Bin sx kx x l r)
   [filterLt k t] filter all keys <[k] from tree [t]
 --------------------------------------------------------------------}
 filterGt :: Ord k => (k -> Ordering) -> Map k a -> Map k a
-filterGt cmp Tip = Tip
-filterGt cmp (Bin sx kx x l r)
+filterGt _   Tip = Tip
+filterGt cmp (Bin _ kx x l r)
   = case cmp kx of
       LT -> join kx x (filterGt cmp l) r
       GT -> filterGt cmp r
       EQ -> r
       
 filterLt :: Ord k => (k -> Ordering) -> Map k a -> Map k a
-filterLt cmp Tip = Tip
-filterLt cmp (Bin sx kx x l r)
+filterLt _   Tip = Tip
+filterLt cmp (Bin _ kx x l r)
   = case cmp kx of
       LT -> filterLt cmp l
       GT -> join kx x l (filterLt cmp r)
@@ -1688,8 +1728,8 @@ filterLt cmp (Bin sx kx x l r)
 -- > split 6 (fromList [(5,"a"), (3,"b")]) == (fromList [(3,"b"), (5,"a")], empty)
 
 split :: Ord k => k -> Map k a -> (Map k a,Map k a)
-split k Tip = (Tip,Tip)
-split k (Bin sx kx x l r)
+split _ Tip = (Tip,Tip)
+split k (Bin _ kx x l r)
   = case compare k kx of
       LT -> let (lt,gt) = split k l in (lt,join kx x gt r)
       GT -> let (lt,gt) = split k r in (join kx x l lt,gt)
@@ -1705,8 +1745,8 @@ split k (Bin sx kx x l r)
 -- > splitLookup 6 (fromList [(5,"a"), (3,"b")]) == (fromList [(3,"b"), (5,"a")], Nothing, empty)
 
 splitLookup :: Ord k => k -> Map k a -> (Map k a,Maybe a,Map k a)
-splitLookup k Tip = (Tip,Nothing,Tip)
-splitLookup k (Bin sx kx x l r)
+splitLookup _ Tip = (Tip,Nothing,Tip)
+splitLookup k (Bin _ kx x l r)
   = case compare k kx of
       LT -> let (lt,z,gt) = splitLookup k l in (lt,z,join kx x gt r)
       GT -> let (lt,z,gt) = splitLookup k r in (join kx x l lt,z,gt)
@@ -1714,19 +1754,22 @@ splitLookup k (Bin sx kx x l r)
 
 -- | /O(log n)/.
 splitLookupWithKey :: Ord k => k -> Map k a -> (Map k a,Maybe (k,a),Map k a)
-splitLookupWithKey k Tip = (Tip,Nothing,Tip)
-splitLookupWithKey k (Bin sx kx x l r)
+splitLookupWithKey _ Tip = (Tip,Nothing,Tip)
+splitLookupWithKey k (Bin _ kx x l r)
   = case compare k kx of
       LT -> let (lt,z,gt) = splitLookupWithKey k l in (lt,z,join kx x gt r)
       GT -> let (lt,z,gt) = splitLookupWithKey k r in (join kx x l lt,z,gt)
       EQ -> (l,Just (kx, x),r)
 
+{-
+XXX unused code
+
 -- | /O(log n)/. Performs a 'split' but also returns whether the pivot
 -- element was found in the original set.
 splitMember :: Ord k => k -> Map k a -> (Map k a,Bool,Map k a)
 splitMember x t = let (l,m,r) = splitLookup x t in
      (l,maybe False (const True) m,r)
-
+-}
 
 {--------------------------------------------------------------------
   Utility functions that maintain the balance properties of the tree.
@@ -1774,13 +1817,13 @@ insertMax,insertMin :: k -> a -> Map k a -> Map k a
 insertMax kx x t
   = case t of
       Tip -> singleton kx x
-      Bin sz ky y l r
+      Bin _ ky y l r
           -> balance ky y l (insertMax kx x r)
              
 insertMin kx x t
   = case t of
       Tip -> singleton kx x
-      Bin sz ky y l r
+      Bin _ ky y l r
           -> balance ky y (insertMin kx x l) r
              
 {--------------------------------------------------------------------
@@ -1877,20 +1920,30 @@ balance k x l r
     sizeX = sizeL + sizeR + 1
 
 -- rotate
+rotateL :: a -> b -> Map a b -> Map a b -> Map a b
 rotateL k x l r@(Bin _ _ _ ly ry)
   | size ly < ratio*size ry = singleL k x l r
   | otherwise               = doubleL k x l r
+rotateL _ _ _ Tip = error "rotateL Tip"
 
+rotateR :: a -> b -> Map a b -> Map a b -> Map a b
 rotateR k x l@(Bin _ _ _ ly ry) r
   | size ry < ratio*size ly = singleR k x l r
   | otherwise               = doubleR k x l r
+rotateR _ _ Tip _ = error "rotateR Tip"
 
 -- basic rotations
+singleL, singleR :: a -> b -> Map a b -> Map a b -> Map a b
 singleL k1 x1 t1 (Bin _ k2 x2 t2 t3)  = bin k2 x2 (bin k1 x1 t1 t2) t3
+singleL _ _ _ Tip = error "singleL Tip"
 singleR k1 x1 (Bin _ k2 x2 t1 t2) t3  = bin k2 x2 t1 (bin k1 x1 t2 t3)
+singleR _ _ Tip _ = error "singleR Tip"
 
+doubleL, doubleR :: a -> b -> Map a b -> Map a b -> Map a b
 doubleL k1 x1 t1 (Bin _ k2 x2 (Bin _ k3 x3 t2 t3) t4) = bin k3 x3 (bin k1 x1 t1 t2) (bin k2 x2 t3 t4)
+doubleL _ _ _ _ = error "doubleL"
 doubleR k1 x1 (Bin _ k2 x2 t1 (Bin _ k3 x3 t2 t3)) t4 = bin k3 x3 (bin k2 x2 t1 t2) (bin k1 x1 t3 t4)
+doubleR _ _ _ _ = error "doubleR"
 
 
 {--------------------------------------------------------------------
@@ -1923,7 +1976,7 @@ instance Functor (Map k) where
   fmap f m  = map f m
 
 instance Traversable (Map k) where
-  traverse f Tip = pure Tip
+  traverse _ Tip = pure Tip
   traverse f (Bin s k v l r)
     = flip (Bin s k) <$> traverse f l <*> f v <*> traverse f r
 
@@ -1950,12 +2003,16 @@ instance (Ord k, Read k, Read e) => Read (Map k e) where
     return (fromList xs,t)
 #endif
 
+{-
+XXX unused code
+
 -- parses a pair of things with the syntax a:=b
 readPair :: (Read a, Read b) => ReadS (a,b)
 readPair s = do (a, ct1)    <- reads s
                 (":=", ct2) <- lex ct1
                 (b, ct3)    <- reads ct2
                 return ((a,b), ct3)
+-}
 
 {--------------------------------------------------------------------
   Show
@@ -1964,6 +2021,9 @@ instance (Show k, Show a) => Show (Map k a) where
   showsPrec d m  = showParen (d > 10) $
     showString "fromList " . shows (toList m)
 
+{-
+XXX unused code
+
 showMap :: (Show k,Show a) => [(k,a)] -> ShowS
 showMap []     
   = showString "{}" 
@@ -1971,10 +2031,10 @@ showMap (x:xs)
   = showChar '{' . showElem x . showTail xs
   where
     showTail []     = showChar '}'
-    showTail (x:xs) = showString ", " . showElem x . showTail xs
+    showTail (x':xs') = showString ", " . showElem x' . showTail xs'
     
-    showElem (k,x)  = shows k . showString " := " . shows x
-  
+    showElem (k,x')  = shows k . showString " := " . shows x'
+-}
 
 -- | /O(n)/. Show the tree that implements the map. The tree is shown
 -- in a compressed, hanging format. See 'showTreeWith'.
@@ -2030,9 +2090,9 @@ showsTree :: (k -> a -> String) -> Bool -> [String] -> [String] -> Map k a -> Sh
 showsTree showelem wide lbars rbars t
   = case t of
       Tip -> showsBars lbars . showString "|\n"
-      Bin sz kx x Tip Tip
+      Bin _ kx x Tip Tip
           -> showsBars lbars . showString (showelem kx x) . showString "\n" 
-      Bin sz kx x l r
+      Bin _ kx x l r
           -> showsTree showelem wide (withBar rbars) (withEmpty rbars) r .
              showWide wide rbars .
              showsBars lbars . showString (showelem kx x) . showString "\n" .
@@ -2043,16 +2103,16 @@ showsTreeHang :: (k -> a -> String) -> Bool -> [String] -> Map k a -> ShowS
 showsTreeHang showelem wide bars t
   = case t of
       Tip -> showsBars bars . showString "|\n" 
-      Bin sz kx x Tip Tip
+      Bin _ kx x Tip Tip
           -> showsBars bars . showString (showelem kx x) . showString "\n" 
-      Bin sz kx x l r
+      Bin _ kx x l r
           -> showsBars bars . showString (showelem kx x) . showString "\n" . 
              showWide wide bars .
              showsTreeHang showelem wide (withBar bars) l .
              showWide wide bars .
              showsTreeHang showelem wide (withEmpty bars) r
 
-
+showWide :: Bool -> [String] -> String -> String
 showWide wide bars 
   | wide      = showString (concat (reverse bars)) . showString "|\n" 
   | otherwise = id
@@ -2063,7 +2123,10 @@ showsBars bars
       [] -> id
       _  -> showString (concat (reverse (tail bars))) . showString node
 
+node :: String
 node           = "+--"
+
+withBar, withEmpty :: [String] -> [String]
 withBar bars   = "|  ":bars
 withEmpty bars = "   ":bars
 
@@ -2086,36 +2149,38 @@ valid :: Ord k => Map k a -> Bool
 valid t
   = balanced t && ordered t && validsize t
 
+ordered :: Ord a => Map a b -> Bool
 ordered t
   = bounded (const True) (const True) t
   where
-    bounded lo hi t
-      = case t of
+    bounded lo hi t'
+      = case t' of
           Tip              -> True
-          Bin sz kx x l r  -> (lo kx) && (hi kx) && bounded lo (<kx) l && bounded (>kx) hi r
+          Bin _ kx _ l r  -> (lo kx) && (hi kx) && bounded lo (<kx) l && bounded (>kx) hi r
 
 -- | Exported only for "Debug.QuickCheck"
 balanced :: Map k a -> Bool
 balanced t
   = case t of
-      Tip              -> True
-      Bin sz kx x l r  -> (size l + size r <= 1 || (size l <= delta*size r && size r <= delta*size l)) &&
-                          balanced l && balanced r
-
+      Tip            -> True
+      Bin _ _ _ l r  -> (size l + size r <= 1 || (size l <= delta*size r && size r <= delta*size l)) &&
+                        balanced l && balanced r
 
+validsize :: Map a b -> Bool
 validsize t
   = (realsize t == Just (size t))
   where
-    realsize t
-      = case t of
-          Tip             -> Just 0
-          Bin sz kx x l r -> case (realsize l,realsize r) of
-                              (Just n,Just m)  | n+m+1 == sz  -> Just sz
-                              other            -> Nothing
+    realsize t'
+      = case t' of
+          Tip            -> Just 0
+          Bin sz _ _ l r -> case (realsize l,realsize r) of
+                            (Just n,Just m)  | n+m+1 == sz  -> Just sz
+                            _                               -> Nothing
 
 {--------------------------------------------------------------------
   Utilities
 --------------------------------------------------------------------}
+foldlStrict :: (a -> b -> a) -> a -> [b] -> a
 foldlStrict f z xs
   = case xs of
       []     -> z
index 9b2047c..87332c4 100644 (file)
@@ -75,13 +75,11 @@ import Control.Monad (MonadPlus(..))
 import Data.Monoid (Monoid(..))
 import Data.Foldable
 import Data.Traversable
-import Data.Typeable
 
 #ifdef __GLASGOW_HASKELL__
 import Text.Read (Lexeme(Ident), lexP, parens, prec,
        readPrec, readListPrec, readListPrecDefault)
-import Data.Generics.Basics (Data(..), Fixity(..),
-                       constrIndex, mkConstr, mkDataType)
+import Data.Generics.Basics
 #endif
 
 #if TESTING
@@ -183,8 +181,11 @@ instance Data a => Data (Seq a) where
 
        dataCast1 f     = gcast1 f
 
+emptyConstr, consConstr :: Constr
 emptyConstr = mkConstr seqDataType "empty" [] Prefix
 consConstr  = mkConstr seqDataType "<|" [] Infix
+
+seqDataType :: DataType
 seqDataType = mkDataType "Data.Sequence.Seq" [emptyConstr, consConstr]
 #endif
 
@@ -267,12 +268,12 @@ instance Foldable Digit where
        foldl f z (Three a b c) = ((z `f` a) `f` b) `f` c
        foldl f z (Four a b c d) = (((z `f` a) `f` b) `f` c) `f` d
 
-       foldr1 f (One a) = a
+       foldr1 _ (One a) = a
        foldr1 f (Two a b) = a `f` b
        foldr1 f (Three a b c) = a `f` (b `f` c)
        foldr1 f (Four a b c d) = a `f` (b `f` (c `f` d))
 
-       foldl1 f (One a) = a
+       foldl1 _ (One a) = a
        foldl1 f (Two a b) = a `f` b
        foldl1 f (Three a b c) = (a `f` b) `f` c
        foldl1 f (Four a b c d) = ((a `f` b) `f` c) `f` d
@@ -691,13 +692,13 @@ instance Functor ViewL where
        fmap = fmapDefault
 
 instance Foldable ViewL where
-       foldr f z EmptyL = z
+       foldr _ z EmptyL = z
        foldr f z (x :< xs) = f x (foldr f z xs)
 
-       foldl f z EmptyL = z
+       foldl _ z EmptyL = z
        foldl f z (x :< xs) = foldl f (f z x) xs
 
-       foldl1 f EmptyL = error "foldl1: empty view"
+       foldl1 _ EmptyL = error "foldl1: empty view"
        foldl1 f (x :< xs) = foldl f x xs
 
 instance Traversable ViewL where
@@ -750,13 +751,13 @@ instance Functor ViewR where
        fmap = fmapDefault
 
 instance Foldable ViewR where
-       foldr f z EmptyR = z
+       foldr _ z EmptyR = z
        foldr f z (xs :> x) = foldr f (f x z) xs
 
-       foldl f z EmptyR = z
+       foldl _ z EmptyR = z
        foldl f z (xs :> x) = f (foldl f z xs) x
 
-       foldr1 f EmptyR = error "foldr1: empty view"
+       foldr1 _ EmptyR = error "foldr1: empty view"
        foldr1 f (xs :> x) = foldr f x xs
 
 instance Traversable ViewR where
index 6655a49..e6ace41 100644 (file)
@@ -103,7 +103,6 @@ module Data.Set  (
 import Prelude hiding (filter,foldr,null,map)
 import qualified Data.List as List
 import Data.Monoid (Monoid(..))
-import Data.Typeable
 import Data.Foldable (Foldable(foldMap))
 
 {-
@@ -116,7 +115,7 @@ import qualified List
 #if __GLASGOW_HASKELL__
 import Text.Read
 import Data.Generics.Basics
-import Data.Generics.Instances
+import Data.Generics.Instances ()
 #endif
 
 {--------------------------------------------------------------------
@@ -143,7 +142,7 @@ instance Ord a => Monoid (Set a) where
     mconcat = unions
 
 instance Foldable Set where
-    foldMap f Tip = mempty
+    foldMap _ Tip = mempty
     foldMap f (Bin _s k l r) = foldMap f l `mappend` f k `mappend` foldMap f r
 
 #if __GLASGOW_HASKELL__
@@ -171,22 +170,22 @@ instance (Data a, Ord a) => Data (Set a) where
 null :: Set a -> Bool
 null t
   = case t of
-      Tip           -> True
-      Bin sz x l r  -> False
+      Tip    -> True
+      Bin {} -> False
 
 -- | /O(1)/. The number of elements in the set.
 size :: Set a -> Int
 size t
   = case t of
-      Tip           -> 0
-      Bin sz x l r  -> sz
+      Tip          -> 0
+      Bin sz _ _ _ -> sz
 
 -- | /O(log n)/. Is the element in the set?
 member :: Ord a => a -> Set a -> Bool
 member x t
   = case t of
       Tip -> False
-      Bin sz y l r
+      Bin _ y l r
           -> case compare x y of
                LT -> member x l
                GT -> member x r
@@ -231,7 +230,7 @@ delete :: Ord a => a -> Set a -> Set a
 delete x t
   = case t of
       Tip -> Tip
-      Bin sz y l r 
+      Bin _ y l r
           -> case compare x y of
                LT -> balance y (delete x l) r
                GT -> balance y l (delete x r)
@@ -252,8 +251,9 @@ isSubsetOf :: Ord a => Set a -> Set a -> Bool
 isSubsetOf t1 t2
   = (size t1 <= size t2) && (isSubsetOfX t1 t2)
 
-isSubsetOfX Tip t = True
-isSubsetOfX t Tip = False
+isSubsetOfX :: Ord a => Set a -> Set a -> Bool
+isSubsetOfX Tip _ = True
+isSubsetOfX _ Tip = False
 isSubsetOfX (Bin _ x l r) t
   = found && isSubsetOfX l lt && isSubsetOfX r gt
   where
@@ -265,25 +265,25 @@ isSubsetOfX (Bin _ x l r) t
 --------------------------------------------------------------------}
 -- | /O(log n)/. The minimal element of a set.
 findMin :: Set a -> a
-findMin (Bin _ x Tip r) = x
-findMin (Bin _ x l r)   = findMin l
+findMin (Bin _ x Tip _) = x
+findMin (Bin _ _ l _)   = findMin l
 findMin Tip             = error "Set.findMin: empty set has no minimal element"
 
 -- | /O(log n)/. The maximal element of a set.
 findMax :: Set a -> a
-findMax (Bin _ x l Tip)  = x
-findMax (Bin _ x l r)    = findMax r
+findMax (Bin _ x _ Tip)  = x
+findMax (Bin _ _ _ r)    = findMax r
 findMax Tip              = error "Set.findMax: empty set has no maximal element"
 
 -- | /O(log n)/. Delete the minimal element.
 deleteMin :: Set a -> Set a
-deleteMin (Bin _ x Tip r) = r
+deleteMin (Bin _ _ Tip r) = r
 deleteMin (Bin _ x l r)   = balance x (deleteMin l) r
 deleteMin Tip             = Tip
 
 -- | /O(log n)/. Delete the maximal element.
 deleteMax :: Set a -> Set a
-deleteMax (Bin _ x l Tip) = l
+deleteMax (Bin _ _ l Tip) = l
 deleteMax (Bin _ x l r)   = balance x l (deleteMax r)
 deleteMax Tip             = Tip
 
@@ -306,7 +306,9 @@ union Tip t2  = t2
 union t1 Tip  = t1
 union t1 t2 = hedgeUnion (const LT) (const GT) t1 t2
 
-hedgeUnion cmplo cmphi t1 Tip 
+hedgeUnion :: Ord a
+           => (a -> Ordering) -> (a -> Ordering) -> Set a -> Set a -> Set a
+hedgeUnion _     _     t1 Tip
   = t1
 hedgeUnion cmplo cmphi Tip (Bin _ x l r)
   = join x (filterGt cmplo l) (filterLt cmphi r)
@@ -322,11 +324,13 @@ hedgeUnion cmplo cmphi (Bin _ x l r) t2
 -- | /O(n+m)/. Difference of two sets. 
 -- The implementation uses an efficient /hedge/ algorithm comparable with /hedge-union/.
 difference :: Ord a => Set a -> Set a -> Set a
-difference Tip t2  = Tip
+difference Tip   = Tip
 difference t1 Tip  = t1
 difference t1 t2   = hedgeDiff (const LT) (const GT) t1 t2
 
-hedgeDiff cmplo cmphi Tip t     
+hedgeDiff :: Ord a
+          => (a -> Ordering) -> (a -> Ordering) -> Set a -> Set a -> Set a
+hedgeDiff _ _ Tip _
   = Tip
 hedgeDiff cmplo cmphi (Bin _ x l r) Tip 
   = join x (filterGt cmplo l) (filterLt cmphi r)
@@ -351,8 +355,8 @@ hedgeDiff cmplo cmphi t (Bin _ x l r)
 --
 -- prints @(fromList [A],fromList [B])@.
 intersection :: Ord a => Set a -> Set a -> Set a
-intersection Tip t = Tip
-intersection t Tip = Tip
+intersection Tip _ = Tip
+intersection _ Tip = Tip
 intersection t1@(Bin s1 x1 l1 r1) t2@(Bin s2 x2 l2 r2) =
    if s1 >= s2 then
       let (lt,found,gt) = splitLookup x2 t1
@@ -372,7 +376,7 @@ intersection t1@(Bin s1 x1 l1 r1) t2@(Bin s2 x2 l2 r2) =
 --------------------------------------------------------------------}
 -- | /O(n)/. Filter all elements that satisfy the predicate.
 filter :: Ord a => (a -> Bool) -> Set a -> Set a
-filter p Tip = Tip
+filter _ Tip = Tip
 filter p (Bin _ x l r)
   | p x       = join x (filter p l) (filter p r)
   | otherwise = merge (filter p l) (filter p r)
@@ -381,7 +385,7 @@ filter p (Bin _ x l r)
 -- the predicate and one with all elements that don't satisfy the predicate.
 -- See also 'split'.
 partition :: Ord a => (a -> Bool) -> Set a -> (Set a,Set a)
-partition p Tip = (Tip,Tip)
+partition _ Tip = (Tip,Tip)
 partition p (Bin _ x l r)
   | p x       = (join x l1 r1,merge l2 r2)
   | otherwise = (merge l1 r1,join x l2 r2)
@@ -413,7 +417,7 @@ map f = fromList . List.map f . toList
 -- >     where ls = toList s
 
 mapMonotonic :: (a->b) -> Set a -> Set b
-mapMonotonic f Tip = Tip
+mapMonotonic _ Tip = Tip
 mapMonotonic f (Bin sz x l r) =
     Bin sz (f x) (mapMonotonic f l) (mapMonotonic f r)
 
@@ -428,7 +432,7 @@ fold f z s
 
 -- | /O(n)/. Post-order fold.
 foldr :: (a -> b -> b) -> b -> Set a -> b
-foldr f z Tip           = z
+foldr _ z Tip           = z
 foldr f z (Bin _ x l r) = foldr f (f x (foldr f z r)) l
 
 {--------------------------------------------------------------------
@@ -473,16 +477,16 @@ fromAscList xs
   = fromDistinctAscList (combineEq xs)
   where
   -- [combineEq xs] combines equal elements with [const] in an ordered list [xs]
-  combineEq xs
-    = case xs of
+  combineEq xs'
+    = case xs' of
         []     -> []
         [x]    -> [x]
         (x:xx) -> combineEq' x xx
 
   combineEq' z [] = [z]
-  combineEq' z (x:xs)
-    | z==x      = combineEq' z xs
-    | otherwise = z:combineEq' x xs
+  combineEq' z (x:xs')
+    | z==x      =   combineEq' z xs'
+    | otherwise = z:combineEq' x xs'
 
 
 -- | /O(n)/. Build a set from an ascending list of distinct elements in linear time.
@@ -493,16 +497,18 @@ fromDistinctAscList xs
   where
     -- 1) use continutations so that we use heap space instead of stack space.
     -- 2) special case for n==5 to build bushier trees. 
-    build c 0 xs   = c Tip xs 
-    build c 5 xs   = case xs of
+    build c 0 xs'  = c Tip xs'
+    build c 5 xs'  = case xs' of
                        (x1:x2:x3:x4:x5:xx) 
                             -> c (bin x4 (bin x2 (singleton x1) (singleton x3)) (singleton x5)) xx
-    build c n xs   = seq nr $ build (buildR nr c) nl xs
+                       _ -> error "fromDistinctAscList build 5"
+    build c n xs'  = seq nr $ build (buildR nr c) nl xs'
                    where
                      nl = n `div` 2
                      nr = n - nl - 1
 
     buildR n c l (x:ys) = build (buildB l x c) n ys
+    buildR _ _ _ []     = error "fromDistinctAscList buildR []"
     buildB l x c r zs   = c (bin x l r) zs
 
 {--------------------------------------------------------------------
@@ -527,14 +533,18 @@ instance Show a => Show (Set a) where
   showsPrec p xs = showParen (p > 10) $
     showString "fromList " . shows (toList xs)
 
+{-
+XXX unused code
+
 showSet :: (Show a) => [a] -> ShowS
 showSet []     
   = showString "{}" 
 showSet (x:xs) 
   = showChar '{' . shows x . showTail xs
   where
-    showTail []     = showChar '}'
-    showTail (x:xs) = showChar ',' . shows x . showTail xs
+    showTail []       = showChar '}'
+    showTail (x':xs') = showChar ',' . shows x' . showTail xs'
+-}
 
 {--------------------------------------------------------------------
   Read
@@ -584,40 +594,43 @@ INSTANCE_TYPEABLE1(Set,setTc,"Set")
   empty or the key of the root is between @lo@ and @hi@.
 --------------------------------------------------------------------}
 trim :: (a -> Ordering) -> (a -> Ordering) -> Set a -> Set a
-trim cmplo cmphi Tip = Tip
-trim cmplo cmphi t@(Bin sx x l r)
+trim _     _     Tip = Tip
+trim cmplo cmphi t@(Bin _ x l r)
   = case cmplo x of
       LT -> case cmphi x of
               GT -> t
-              le -> trim cmplo cmphi l
-      ge -> trim cmplo cmphi r
-              
+              _  -> trim cmplo cmphi l
+      _  -> trim cmplo cmphi r
+
+{-
+XXX unused code
+
 trimMemberLo :: Ord a => a -> (a -> Ordering) -> Set a -> (Bool, Set a)
-trimMemberLo lo cmphi Tip = (False,Tip)
-trimMemberLo lo cmphi t@(Bin sx x l r)
+trimMemberLo _  _     Tip = (False,Tip)
+trimMemberLo lo cmphi t@(Bin _ x l r)
   = case compare lo x of
       LT -> case cmphi x of
               GT -> (member lo t, t)
-              le -> trimMemberLo lo cmphi l
+               -> trimMemberLo lo cmphi l
       GT -> trimMemberLo lo cmphi r
       EQ -> (True,trim (compare lo) cmphi r)
-
+-}
 
 {--------------------------------------------------------------------
   [filterGt x t] filter all values >[x] from tree [t]
   [filterLt x t] filter all values <[x] from tree [t]
 --------------------------------------------------------------------}
 filterGt :: (a -> Ordering) -> Set a -> Set a
-filterGt cmp Tip = Tip
-filterGt cmp (Bin sx x l r)
+filterGt _ Tip = Tip
+filterGt cmp (Bin _ x l r)
   = case cmp x of
       LT -> join x (filterGt cmp l) r
       GT -> filterGt cmp r
       EQ -> r
       
 filterLt :: (a -> Ordering) -> Set a -> Set a
-filterLt cmp Tip = Tip
-filterLt cmp (Bin sx x l r)
+filterLt _ Tip = Tip
+filterLt cmp (Bin _ x l r)
   = case cmp x of
       LT -> filterLt cmp l
       GT -> join x l (filterLt cmp r)
@@ -631,8 +644,8 @@ filterLt cmp (Bin sx x l r)
 -- where all elements in @set1@ are lower than @x@ and all elements in
 -- @set2@ larger than @x@. @x@ is not found in neither @set1@ nor @set2@.
 split :: Ord a => a -> Set a -> (Set a,Set a)
-split x Tip = (Tip,Tip)
-split x (Bin sy y l r)
+split _ Tip = (Tip,Tip)
+split x (Bin _ y l r)
   = case compare x y of
       LT -> let (lt,gt) = split x l in (lt,join y gt r)
       GT -> let (lt,gt) = split x r in (join y l lt,gt)
@@ -647,8 +660,8 @@ splitMember x t = let (l,m,r) = splitLookup x t in
 -- | /O(log n)/. Performs a 'split' but also returns the pivot
 -- element that was found in the original set.
 splitLookup :: Ord a => a -> Set a -> (Set a,Maybe a,Set a)
-splitLookup x Tip = (Tip,Nothing,Tip)
-splitLookup x (Bin sy y l r)
+splitLookup _ Tip = (Tip,Nothing,Tip)
+splitLookup x (Bin _ y l r)
    = case compare x y of
        LT -> let (lt,found,gt) = splitLookup x l in (lt,found,join y gt r)
        GT -> let (lt,found,gt) = splitLookup x r in (join y l lt,found,gt)
@@ -700,13 +713,13 @@ insertMax,insertMin :: a -> Set a -> Set a
 insertMax x t
   = case t of
       Tip -> singleton x
-      Bin sz y l r
+      Bin _ y l r
           -> balance y l (insertMax x r)
              
 insertMin x t
   = case t of
       Tip -> singleton x
-      Bin sz y l r
+      Bin _ y l r
           -> balance y (insertMin x l) r
              
 {--------------------------------------------------------------------
@@ -827,20 +840,30 @@ balance x l r
     sizeX = sizeL + sizeR + 1
 
 -- rotate
+rotateL :: a -> Set a -> Set a -> Set a
 rotateL x l r@(Bin _ _ ly ry)
   | size ly < ratio*size ry = singleL x l r
   | otherwise               = doubleL x l r
+rotateL _ _ Tip = error "rotateL Tip"
 
+rotateR :: a -> Set a -> Set a -> Set a
 rotateR x l@(Bin _ _ ly ry) r
   | size ry < ratio*size ly = singleR x l r
   | otherwise               = doubleR x l r
+rotateR _ Tip _ = error "rotateL Tip"
 
 -- basic rotations
+singleL, singleR :: a -> Set a -> Set a -> Set a
 singleL x1 t1 (Bin _ x2 t2 t3)  = bin x2 (bin x1 t1 t2) t3
+singleL _  _  Tip               = error "singleL"
 singleR x1 (Bin _ x2 t1 t2) t3  = bin x2 t1 (bin x1 t2 t3)
+singleR _  Tip              _   = error "singleR"
 
+doubleL, doubleR :: a -> Set a -> Set a -> Set a
 doubleL x1 t1 (Bin _ x2 (Bin _ x3 t2 t3) t4) = bin x3 (bin x1 t1 t2) (bin x2 t3 t4)
+doubleL _ _ _ = error "doubleL"
 doubleR x1 (Bin _ x2 t1 (Bin _ x3 t2 t3)) t4 = bin x3 (bin x2 t1 t2) (bin x1 t3 t4)
+doubleR _ _ _ = error "doubleR"
 
 
 {--------------------------------------------------------------------
@@ -854,6 +877,7 @@ bin x l r
 {--------------------------------------------------------------------
   Utilities
 --------------------------------------------------------------------}
+foldlStrict :: (a -> b -> a) -> a -> [b] -> a
 foldlStrict f z xs
   = case xs of
       []     -> z
@@ -914,9 +938,9 @@ showsTree :: Show a => Bool -> [String] -> [String] -> Set a -> ShowS
 showsTree wide lbars rbars t
   = case t of
       Tip -> showsBars lbars . showString "|\n"
-      Bin sz x Tip Tip
+      Bin _ x Tip Tip
           -> showsBars lbars . shows x . showString "\n" 
-      Bin sz x l r
+      Bin _ x l r
           -> showsTree wide (withBar rbars) (withEmpty rbars) r .
              showWide wide rbars .
              showsBars lbars . shows x . showString "\n" .
@@ -927,16 +951,16 @@ showsTreeHang :: Show a => Bool -> [String] -> Set a -> ShowS
 showsTreeHang wide bars t
   = case t of
       Tip -> showsBars bars . showString "|\n" 
-      Bin sz x Tip Tip
+      Bin _ x Tip Tip
           -> showsBars bars . shows x . showString "\n" 
-      Bin sz x l r
+      Bin _ x l r
           -> showsBars bars . shows x . showString "\n" . 
              showWide wide bars .
              showsTreeHang wide (withBar bars) l .
              showWide wide bars .
              showsTreeHang wide (withEmpty bars) r
 
-
+showWide :: Bool -> [String] -> String -> String
 showWide wide bars 
   | wide      = showString (concat (reverse bars)) . showString "|\n" 
   | otherwise = id
@@ -947,7 +971,10 @@ showsBars bars
       [] -> id
       _  -> showString (concat (reverse (tail bars))) . showString node
 
+node :: String
 node           = "+--"
+
+withBar, withEmpty :: [String] -> [String]
 withBar bars   = "|  ":bars
 withEmpty bars = "   ":bars
 
@@ -959,31 +986,32 @@ valid :: Ord a => Set a -> Bool
 valid t
   = balanced t && ordered t && validsize t
 
+ordered :: Ord a => Set a -> Bool
 ordered t
   = bounded (const True) (const True) t
   where
-    bounded lo hi t
-      = case t of
-          Tip           -> True
-          Bin sz x l r  -> (lo x) && (hi x) && bounded lo (<x) l && bounded (>x) hi r
+    bounded lo hi t'
+      = case t' of
+          Tip         -> True
+          Bin _ x l r -> (lo x) && (hi x) && bounded lo (<x) l && bounded (>x) hi r
 
 balanced :: Set a -> Bool
 balanced t
   = case t of
-      Tip           -> True
-      Bin sz x l r  -> (size l + size r <= 1 || (size l <= delta*size r && size r <= delta*size l)) &&
-                       balanced l && balanced r
-
+      Tip         -> True
+      Bin _ _ l r -> (size l + size r <= 1 || (size l <= delta*size r && size r <= delta*size l)) &&
+                     balanced l && balanced r
 
+validsize :: Set a -> Bool
 validsize t
   = (realsize t == Just (size t))
   where
-    realsize t
-      = case t of
+    realsize t'
+      = case t' of
           Tip          -> Just 0
-          Bin sz x l r -> case (realsize l,realsize r) of
+          Bin sz _ l r -> case (realsize l,realsize r) of
                             (Just n,Just m)  | n+m+1 == sz  -> Just sz
-                            other            -> Nothing
+                            _                -> Nothing
 
 {-
 {--------------------------------------------------------------------
index 428f4be..8903368 100644 (file)
@@ -39,7 +39,7 @@ import Data.Typeable
 
 #ifdef __GLASGOW_HASKELL__
 import Data.Generics.Basics (Data)
-import Data.Generics.Instances
+import Data.Generics.Instances ()
 #endif
 
 -- | Multi-way trees, also known as /rose trees/.
@@ -155,9 +155,9 @@ unfoldForestM_BF f = liftM toList . unfoldForestQ f . fromList
 unfoldForestQ :: Monad m => (b -> m (a, [b])) -> Seq b -> m (Seq (Tree a))
 unfoldForestQ f aQ = case viewl aQ of
        EmptyL -> return empty
-       a :< aQ -> do
+       a :< aQ' -> do
                (b, as) <- f a
-               tQ <- unfoldForestQ f (Prelude.foldl (|>) aQ as)
+               tQ <- unfoldForestQ f (Prelude.foldl (|>) aQ' as)
                let (tQ', ts) = splitOnto [] as tQ
                return (Node b ts <| tQ')
   where splitOnto :: [a'] -> [b'] -> Seq a' -> (Seq a', [a'])
index 5e22e03..649d6f3 100644 (file)
@@ -15,6 +15,7 @@
 #define TYPEABLE_H
 
 #define INSTANCE_TYPEABLE0(tycon,tcname,str) \
+tcname :: TyCon; \
 tcname = mkTyCon str; \
 instance Typeable tycon where { typeOf _ = mkTyConApp tcname [] }
 
@@ -24,14 +25,17 @@ instance Typeable tycon where { typeOf _ = mkTyConApp tcname [] }
 --  // defined in Data.Typeable.
 
 #define INSTANCE_TYPEABLE1(tycon,tcname,str) \
+tcname :: TyCon; \
 tcname = mkTyCon str; \
 instance Typeable1 tycon where { typeOf1 _ = mkTyConApp tcname [] }
 
 #define INSTANCE_TYPEABLE2(tycon,tcname,str) \
+tcname :: TyCon; \
 tcname = mkTyCon str; \
 instance Typeable2 tycon where { typeOf2 _ = mkTyConApp tcname [] }
 
 #define INSTANCE_TYPEABLE3(tycon,tcname,str) \
+tcname :: TyCon; \
 tcname = mkTyCon str; \
 instance Typeable3 tycon where { typeOf3 _ = mkTyConApp tcname [] }