Rename 'HashMapW' to 'HashMap'

This commit also updates the 'HashMap' Haddock comment, and reenables
the correct 'Show' instance for 'HashMap', removing the 'deriving' one.

Author: rockbmb

Data/HashMap/Base.hs

@@ -27,7 +27,7 @@ module Data.HashMap.Lazy
       -- * Strictness properties
       -- $strictness
 
-      HashMapW
+      HashMap
 
       -- * Construction
     , empty

Data/HashMap/Lazy.hs

@@ -29,7 +29,7 @@ module Data.HashMap.Strict
       -- * Strictness properties
       -- $strictness
 
-      HashMapW
+      HashMap
 
       -- * Construction
     , empty
@@ -117,7 +117,7 @@ import Data.HashMap.Unsafe (runST)
 -- * Construction
 
 -- | /O(1)/ Construct a map with a single element.
-singleton :: (Hashable k) => k -> v -> HashMapW k v
+singleton :: (Hashable k) => k -> v -> HashMap k v
 singleton k !v = HM.singleton k v
 
 ------------------------------------------------------------------------
@@ -126,7 +126,7 @@ singleton k !v = HM.singleton k v
 -- | /O(log n)/ Associate the specified value with the specified
 -- key in this map.  If this map previously contained a mapping for
 -- the key, the old value is replaced.
