Rename 'HashMapInner' to 'Tree'

Author: rockbmb

Data/HashMap/Base.hs

@@ -8,7 +8,7 @@
 
 module Data.HashMap.Base
     (
-      HashMapInner(..)
+      Tree(..)
     , HashMap(..)
     , Leaf(..)
 
@@ -154,22 +154,22 @@ 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 HashMapInner k v
+data Tree k v
     = Empty
-    | BitmapIndexed !Bitmap !(A.Array (HashMapInner k v))
+    | BitmapIndexed !Bitmap !(A.Array (Tree k v))
     | Leaf !Hash !(Leaf k v)
-    | Full !(A.Array (HashMapInner k v))
+    | Full !(A.Array (Tree k v))
     | Collision !Hash !(A.Array (Leaf k v))
       deriving Typeable
 
-type role HashMapInner nominal representational
+type role Tree nominal representational
 
--- | A wrapper over 'HashMapInner'. The 'Int' field represent the hashmap's
+-- | A wrapper over 'Tree'. The 'Int' field represent the hashmap's
 -- size.
-data HashMap k v = HashMap {-# UNPACK #-} !Int !(HashMapInner k v)
+data HashMap k v = HashMap {-# UNPACK #-} !Int !(Tree k v)
   deriving Typeable
 
-instance (NFData k, NFData v) => NFData (HashMapInner k v) where
+instance (NFData k, NFData v) => NFData (Tree k v) where
     rnf Empty                 = ()
     rnf (BitmapIndexed _ ary) = rnf ary
     rnf (Leaf _ l)            = rnf l
@@ -350,7 +350,7 @@ equalKeys eq (HashMap s1 t1) (HashMap s2 t2)
 instance H.Hashable2 HashMap where
     liftHashWithSalt2 hk hv salt (HashMap _ hm) = go salt (toList' hm [])
       where
-        -- go :: Int -> [HashMapInner k v] -> Int
+        -- go :: Int -> [Tree k v] -> Int
         go s [] = s
         go s (Leaf _ l : tl)
           = s `hashLeafWithSalt` l `go` tl
@@ -377,7 +377,7 @@ instance (Hashable k) => H.Hashable1 (HashMap k) where
 instance (Hashable k, Hashable v) => Hashable (HashMap k v) where
     hashWithSalt salt (HashMap _ hm) = go salt (toList' hm [])
       where
-        go :: Int -> [HashMapInner k v] -> Int
+        go :: Int -> [Tree k v] -> Int
         go s [] = s
         go s (Leaf _ l : tl)
           = s `hashLeafWithSalt` l `go` tl
@@ -398,15 +398,15 @@ instance (Hashable k, Hashable v) => Hashable (HashMap 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' :: HashMapInner k v -> [HashMapInner k v] -> [HashMapInner k v]
+toList' :: Tree k v -> [Tree k v] -> [Tree 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 :: HashMapInner k v -> Bool
+isLeafOrCollision :: Tree k v -> Bool
 isLeafOrCollision (Leaf _ _)      = True
 isLeafOrCollision (Collision _ _) = True
 isLeafOrCollision _               = False
@@ -483,7 +483,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 -> HashMapInner k v
+collision :: Hash -> Leaf k v -> Leaf k v -> Tree k v
 collision h e1 e2 =
     let v = A.run $ do mary <- A.new 2 e1
                        A.write mary 1 e2
@@ -492,7 +492,7 @@ collision h e1 e2 =
 {-# INLINE collision #-}
 
 -- | Create a 'BitmapIndexed' or 'Full' node.
-bitmapIndexedOrFull :: Bitmap -> A.Array (HashMapInner k v) -> HashMapInner k v
+bitmapIndexedOrFull :: Bitmap -> A.Array (Tree k v) -> Tree k v
 bitmapIndexedOrFull b ary
     | b == fullNodeMask = Full ary
     | otherwise         = BitmapIndexed b ary
@@ -511,7 +511,7 @@ insert k0 v0 (HashMap 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 -> HashMapInner k v -> (Int, HashMapInner k v)
+insertInternal :: (Eq k, Hashable k) => k -> v -> Tree k v -> (Int, Tree k v)
 insertInternal k0 v0 m0 = go h0 k0 v0 0 m0
   where
     h0 = hash k0
@@ -560,7 +560,7 @@ unsafeInsert k0 v0 (HashMap 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 -> HashMapInner k v -> (Int, HashMapInner k v)
+unsafeInsertInternal :: (Eq k, Hashable k) => k -> v -> Tree k v -> (Int, Tree k v)
 unsafeInsertInternal k0 v0 m0 = runST (go h0 k0 v0 0 m0)
   where
     h0 = hash k0
@@ -599,7 +599,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 (HashMapInner k v)
+two :: Shift -> Hash -> k -> v -> Hash -> k -> v -> ST s (Tree k v)
 two = go
   where
     go s h1 k1 v1 h2 k2 v2
@@ -644,8 +644,8 @@ insertWith f k0 v0 (HashMap sz m0) =
 --
 -- > insertWithInternal f k v map
 -- >   where f new old = new + old
-insertWithInternal :: (Eq k, Hashable k) => (v -> v -> v) -> k -> v -> HashMapInner k v
-            -> (Int, HashMapInner k v)
+insertWithInternal :: (Eq k, Hashable k) => (v -> v -> v) -> k -> v -> Tree k v
+            -> (Int, Tree k v)
 insertWithInternal f k0 v0 m0 = go h0 k0 v0 0 m0
   where
     h0 = hash k0
@@ -692,12 +692,12 @@ unsafeInsertWith f k0 v0 (HashMap sz m0) =
 
 -- | In-place update version of insertWithInternal
 unsafeInsertWithInternal :: forall k v. (Eq k, Hashable k)
-                 => (v -> v -> v) -> k -> v -> HashMapInner k v
-                 -> (Int, HashMapInner k v)
+                 => (v -> v -> v) -> k -> v -> Tree k v
+                 -> (Int, Tree k v)
 unsafeInsertWithInternal f k0 v0 m0 = runST (go h0 k0 v0 0 m0)
   where
     h0 = hash k0
-    go :: Hash -> k -> v -> Shift -> HashMapInner k v -> ST s (Int, HashMapInner k v)
+    go :: Hash -> k -> v -> Shift -> Tree k v -> ST s (Int, Tree 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
@@ -743,7 +743,7 @@ delete k0 (HashMap 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 -> HashMapInner k v -> (Int, HashMapInner k v)
+deleteInternal :: (Eq k, Hashable k) => k -> Tree k v -> (Int, Tree k v)
 deleteInternal k0 m0 = go h0 k0 0 m0
   where
     h0 = hash k0
@@ -886,17 +886,17 @@ unionWithKey f (HashMap sz m) hw =
 unionWithKeyInternal
     :: forall k v . (Eq k, Hashable k)
     => (k -> v -> v -> v)
-    -> HashMapInner k v
+    -> Tree k v
     -> HashMap k v
-    -> (Int, HashMapInner k v)
+    -> (Int, Tree k v)
 unionWithKeyInternal f hm1 (HashMap siz hm2) = go 0 siz hm1 hm2
   where
     go :: Int                -- ^ Bitmask accumulator
        -> Int                -- ^ Size accumulator.
                              -- Counts down from the second hashmap's size.
-       -> HashMapInner k v
-       -> HashMapInner k v
-       -> (Int, HashMapInner k v)
+       -> Tree k v
+       -> Tree k v
+       -> (Int, Tree k v)
     -- empty vs. anything
     go !_ !sz t1 Empty = (sz, t1)
     go _ !sz Empty t2 = (sz, t2)
@@ -1110,7 +1110,7 @@ map f = mapWithKey (const f)
 {-# INLINE map #-}
 
 -- TODO: We should be able to use mutation to create the new
--- 'HashMapInner'.
+-- 'Tree'.
 
 -- | /O(n)/ Transform this map by accumulating an Applicative result
 -- from every value.
@@ -1284,10 +1284,10 @@ filterWithKey pred (HashMap _ m) = HashMap 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
-              . (HashMapInner k v1 -> Maybe (HashMapInner k v2))
+              . (Tree k v1 -> Maybe (Tree k v2))
              -> (Leaf k v1 -> Maybe (Leaf k v2))
-             -> HashMapInner k v1
-             -> (Int, HashMapInner k v2)
+             -> Tree k v1
+             -> (Int, Tree k v2)
 filterMapAuxInternal onLeaf onColl = go 0
   where
     go !sz Empty = (sz, Empty)
@@ -1304,9 +1304,9 @@ filterMapAuxInternal onLeaf onColl = go 0
             mary <- A.new_ n
             step ary0 mary b0 0 0 1 n sz
       where
-        step :: A.Array (HashMapInner k v1) -> A.MArray s (HashMapInner k v2)
+        step :: A.Array (Tree k v1) -> A.MArray s (Tree k v2)
              -> Bitmap -> Int -> Int -> Bitmap -> Int -> Int
-             -> ST s (Int, HashMapInner k v2)
+             -> ST s (Int, Tree k v2)
         step !ary !mary !b i !j !bi n !siz
             | i >= n = case j of
                 0 -> return (siz, Empty)
@@ -1336,7 +1336,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, HashMapInner k v2)
+             -> ST s (Int, Tree 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 (HashMap sz m0) =
 -- Example:
 -- > insertWith f k v map
 -- >   where f new old = new + old
-insertWithInternal :: (Eq k, Hashable k) => (v -> v -> v) -> k -> v -> HashMapInner k v
-           -> (Int, HashMapInner k v)
+insertWithInternal :: (Eq k, Hashable k) => (v -> v -> v) -> k -> v -> Tree k v
+           -> (Int, Tree 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
-    -> HashMapInner k v
-    -> (Int, HashMapInner k v)
+    -> Tree k v
+    -> (Int, Tree k v)
 unsafeInsertWithInternal f k0 v0 m0 = runST (go h0 k0 v0 0 m0)
   where
     h0 = hash k0
@@ -325,9 +325,9 @@ unionWithKey f (HashMap sz m) hw =
 unionWithKeyInternal
     :: (Eq k, Hashable k)
     => (k -> v -> v -> v)
-    -> HashMapInner k v
+    -> Tree k v
     -> HashMap k v
-    -> (Int, HashMapInner k v)
+    -> (Int, Tree k v)
 unionWithKeyInternal f hm1 (HashMap siz hm2) = go 0 siz hm1 hm2
   where
     -- empty vs. anything
@@ -620,6 +620,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 -> HashMapInner k v
+leaf :: Hash -> k -> v -> Tree 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.HashMapInner k v -> [Histogram]
+nodeHistogram :: HM.Tree k v -> [Histogram]
 nodeHistogram Empty = [mempty { empty = 1 }]
 nodeHistogram (Leaf {}) = [mempty { leaf = 1 }]
 nodeHistogram (BitmapIndexed _ ary) =