Enable more warnings

Thanks Mikolaj!

2 files changed, 15 insertions, 15 deletions

diff --git a/dependent-enummap.cabal b/dependent-enummap.cabal
index 0c64b58..7ba65b6 100644
--- a/dependent-enummap.cabal
+++ b/dependent-enummap.cabal
@@ -27,7 +27,8 @@ library
     some >= 1 && < 2,
   hs-source-dirs: src
   default-language: Haskell2010
-  ghc-options: -Wall
+  ghc-options: -Wall -Wcompat -Widentities -Wredundant-constraints -Wunused-packages
+
 
 test-suite test
   type: exitcode-stdio-1.0
diff --git a/src/Data/Dependent/EnumMap/Strict/Internal.hs b/src/Data/Dependent/EnumMap/Strict/Internal.hs
index ddbbe9b..f797147 100644
--- a/src/Data/Dependent/EnumMap/Strict/Internal.hs
+++ b/src/Data/Dependent/EnumMap/Strict/Internal.hs
@@ -261,8 +261,7 @@ member k (DEnumMap m) = IM.member (fst (fromEnum1 k)) m
 notMember :: Enum1 k => k a -> DEnumMap k v -> Bool
 notMember k m = not $ member k m
 
-lookupLT, lookupGT, lookupLE, lookupGE
-  :: (Enum1 k, TestEquality k) => k a -> DEnumMap k v -> Maybe (DSum k v)
+lookupLT, lookupGT, lookupLE, lookupGE :: Enum1 k => k a -> DEnumMap k v -> Maybe (DSum k v)
 lookupLT k (DEnumMap m) = let (i, _) = fromEnum1 k in kVToDSum <$> IM.lookupLT i m
 lookupGT k (DEnumMap m) = let (i, _) = fromEnum1 k in kVToDSum <$> IM.lookupGT i m
 lookupLE k (DEnumMap m) = let (i, _) = fromEnum1 k in kVToDSum <$> IM.lookupLE i m
@@ -386,7 +385,7 @@ disjoint (DEnumMap m1) (DEnumMap m2) = IM.disjoint m1 m2
 
 -- ** Compose
 
-compose :: (Enum1 k1, Enum1 k2, TestEquality k2) => DEnumMap k2 v -> DEnumMap k1 k2 -> DEnumMap k1 v
+compose :: (Enum1 k2, TestEquality k2) => DEnumMap k2 v -> DEnumMap k1 k2 -> DEnumMap k1 v
 compose m2v (DEnumMap m12) =
   DEnumMap (IM.mapMaybe (\(KV inf1 k2) -> KV inf1 <$> m2v !? k2) m12)
 
@@ -407,31 +406,31 @@ mergeWithKey f g1 g2 (DEnumMap m1) (DEnumMap m2) =
 -- * Traversal
 -- ** Map
 
-map :: (Enum1 k, TestEquality k) => (forall a. v1 a -> v2 a) -> DEnumMap k v1 -> DEnumMap k v2
+map :: Enum1 k => (forall a. v1 a -> v2 a) -> DEnumMap k v1 -> DEnumMap k v2
 map f = mapWithKey (const f)
 
-mapWithKey :: (Enum1 k, TestEquality k) => (forall a. k a -> v1 a -> v2 a) -> DEnumMap k v1 -> DEnumMap k v2
+mapWithKey :: Enum1 k => (forall a. k a -> v1 a -> v2 a) -> DEnumMap k v1 -> DEnumMap k v2
 mapWithKey f (DEnumMap m) =
   DEnumMap (IM.mapWithKey (\i (KV inf v) -> case toEnum1 i inf of Some k -> KV inf $ f k (coe1 v)) m)
 
-traverseWithKey :: (Applicative f, Enum1 k, TestEquality k)
+traverseWithKey :: (Applicative f, Enum1 k)
                 => (forall a. k a -> v1 a -> f (v2 a)) -> DEnumMap k v1 -> f (DEnumMap k v2)
 traverseWithKey f (DEnumMap m) =
   DEnumMap <$> IM.traverseWithKey (\i (KV inf v) -> case toEnum1 i inf of Some k -> KV inf <$> f k (coe1 v)) m
 
