Rename 'HashMap' to 'HashMapInner'

Author: rockbmb

Data/HashMap/Base.hs

@@ -8,7 +8,7 @@
 
 module Data.HashMap.Base
     (
-      HashMap(..)
+      HashMapInner(..)
     , HashMapW(..)
     , Leaf(..)
 
@@ -154,21 +154,21 @@ instance (NFData k, NFData v) => NFData (Leaf k v) where
 
 -- | A map from keys to values.  A map cannot contain duplicate keys;
 -- each key can map to at most one value.
-data HashMap k v
+data HashMapInner k v
     = Empty
-    | BitmapIndexed !Bitmap !(A.Array (HashMap k v))
+    | BitmapIndexed !Bitmap !(A.Array (HashMapInner k v))
     | Leaf !Hash !(Leaf k v)
-    | Full !(A.Array (HashMap k v))
+    | Full !(A.Array (HashMapInner k v))
     | Collision !Hash !(A.Array (Leaf k v))
       deriving (Show, Typeable)
 
-type role HashMap nominal representational
+type role HashMapInner nominal representational
 
 -- | WIP. This will become the user-facing 'HashMap' after this PR is
 -- finalized.
-data HashMapW k v = HashMapW {-# UNPACK #-} !Int !(HashMap k v)
+data HashMapW k v = HashMapW {-# UNPACK #-} !Int !(HashMapInner k v)
 
-instance (NFData k, NFData v) => NFData (HashMap k v) where
+instance (NFData k, NFData v) => NFData (HashMapInner k v) where
     rnf Empty                 = ()
     rnf (BitmapIndexed _ ary) = rnf ary
     rnf (Leaf _ l)            = rnf l
@@ -254,7 +254,7 @@ instance Traversable (HashMapW k) where
     traverse f = traverseWithKey (const f)
 
 #if MIN_VERSION_base(4,9,0)
-instance Eq2 HashMap where
+instance Eq2 HashMapInner where
     liftEq2 = equal
 
 instance Eq k => Eq1 (HashMapW k) where
@@ -349,7 +349,7 @@ equalKeys eq (HashMapW s1 t1) (HashMapW s2 t2)
 instance H.Hashable2 HashMapW where
     liftHashWithSalt2 hk hv salt (HashMapW _ hm) = go salt (toList' hm [])
       where
-        -- go :: Int -> [HashMap k v] -> Int
+        -- go :: Int -> [HashMapInner k v] -> Int
         go s [] = s
         go s (Leaf _ l : tl)
           = s `hashLeafWithSalt` l `go` tl
@@ -376,7 +376,7 @@ instance (Hashable k) => H.Hashable1 (HashMapW k) where
 instance (Hashable k, Hashable v) => Hashable (HashMapW k v) where
     hashWithSalt salt (HashMapW _ hm) = go salt (toList' hm [])
       where
-        go :: Int -> [HashMap k v] -> Int
+        go :: Int -> [HashMapInner k v] -> Int
         go s [] = s
         go s (Leaf _ l : tl)
           = s `hashLeafWithSalt` l `go` tl
@@ -397,15 +397,15 @@ instance (Hashable k, Hashable v) => Hashable (HashMapW k v) where
         arrayHashesSorted s = L.sort . L.map (hashLeafWithSalt s) . A.toList
 
   -- Helper to get 'Leaf's and 'Collision's as a list.
-toList' :: HashMap k v -> [HashMap k v] -> [HashMap k v]
+toList' :: HashMapInner k v -> [HashMapInner k v] -> [HashMapInner k v]
 toList' (BitmapIndexed _ ary) a = A.foldr toList' a ary
 toList' (Full ary)            a = A.foldr toList' a ary
 toList' l@(Leaf _ _)          a = l : a
 toList' c@(Collision _ _)     a = c : a
 toList' Empty                 a = a
 
 -- Helper function to detect 'Leaf's and 'Collision's.
-isLeafOrCollision :: HashMap k v -> Bool
+isLeafOrCollision :: HashMapInner k v -> Bool
 isLeafOrCollision (Leaf _ _)      = True
 isLeafOrCollision (Collision _ _) = True
 isLeafOrCollision _               = False
@@ -482,7 +482,7 @@ lookupDefault def k t = case lookup k t of
 infixl 9 !
 
 -- | Create a 'Collision' value with two 'Leaf' values.
-collision :: Hash -> Leaf k v -> Leaf k v -> HashMap k v
+collision :: Hash -> Leaf k v -> Leaf k v -> HashMapInner k v
 collision h e1 e2 =
     let v = A.run $ do mary <- A.new 2 e1
                        A.write mary 1 e2
@@ -491,7 +491,7 @@ collision h e1 e2 =
 {-# INLINE collision #-}
 
 -- | Create a 'BitmapIndexed' or 'Full' node.
-bitmapIndexedOrFull :: Bitmap -> A.Array (HashMap k v) -> HashMap k v
+bitmapIndexedOrFull :: Bitmap -> A.Array (HashMapInner k v) -> HashMapInner k v
 bitmapIndexedOrFull b ary
     | b == fullNodeMask = Full ary
     | otherwise         = BitmapIndexed b ary
@@ -510,7 +510,7 @@ insert k0 v0 (HashMapW sz m0) =
 -- key in this map.  If this map previously contained a mapping for
 -- the key, the old value is replaced. Returns a tuple containing the
 -- hashmap's change in size, and the hashmap after the insertion.
-insertInternal :: (Eq k, Hashable k) => k -> v -> HashMap k v -> (Int, HashMap k v)
+insertInternal :: (Eq k, Hashable k) => k -> v -> HashMapInner k v -> (Int, HashMapInner k v)
 insertInternal k0 v0 m0 = go h0 k0 v0 0 m0
   where
     h0 = hash k0
@@ -559,7 +559,7 @@ unsafeInsert k0 v0 (HashMapW sz m0) =
 
 -- | In-place update version of insert. Returns a tuple with the
 -- HashMap's change in size and the hashmap itself.
-unsafeInsertInternal :: (Eq k, Hashable k) => k -> v -> HashMap k v -> (Int, HashMap k v)
+unsafeInsertInternal :: (Eq k, Hashable k) => k -> v -> HashMapInner k v -> (Int, HashMapInner k v)
 unsafeInsertInternal k0 v0 m0 = runST (go h0 k0 v0 0 m0)
   where
     h0 = hash k0
@@ -598,7 +598,7 @@ unsafeInsertInternal k0 v0 m0 = runST (go h0 k0 v0 0 m0)
 {-# INLINABLE unsafeInsertInternal #-}
 
 -- | Create a map from two key-value pairs which hashes don't collide.
-two :: Shift -> Hash -> k -> v -> Hash -> k -> v -> ST s (HashMap k v)
+two :: Shift -> Hash -> k -> v -> Hash -> k -> v -> ST s (HashMapInner k v)
 two = go
   where
     go s h1 k1 v1 h2 k2 v2
@@ -643,8 +643,8 @@ insertWith f k0 v0 (HashMapW sz m0) =
 --
 -- > insertWithInternal f k v map
 -- >   where f new old = new + old
-insertWithInternal :: (Eq k, Hashable k) => (v -> v -> v) -> k -> v -> HashMap k v
-            -> (Int, HashMap k v)
+insertWithInternal :: (Eq k, Hashable k) => (v -> v -> v) -> k -> v -> HashMapInner k v
+            -> (Int, HashMapInner k v)
 insertWithInternal f k0 v0 m0 = go h0 k0 v0 0 m0
   where
     h0 = hash k0
@@ -691,12 +691,12 @@ unsafeInsertWith f k0 v0 (HashMapW sz m0) =
 
 -- | In-place update version of insertWithInternal
 unsafeInsertWithInternal :: forall k v. (Eq k, Hashable k)
-                 => (v -> v -> v) -> k -> v -> HashMap k v
-                 -> (Int, HashMap k v)
+                 => (v -> v -> v) -> k -> v -> HashMapInner k v
+                 -> (Int, HashMapInner k v)
 unsafeInsertWithInternal f k0 v0 m0 = runST (go h0 k0 v0 0 m0)
   where
     h0 = hash k0
-    go :: Hash -> k -> v -> Shift -> HashMap k v -> ST s (Int, HashMap k v)
+    go :: Hash -> k -> v -> Shift -> HashMapInner k v -> ST s (Int, HashMapInner k v)
     go !h !k x !_ Empty = return $! (1, Leaf h (L k x))
     go h k x s (Leaf hy l@(L ky y))
         | hy == h = if ky == k
@@ -742,7 +742,7 @@ delete k0 (HashMapW sz m0) =
 -- | /O(log n)/ Remove the mapping for the specified key from this map
 -- if present. Returns a tuple with the hashmap's change in size and the
 -- hashmap after the deletion.
-deleteInternal :: (Eq k, Hashable k) => k -> HashMap k v -> (Int, HashMap k v)
+deleteInternal :: (Eq k, Hashable k) => k -> HashMapInner k v -> (Int, HashMapInner k v)
 deleteInternal k0 m0 = go h0 k0 0 m0
   where
     h0 = hash k0
@@ -885,17 +885,17 @@ unionWithKey f (HashMapW sz m) hw =
 unionWithKeyInternal
     :: forall k v . (Eq k, Hashable k)
     => (k -> v -> v -> v)
-    -> HashMap k v
+    -> HashMapInner k v
     -> HashMapW k v
-    -> (Int, HashMap k v)
+    -> (Int, HashMapInner k v)
 unionWithKeyInternal f hm1 (HashMapW siz hm2) = go 0 siz hm1 hm2
   where
     go :: Int                -- ^ Bitmask accumulator
        -> Int                -- ^ Size accumulator.
                              -- Counts down from the second hashmap's size.
-       -> HashMap k v
-       -> HashMap k v
-       -> (Int, HashMap k v)
+       -> HashMapInner k v
+       -> HashMapInner k v
+       -> (Int, HashMapInner k v)
     -- empty vs. anything
     go !_ !sz t1 Empty = (sz, t1)
     go _ !sz Empty t2 = (sz, t2)
@@ -1107,7 +1107,7 @@ map f = mapWithKey (const f)
 {-# INLINE map #-}
 
 -- TODO: We should be able to use mutation to create the new
--- 'HashMap'.
+-- 'HashMapInner'.
 
 -- | /O(n)/ Transform this map by accumulating an Applicative result
 -- from every value.
@@ -1281,10 +1281,10 @@ filterWithKey pred (HashMapW _ m) = HashMapW size' m'
 -- allowing the former and latter to reuse terms.
 -- Returns the result hashmap's size, and the hashmap itself.
 filterMapAuxInternal :: forall k v1 v2
-              . (HashMap k v1 -> Maybe (HashMap k v2))
+              . (HashMapInner k v1 -> Maybe (HashMapInner k v2))
              -> (Leaf k v1 -> Maybe (Leaf k v2))
-             -> HashMap k v1
-             -> (Int, HashMap k v2)
+             -> HashMapInner k v1
+             -> (Int, HashMapInner k v2)
 filterMapAuxInternal onLeaf onColl = go 0
   where
     go !sz Empty = (sz, Empty)
@@ -1301,9 +1301,9 @@ filterMapAuxInternal onLeaf onColl = go 0
             mary <- A.new_ n
             step ary0 mary b0 0 0 1 n sz
       where
-        step :: A.Array (HashMap k v1) -> A.MArray s (HashMap k v2)
+        step :: A.Array (HashMapInner k v1) -> A.MArray s (HashMapInner k v2)
              -> Bitmap -> Int -> Int -> Bitmap -> Int -> Int
-             -> ST s (Int, HashMap k v2)
+             -> ST s (Int, HashMapInner k v2)
         step !ary !mary !b i !j !bi n !siz
             | i >= n = case j of
                 0 -> return (siz, Empty)
@@ -1333,7 +1333,7 @@ filterMapAuxInternal onLeaf onColl = go 0
       where
         step :: A.Array (Leaf k v1) -> A.MArray s (Leaf k v2)
              -> Int -> Int -> Int -> Int
-             -> ST s (Int, HashMap k v2)
+             -> ST s (Int, HashMapInner k v2)
         step !ary !mary i !j n !sz
             | i >= n    = case j of
                 0 -> return (sz, Empty)

Data/HashMap/Strict.hs

@@ -154,8 +154,8 @@ insertWith f k0 v0 (HashMapW sz m0) =
 -- Example:
 -- > insertWith f k v map
 -- >   where f new old = new + old
-insertWithInternal :: (Eq k, Hashable k) => (v -> v -> v) -> k -> v -> HashMap k v
-           -> (Int, HashMap k v)
+insertWithInternal :: (Eq k, Hashable k) => (v -> v -> v) -> k -> v -> HashMapInner k v
+           -> (Int, HashMapInner k v)
 insertWithInternal f k0 v0 m0 = go h0 k0 v0 0 m0
   where
     h0 = hash k0
@@ -206,8 +206,8 @@ unsafeInsertWithInternal
     => (v -> v -> v)
     -> k
     -> v
-    -> HashMap k v
-    -> (Int, HashMap k v)
+    -> HashMapInner k v
+    -> (Int, HashMapInner k v)
 unsafeInsertWithInternal f k0 v0 m0 = runST (go h0 k0 v0 0 m0)
   where
     h0 = hash k0
@@ -325,9 +325,9 @@ unionWithKey f (HashMapW sz m) hw =
 unionWithKeyInternal
     :: (Eq k, Hashable k)
     => (k -> v -> v -> v)
-    -> HashMap k v
+    -> HashMapInner k v
     -> HashMapW k v
-    -> (Int, HashMap k v)
+    -> (Int, HashMapInner k v)
 unionWithKeyInternal f hm1 (HashMapW siz hm2) = go 0 siz hm1 hm2
   where
     -- empty vs. anything
@@ -618,6 +618,6 @@ updateOrSnocWithKey f k0 v0 ary0 = go k0 v0 ary0 0 (A.length ary0)
 -- These constructors make sure the value is in WHNF before it's
 -- inserted into the constructor.
 
-leaf :: Hash -> k -> v -> HashMap k v
+leaf :: Hash -> k -> v -> HashMapInner k v
 leaf h k !v = Leaf h (L k v)
 {-# INLINE leaf #-}

utils/Stats.hs

@@ -26,7 +26,7 @@ instance Monoid Histogram where
         }
 
 -- | Count the number of node types at each level
-nodeHistogram :: HM.HashMap k v -> [Histogram]
+nodeHistogram :: HM.HashMapInner k v -> [Histogram]
 nodeHistogram Empty = [mempty { empty = 1 }]
 nodeHistogram (Leaf {}) = [mempty { leaf = 1 }]
 nodeHistogram (BitmapIndexed _ ary) =