-insert :: (Eq k, Hashable k) => k -> v -> HashMapW k v -> HashMapW k v
+insert :: (Eq k, Hashable k) => k -> v -> HashMap k v -> HashMap k v
 insert k !v = HM.insert k v
 {-# INLINABLE insert #-}
 
@@ -137,11 +137,11 @@ insert k !v = HM.insert k v
 --
 -- > insertWith f k v map
 -- >   where f new old = new + old
-insertWith :: (Eq k, Hashable k) => (v -> v -> v) -> k -> v -> HashMapW k v
-            -> HashMapW k v
-insertWith f k0 v0 (HashMapW sz m0) =
+insertWith :: (Eq k, Hashable k) => (v -> v -> v) -> k -> v -> HashMap k v
+            -> HashMap k v
+insertWith f k0 v0 (HashMap sz m0) =
     let (diff, m0') = insertWithInternal f k0 v0 m0
-    in HashMapW (diff + sz) m0'
+    in HashMap (diff + sz) m0'
 {-# INLINABLE insertWith #-}
 
 -- | /O(log n)/ Associate the value with the key in this map.  If
@@ -193,11 +193,11 @@ insertWithInternal f k0 v0 m0 = go h0 k0 v0 0 m0
 
 -- | In-place update version of insertWith
 unsafeInsertWith :: forall k v . (Eq k, Hashable k)
-                 => (v -> v -> v) -> k -> v -> HashMapW k v
-                 -> HashMapW k v
-unsafeInsertWith f k0 v0 (HashMapW sz m0) =
+                 => (v -> v -> v) -> k -> v -> HashMap k v
+                 -> HashMap k v
+unsafeInsertWith f k0 v0 (HashMap sz m0) =
     let (diff, m0') = unsafeInsertWithInternal f k0 v0 m0
-    in HashMapW (diff + sz) m0'
+    in HashMap (diff + sz) m0'
 {-# INLINABLE unsafeInsertWith #-}
 
 -- | In-place update version of insertWith
@@ -247,8 +247,8 @@ unsafeInsertWithInternal f k0 v0 m0 = runST (go h0 k0 v0 0 m0)
 
 -- | /O(log n)/ Adjust the value tied to a given key in this map only
 -- if it is present. Otherwise, leave the map alone.
-adjust :: (Eq k, Hashable k) => (v -> v) -> k -> HashMapW k v -> HashMapW k v
-adjust f k0 (HashMapW sz m0) = HashMapW sz (go h0 k0 0 m0)
+adjust :: (Eq k, Hashable k) => (v -> v) -> k -> HashMap k v -> HashMap k v
+adjust f k0 (HashMap sz m0) = HashMap sz (go h0 k0 0 m0)
   where
     h0 = hash k0
     go !_ !_ !_ Empty = Empty
@@ -277,7 +277,7 @@ adjust f k0 (HashMapW sz m0) = HashMapW sz (go h0 k0 0 m0)
 -- | /O(log n)/  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 deleted.
 -- If it is (@'Just' y), the key k is bound to the new value y.
-update :: (Eq k, Hashable k) => (a -> Maybe a) -> k -> HashMapW k a -> HashMapW k a
+update :: (Eq k, Hashable k) => (a -> Maybe a) -> k -> HashMap k a -> HashMap k a
 update f = alter (>>= f)
 {-# INLINABLE update #-}
 
@@ -288,8 +288,8 @@ alter
     :: (Eq k, Hashable k)
     => (Maybe v -> Maybe v)
     -> k
-    -> HashMapW k v
-    -> HashMapW k v
+    -> HashMap k v
+    -> HashMap k v
 alter f k m =
   case f (HM.lookup k m) of
     Nothing -> delete k m
@@ -301,8 +301,8 @@ alter f k m =
 
 -- | /O(n+m)/ The union of two maps.  If a key occurs in both maps,
 -- the provided function (first argument) will be used to compute the result.
-unionWith :: (Eq k, Hashable k) => (v -> v -> v) -> HashMapW k v -> HashMapW k v
-          -> HashMapW k v
+unionWith :: (Eq k, Hashable k) => (v -> v -> v) -> HashMap k v -> HashMap k v
+          -> HashMap k v
 unionWith f = unionWithKey (const f)
 {-# INLINE unionWith #-}
 
@@ -312,12 +312,12 @@ unionWith f = unionWithKey (const f)
 unionWithKey
     :: (Eq k, Hashable k)
     => (k -> v -> v -> v)
-    -> HashMapW k v
-    -> HashMapW k v
-    -> HashMapW k v
-unionWithKey f (HashMapW sz m) hw =
+    -> HashMap k v
+    -> HashMap k v
+    -> HashMap k v
+unionWithKey f (HashMap sz m) hw =
     let (diff, m') = unionWithKeyInternal f m hw
-    in HashMapW (diff + sz) m'
+    in HashMap (diff + sz) m'
 {-# INLINE unionWithKey #-}
 
 -- | /O(n+m)/ The union of two maps.  If a key occurs in both maps,
@@ -326,9 +326,9 @@ unionWithKeyInternal
     :: (Eq k, Hashable k)
     => (k -> v -> v -> v)
     -> HashMapInner k v
-    -> HashMapW k v
+    -> HashMap k v
     -> (Int, HashMapInner k v)
-unionWithKeyInternal f hm1 (HashMapW siz hm2) = go 0 siz hm1 hm2
+unionWithKeyInternal f hm1 (HashMap siz hm2) = go 0 siz hm1 hm2
   where
     -- empty vs. anything
     go !_ !sz t1 Empty = (sz, t1)
@@ -454,8 +454,8 @@ unionWithKeyInternal f hm1 (HashMapW siz hm2) = go 0 siz hm1 hm2
 -- * Transformations
 
 -- | /O(n)/ Transform this map by applying a function to every value.
-mapWithKey :: (k -> v1 -> v2) -> HashMapW k v1 -> HashMapW k v2
-mapWithKey f (HashMapW sz m) = HashMapW sz (go m)
+mapWithKey :: (k -> v1 -> v2) -> HashMap k v1 -> HashMap k v2
+mapWithKey f (HashMap sz m) = HashMap sz (go m)
   where
     go Empty                 = Empty
     go (Leaf h (L k v))      = leaf h k (f k v)
@@ -466,7 +466,7 @@ mapWithKey f (HashMapW sz m) = HashMapW sz (go m)
 {-# INLINE mapWithKey #-}
 
 -- | /O(n)/ Transform this map by applying a function to every value.
-map :: (v1 -> v2) -> HashMapW k v1 -> HashMapW k v2
+map :: (v1 -> v2) -> HashMap k v1 -> HashMap k v2
 map f = mapWithKey (const f)
 {-# INLINE map #-}
 
@@ -476,8 +476,8 @@ map f = mapWithKey (const f)
 
 -- | /O(n)/ Transform this map by applying a function to every value
 --   and retaining only some of them.
-mapMaybeWithKey :: (k -> v1 -> Maybe v2) -> HashMapW k v1 -> HashMapW k v2
-mapMaybeWithKey f (HashMapW _ m) = HashMapW size' m'
+mapMaybeWithKey :: (k -> v1 -> Maybe v2) -> HashMap k v1 -> HashMap k v2
+mapMaybeWithKey f (HashMap _ m) = HashMap size' m'
   where onLeaf (Leaf h (L k v)) | Just v' <- f k v = Just (leaf h k v')
         onLeaf _ = Nothing
 
@@ -489,7 +489,7 @@ mapMaybeWithKey f (HashMapW _ m) = HashMapW size' m'
 
 -- | /O(n)/ Transform this map by applying a function to every value
 --   and retaining only some of them.
-mapMaybe :: (v1 -> Maybe v2) -> HashMapW k v1 -> HashMapW k v2
+mapMaybe :: (v1 -> Maybe v2) -> HashMap k v1 -> HashMap k v2
 mapMaybe f = mapMaybeWithKey (const f)
 {-# INLINE mapMaybe #-}
 
@@ -506,9 +506,9 @@ mapMaybe f = mapMaybeWithKey (const f)
 differenceWith
     :: (Eq k, Hashable k)
     => (v -> w -> Maybe v)
-    -> HashMapW k v
-    -> HashMapW k w
-    -> HashMapW k v
+    -> HashMap k v
+    -> HashMap k w
+    -> HashMap k v
 differenceWith f a b = foldlWithKey' go empty a
   where
     go m k v = case HM.lookup k b of
@@ -519,8 +519,8 @@ differenceWith f a b = foldlWithKey' go empty a
 -- | /O(n+m)/ Intersection of two maps. If a key occurs in both maps
 -- the provided function is used to combine the values from the two
 -- maps.
-intersectionWith :: (Eq k, Hashable k) => (v1 -> v2 -> v3) -> HashMapW k v1
-                 -> HashMapW k v2 -> HashMapW k v3
+intersectionWith :: (Eq k, Hashable k) => (v1 -> v2 -> v3) -> HashMap k v1
+                 -> HashMap k v2 -> HashMap k v3
 intersectionWith f a b = foldlWithKey' go empty a
   where
     go m k v = case HM.lookup k b of
@@ -532,7 +532,7 @@ intersectionWith f a b = foldlWithKey' go empty a
 -- the provided function is used to combine the values from the two
 -- maps.
 intersectionWithKey :: (Eq k, Hashable k) => (k -> v1 -> v2 -> v3)
-                    -> HashMapW k v1 -> HashMapW k v2 -> HashMapW k v3
+                    -> HashMap k v1 -> HashMap k v2 -> HashMap k v3
 intersectionWithKey f a b = foldlWithKey' go empty a
   where
     go m k v = case HM.lookup k b of
@@ -546,7 +546,7 @@ intersectionWithKey f a b = foldlWithKey' go empty a
 -- | /O(n*log n)/ Construct a map with the supplied mappings.  If the
 -- list contains duplicate mappings, the later mappings take
 -- precedence.
-fromList :: (Eq k, Hashable k) => [(k, v)] -> HashMapW k v
+fromList :: (Eq k, Hashable k) => [(k, v)] -> HashMap k v
 fromList = L.foldl' (\ m (k, !v) -> HM.unsafeInsert k v m) empty
 {-# INLINABLE fromList #-}
 
@@ -563,7 +563,7 @@ fromList = L.foldl' (\ m (k, !v) -> HM.unsafeInsert k v m) empty
 --
 -- will group all values by their keys in a list 'xs :: [(k, v)]' and
 -- return a 'HashMap k [v]'.
-fromListWith :: (Eq k, Hashable k) => (v -> v -> v) -> [(k, v)] -> HashMapW k v
+fromListWith :: (Eq k, Hashable k) => (v -> v -> v) -> [(k, v)] -> HashMap k v
 fromListWith f = L.foldl' (\ m (k, v) -> unsafeInsertWith f k v m) empty
 {-# INLINE fromListWith #-}
 

Data/HashMap/Strict.hs

@@ -67,14 +67,14 @@ module Data.HashSet
     , toList
     , fromList
 
-    -- * HashMapWs
+    -- * HashMaps
     , toMap
     , fromMap
     ) where
 
 import Control.DeepSeq (NFData(..))
 import Data.Data hiding (Typeable)
-import Data.HashMap.Base (HashMapW, foldrWithKey, equalKeys)
+import Data.HashMap.Base (HashMap, foldrWithKey, equalKeys)
 import Data.Hashable (Hashable(hashWithSalt))
 #if __GLASGOW_HASKELL__ >= 711
 import Data.Semigroup (Semigroup(..), Monoid(..))
@@ -103,7 +103,7 @@ import qualified Data.Hashable.Lifted as H
 
 -- | A set of values.  A set cannot contain duplicate values.
 newtype HashSet a = HashSet {
-      asMap :: HashMapW a ()
+      asMap :: HashMap a ()
     } deriving (Typeable)
 
 #if __GLASGOW_HASKELL__ >= 708
@@ -202,12 +202,12 @@ singleton :: Hashable a => a -> HashSet a
 singleton a = HashSet (H.singleton a ())
 {-# INLINABLE singleton #-}
 
--- | /O(1)/ Convert to the equivalent 'HashMapW'.
-toMap :: HashSet a -> HashMapW a ()
+-- | /O(1)/ Convert to the equivalent 'HashMap'.
+toMap :: HashSet a -> HashMap a ()
 toMap = asMap
 
--- | /O(1)/ Convert from the equivalent 'HashMapW'.
-fromMap :: HashMapW a () -> HashSet a
+-- | /O(1)/ Convert from the equivalent 'HashMap'.
+fromMap :: HashMap a () -> HashSet a
 fromMap = HashSet
 
 -- | /O(n+m)/ Construct a set containing all elements from both sets.

Data/HashSet.hs

@@ -55,10 +55,10 @@ data Env = Env {
     elemsDupBS :: ![(BS.ByteString, Int)],
     elemsDupI  :: ![(Int, Int)],
 
-    hm    :: !(HM.HashMapW String Int),
-    hmbs  :: !(HM.HashMapW BS.ByteString Int),
-    hmi   :: !(HM.HashMapW Int Int),
-    hmi2  :: !(HM.HashMapW Int Int),
+    hm    :: !(HM.HashMap String Int),
+    hmbs  :: !(HM.HashMap BS.ByteString Int),
+    hmi   :: !(HM.HashMap Int Int),
+    hmi2  :: !(HM.HashMap Int Int),
     m     :: !(M.Map String Int),
     mbs   :: !(M.Map BS.ByteString Int),
     im    :: !(IM.IntMap Int),
@@ -195,7 +195,7 @@ main = do
           ]
 
         , env setupEnv $ \ ~(Env{..}) ->
-          bgroup "HashMapW"
+          bgroup "HashMap"
           [ -- * Basic interface
             bgroup "lookup"
             [ bench "String" $ whnf (lookup keys) hm
@@ -283,32 +283,32 @@ main = do
         ]
 
 ------------------------------------------------------------------------
--- * HashMapW
+-- * HashMap
 
-lookup :: (Eq k, Hashable k) => [k] -> HM.HashMapW k Int -> Int
+lookup :: (Eq k, Hashable k) => [k] -> HM.HashMap k Int -> Int
 lookup xs m = foldl' (\z k -> fromMaybe z (HM.lookup k m)) 0 xs
-{-# SPECIALIZE lookup :: [Int] -> HM.HashMapW Int Int -> Int #-}
-{-# SPECIALIZE lookup :: [String] -> HM.HashMapW String Int -> Int #-}
-{-# SPECIALIZE lookup :: [BS.ByteString] -> HM.HashMapW BS.ByteString Int
+{-# SPECIALIZE lookup :: [Int] -> HM.HashMap Int Int -> Int #-}
+{-# SPECIALIZE lookup :: [String] -> HM.HashMap String Int -> Int #-}
+{-# SPECIALIZE lookup :: [BS.ByteString] -> HM.HashMap BS.ByteString Int
                       -> Int #-}
 
-insert :: (Eq k, Hashable k) => [(k, Int)] -> HM.HashMapW k Int
-       -> HM.HashMapW k Int
+insert :: (Eq k, Hashable k) => [(k, Int)] -> HM.HashMap k Int
+       -> HM.HashMap k Int
 insert xs m0 = foldl' (\m (k, v) -> HM.insert k v m) m0 xs
-{-# SPECIALIZE insert :: [(Int, Int)] -> HM.HashMapW Int Int
-                      -> HM.HashMapW Int Int #-}
-{-# SPECIALIZE insert :: [(String, Int)] -> HM.HashMapW String Int
-                      -> HM.HashMapW String Int #-}
-{-# SPECIALIZE insert :: [(BS.ByteString, Int)] -> HM.HashMapW BS.ByteString Int
-                      -> HM.HashMapW BS.ByteString Int #-}
-
-delete :: (Eq k, Hashable k) => [k] -> HM.HashMapW k Int -> HM.HashMapW k Int
+{-# SPECIALIZE insert :: [(Int, Int)] -> HM.HashMap Int Int
+                      -> HM.HashMap Int Int #-}
+{-# SPECIALIZE insert :: [(String, Int)] -> HM.HashMap String Int
+                      -> HM.HashMap String Int #-}
+{-# SPECIALIZE insert :: [(BS.ByteString, Int)] -> HM.HashMap BS.ByteString Int
+                      -> HM.HashMap BS.ByteString Int #-}
+
+delete :: (Eq k, Hashable k) => [k] -> HM.HashMap k Int -> HM.HashMap k Int
 delete xs m0 = foldl' (\m k -> HM.delete k m) m0 xs
-{-# SPECIALIZE delete :: [Int] -> HM.HashMapW Int Int -> HM.HashMapW Int Int #-}
-{-# SPECIALIZE delete :: [String] -> HM.HashMapW String Int
-                      -> HM.HashMapW String Int #-}
-{-# SPECIALIZE delete :: [BS.ByteString] -> HM.HashMapW BS.ByteString Int
-                      -> HM.HashMapW BS.ByteString Int #-}
+{-# SPECIALIZE delete :: [Int] -> HM.HashMap Int Int -> HM.HashMap Int Int #-}
+{-# SPECIALIZE delete :: [String] -> HM.HashMap String Int
+                      -> HM.HashMap String Int #-}
+{-# SPECIALIZE delete :: [BS.ByteString] -> HM.HashMap BS.ByteString Int
+                      -> HM.HashMap BS.ByteString Int #-}
 
 ------------------------------------------------------------------------
 -- * Map

benchmarks/Benchmarks.hs

@@ -364,15 +364,15 @@ type Model k v = M.Map k v
 -- one operating on a 'Model'.
 eq :: (Eq a, Eq k, Hashable k, Ord k)
    => (Model k v -> a)        -- ^ Function that modifies a 'Model'
-   -> (HM.HashMapW k v -> a)  -- ^ Function that modified a 'HashMap' in the same
+   -> (HM.HashMap k v -> a)  -- ^ Function that modified a 'HashMap' in the same
                               -- way
    -> [(k, v)]                -- ^ Initial content of the 'HashMap' and 'Model'
    -> Bool                    -- ^ True if the functions are equivalent
 eq f g xs = g (HM.fromList xs) == f (M.fromList xs)
 
 eq_ :: (Eq k, Eq v, Hashable k, Ord k)
     => (Model k v -> Model k v)              -- ^ Function that modifies a 'Model'
-    -> (HM.HashMapW k v -> HM.HashMapW k v)  -- ^ Function that modified a
+    -> (HM.HashMap k v -> HM.HashMap k v)  -- ^ Function that modified a
                                              -- 'HashMap' in the same way
     -> [(k, v)]                              -- ^ Initial content of the 'HashMap'
                                              -- and 'Model'
@@ -392,5 +392,5 @@ main = defaultMain tests
 sortByKey :: Ord k => [(k, v)] -> [(k, v)]
 sortByKey = L.sortBy (compare `on` fst)
 
-toAscList :: Ord k => HM.HashMapW k v -> [(k, v)]
+toAscList :: Ord k => HM.HashMap k v -> [(k, v)]
 toAscList = L.sortBy (compare `on` fst) . HM.toList

tests/HashMapProperties.hs

@@ -68,7 +68,7 @@ propEqAfterDelete (Keys keys) =
       k      = head keys
   in  HM.delete k keyMap == mapFromKeys (delete k keys)
 
-mapFromKeys :: [Int] -> HM.HashMapW Int ()
+mapFromKeys :: [Int] -> HM.HashMap Int ()
 mapFromKeys keys = HM.fromList (zip keys (repeat ()))
 
 ------------------------------------------------------------------------