-traverseMaybeWithKey :: (Applicative f, Enum1 k, TestEquality k)
+traverseMaybeWithKey :: (Applicative f, Enum1 k)
                      => (forall a. k a -> v1 a -> f (Maybe (v2 a))) -> DEnumMap k v1 -> f (DEnumMap k v2)
 traverseMaybeWithKey f (DEnumMap m) =
   DEnumMap <$> IM.traverseMaybeWithKey (\i (KV inf v) -> case toEnum1 i inf of Some k -> fmap (KV inf) <$> f k (coe1 v)) m
 
-mapAccum :: (Enum1 k, TestEquality k) => (forall a. acc -> v1 a -> (acc, v2 a)) -> acc -> DEnumMap k v1 -> (acc, DEnumMap k v2)
+mapAccum :: Enum1 k => (forall a. acc -> v1 a -> (acc, v2 a)) -> acc -> DEnumMap k v1 -> (acc, DEnumMap k v2)
 mapAccum f = mapAccumWithKey (\x _ y -> f x y)
 
-mapAccumWithKey :: (Enum1 k, TestEquality k) => (forall a. acc -> k a -> v1 a -> (acc, v2 a)) -> acc -> DEnumMap k v1 -> (acc, DEnumMap k v2)
+mapAccumWithKey :: Enum1 k => (forall a. acc -> k a -> v1 a -> (acc, v2 a)) -> acc -> DEnumMap k v1 -> (acc, DEnumMap k v2)
 mapAccumWithKey f acc0 (DEnumMap m) =
   second DEnumMap $ IM.mapAccumWithKey (\acc i (KV inf v) -> case toEnum1 i inf of Some k -> second (KV inf) $ f acc k (coe1 v)) acc0 m
 
-mapAccumRWithKey :: (Enum1 k, TestEquality k) => (forall a. acc -> k a -> v1 a -> (acc, v2 a)) -> acc -> DEnumMap k v1 -> (acc, DEnumMap k v2)
+mapAccumRWithKey :: Enum1 k => (forall a. acc -> k a -> v1 a -> (acc, v2 a)) -> acc -> DEnumMap k v1 -> (acc, DEnumMap k v2)
 mapAccumRWithKey f acc0 (DEnumMap m) =
   second DEnumMap $ IM.mapAccumRWithKey (\acc i (KV inf v) -> case toEnum1 i inf of Some k -> second (KV inf) $ f acc k (coe1 v)) acc0 m
 
@@ -542,19 +541,19 @@ spanAntitone :: Enum1 k => (forall a. k a -> Bool) -> DEnumMap k v -> (DEnumMap
 spanAntitone f (DEnumMap m) =
   bimap DEnumMap DEnumMap (IM.spanAntitone (\i -> case m IM.! i of KV inf _ -> case toEnum1 i inf of Some k -> f k) m)
 
-mapMaybe :: (Enum1 k, TestEquality k) => (forall a. v1 a -> Maybe (v2 a)) -> DEnumMap k v1 -> DEnumMap k v2
+mapMaybe :: Enum1 k => (forall a. v1 a -> Maybe (v2 a)) -> DEnumMap k v1 -> DEnumMap k v2
 mapMaybe f = mapMaybeWithKey (const f)
 
-mapMaybeWithKey :: (Enum1 k, TestEquality k)
+mapMaybeWithKey :: Enum1 k
                 => (forall a. k a -> v1 a -> Maybe (v2 a)) -> DEnumMap k v1 -> DEnumMap k v2
 mapMaybeWithKey f (DEnumMap m) =
   DEnumMap (IM.mapMaybeWithKey (\i (KV inf v) -> case toEnum1 i inf of Some k -> KV inf <$> f k (coe1 v)) m)
 
-mapEither :: (Enum1 k, TestEquality k)
+mapEither :: Enum1 k
           => (forall a. v1 a -> Either (v2 a) (v3 a)) -> DEnumMap k v1 -> (DEnumMap k v2, DEnumMap k v3)
 mapEither f = mapEitherWithKey (const f)
 
-mapEitherWithKey :: (Enum1 k, TestEquality k)
+mapEitherWithKey :: Enum1 k
                  => (forall a. k a -> v1 a -> Either (v2 a) (v3 a)) -> DEnumMap k v1 -> (DEnumMap k v2, DEnumMap k v3)
 mapEitherWithKey f (DEnumMap m) =
   bimap DEnumMap DEnumMap (IM.mapEitherWithKey (\i (KV inf v) -> case toEnum1 i inf of Some k -> bimap (KV inf) (KV inf) $ f k (coe1 v)) m)