Add size aware intersection and difference functions

This commit adds versions of 'intersection, intersectionWith,
intersectionWithKey, difference, differenceWith' that track size to
be used later in this PR.

Author: rockbmb

Data/HashMap/Base.hs

@@ -1213,6 +1213,21 @@ difference a b = foldlWithKey' go empty a
                  _       -> m
 {-# INLINABLE difference #-}
 
+-- | /O(n*log m)/ Difference of two maps. Return elements of the first map
+-- not existing in the second. Returns a tuple with the size of the resulting
+-- hashmap, and the hashmap itself.
+differenceInternal
+    :: (Eq k, Hashable k)
+    => HashMap k v
+    -> HashMap k w
+    -> (Int, HashMap k v)
+differenceInternal a b = foldlWithKey' go (0, empty) a
+  where
+    go p@(sz, m) k v = case lookup k b of
+                 Nothing -> let (s, m') = insertInternal k v m in (sz + s, m')
+                 _       -> p
+{-# INLINABLE differenceInternal #-}
+
 -- | /O(n*log m)/ Difference with a combining function. When two equal keys are
 -- encountered, the combining function is applied to the values of these keys.
 -- If it returns 'Nothing', the element is discarded (proper set difference). If
@@ -1225,6 +1240,27 @@ differenceWith f a b = foldlWithKey' go empty a
                  Just w  -> maybe m (\y -> insert k y m) (f v w)
 {-# INLINABLE differenceWith #-}
 
+-- | /O(n*log m)/ Difference with a combining function. When two equal keys are
+-- encountered, the combining function is applied to the values of these keys.
+-- If it returns 'Nothing', the element is discarded (proper set difference). If
+-- it returns (@'Just' y@), the element is updated with a new value @y@.
+-- Returns a tuple with the size of the resulting hashmap, and the hashmap
+-- itself.
+differenceWithInternal
+    :: (Eq k, Hashable k)
+    => (v -> w -> Maybe v)
+    -> HashMap k v
+    -> HashMap k w
+    -> (Int, HashMap k v)
+differenceWithInternal f a b = foldlWithKey' go (0, empty) a
+  where
+    go p@(sz, m) k v = case lookup k b of
+                 Nothing -> let (s, m') = insertInternal k v m in (sz + s, m')
+                 Just w  -> maybe p (\y -> let (s, m') = insertInternal k y m
+                                           in (sz + s, m'))
+                                    (f v w)
+{-# INLINABLE differenceWithInternal #-}
+
 -- | /O(n*log m)/ Intersection of two maps. Return elements of the first
 -- map for keys existing in the second.
 intersection :: (Eq k, Hashable k) => HashMap k v -> HashMap k w -> HashMap k v
@@ -1235,6 +1271,22 @@ intersection a b = foldlWithKey' go empty a
                  _      -> m
 {-# INLINABLE intersection #-}
 
+-- | /O(n*log m)/ Intersection of two maps. Return elements of the first
+-- map for keys existing in the second.
+--- The result is a tuple with the size of the resulting hashmap, and the
+-- hashmap itself.
+insersectionInternal
+    :: (Eq k, Hashable k)
+    => HashMap k v
+    -> HashMap k w
+    -> (Int, HashMap k v)
+insersectionInternal a b = foldlWithKey' go (0, empty) a
+  where
+    go p@(sz, m) k v = case lookup k b of
+                 Just _ -> let (s, m') = insertInternal k v m in (sz + s, m')
+                 _      -> p
+{-# INLINABLE insersectionInternal #-}
+
 -- | /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.
@@ -1247,6 +1299,20 @@ intersectionWith f a b = foldlWithKey' go empty a
                  _      -> m
 {-# INLINABLE intersectionWith #-}
 
+-- | /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.
+-- The result is a tuple with the size of the resulting hashmap, and the
+-- hashmap itself.
+insersectionWithInternal :: (Eq k, Hashable k) => (v1 -> v2 -> v3) -> HashMap k v1
+                         -> HashMap k v2 -> (Int, HashMap k v3)
+insersectionWithInternal f a b = foldlWithKey' go (0, empty) a
+  where
+    go p@(sz, m) k v = case lookup k b of
+                 Just w -> let (s, m') = insertInternal k (f v w) m in (sz + s, m')
+                 _      -> p
+{-# INLINABLE insersectionWithInternal #-}
+
 -- | /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.
@@ -1259,6 +1325,20 @@ intersectionWithKey f a b = foldlWithKey' go empty a
                  _      -> m
 {-# INLINABLE intersectionWithKey #-}
 
+-- | /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.
+-- The result is a tuple with the size of the resulting hashmap, and the
+-- hashmap itself.
+intersectionWithKeyInternal :: (Eq k, Hashable k) => (k -> v1 -> v2 -> v3)
+                    -> HashMap k v1 -> HashMap k v2 -> (Int, HashMap k v3)
+intersectionWithKeyInternal f a b = foldlWithKey' go (0, empty) a
+  where
+    go p@(sz, m) k v = case lookup k b of
+                 Just w -> let (s, m') = insertInternal k (f k v w) m in (sz+s, m')
+                 _      -> p
+{-# INLINABLE intersectionWithKeyInternal #-}
+
 ------------------------------------------------------------------------
 -- * Folds