Add insertWith and insertWithKey benchmarks.

insertWith is implemented using insertWithKey so other than noise they should
have similar results.

benchmarking HashMap/insertWith/String
time                 1.932 ms   (1.771 ms .. 2.124 ms)
                     0.954 R²   (0.923 R² .. 0.983 R²)
mean                 1.750 ms   (1.664 ms .. 1.872 ms)
std dev              301.9 μs   (227.4 μs .. 410.5 μs)
variance introduced by outliers: 87% (severely inflated)

benchmarking HashMap/insertWith/ByteString
time                 2.272 ms   (2.194 ms .. 2.347 ms)
                     0.978 R²   (0.951 R² .. 0.994 R²)
mean                 1.840 ms   (1.744 ms .. 1.962 ms)
std dev              331.1 μs   (266.5 μs .. 486.0 μs)
variance introduced by outliers: 88% (severely inflated)

benchmarking HashMap/insertWith/Int
time                 1.321 ms   (1.241 ms .. 1.454 ms)
                     0.955 R²   (0.932 R² .. 0.976 R²)
mean                 1.365 ms   (1.316 ms .. 1.420 ms)
std dev              178.3 μs   (150.3 μs .. 230.6 μs)
variance introduced by outliers: 81% (severely inflated)

benchmarking HashMap/insertWithKey/String
time                 1.783 ms   (1.714 ms .. 1.900 ms)
                     0.959 R²   (0.934 R² .. 0.983 R²)
mean                 1.614 ms   (1.526 ms .. 1.747 ms)
std dev              289.4 μs   (217.9 μs .. 372.9 μs)
variance introduced by outliers: 89% (severely inflated)

benchmarking HashMap/insertWithKey/ByteString
time                 1.647 ms   (1.605 ms .. 1.688 ms)
                     0.992 R²   (0.983 R² .. 0.997 R²)
mean                 1.563 ms   (1.524 ms .. 1.644 ms)
std dev              164.4 μs   (85.16 μs .. 308.3 μs)
variance introduced by outliers: 71% (severely inflated)

benchmarking HashMap/insertWithKey/Int
time                 1.313 ms   (1.289 ms .. 1.335 ms)
                     0.994 R²   (0.990 R² .. 0.997 R²)
mean                 1.289 ms   (1.270 ms .. 1.338 ms)
std dev              83.74 μs   (50.75 μs .. 157.2 μs)
variance introduced by outliers: 49% (moderately inflated)

Author: m-renaud

benchmarks/Benchmarks.hs

@@ -217,6 +217,16 @@ main = do
             , bench "ByteString" $ whnf (insert elemsBS) hmbs
             , bench "Int" $ whnf (insert elemsI) hmi
             ]
+          , bgroup "insertWith"
+            [ bench "String" $ whnf (insertWith elems) HM.empty
+            , bench "ByteString" $ whnf (insertWith elemsBS) HM.empty
+            , bench "Int" $ whnf (insertWith elemsI) HM.empty
+            ]
+          , bgroup "insertWithKey"
+            [ bench "String" $ whnf (insertWithKey elems) HM.empty
+            , bench "ByteString" $ whnf (insertWithKey elemsBS) HM.empty
+            , bench "Int" $ whnf (insertWithKey elemsI) HM.empty
+            ]
           , bgroup "delete"
             [ bench "String" $ whnf (delete keys) hm
             , bench "ByteString" $ whnf (delete keysBS) hmbs
@@ -302,6 +312,27 @@ insert xs m0 = foldl' (\m (k, v) -> HM.insert k v m) m0 xs
 {-# SPECIALIZE insert :: [(BS.ByteString, Int)] -> HM.HashMap BS.ByteString Int
                       -> HM.HashMap BS.ByteString Int #-}
 
+insertWith :: (Eq k, Hashable k) => [(k, Int)] -> HM.HashMap k Int
+       -> HM.HashMap k Int
+insertWith xs m0 = foldl' (\m (k, v) -> HM.insertWith (+) k v m) m0 xs
+{-# SPECIALIZE insertWith :: [(Int, Int)] -> HM.HashMap Int Int
+                          -> HM.HashMap Int Int #-}
+{-# SPECIALIZE insertWith :: [(String, Int)] -> HM.HashMap String Int
+                          -> HM.HashMap String Int #-}
+{-# SPECIALIZE insertWith :: [(BS.ByteString, Int)] -> HM.HashMap BS.ByteString Int
+                          -> HM.HashMap BS.ByteString Int #-}
+
+insertWithKey :: (Eq k, Hashable k) => [(k, Int)] -> HM.HashMap k Int
+              -> HM.HashMap k Int
+insertWithKey xs m0 = foldl' (\m (k, v) -> HM.insertWithKey f k v m) m0 xs
+  where f = const (+)
+{-# SPECIALIZE insertWithKey :: [(Int, Int)] -> HM.HashMap Int Int
+                             -> HM.HashMap Int Int #-}
+{-# SPECIALIZE insertWithKey :: [(String, Int)] -> HM.HashMap String Int
+                             -> HM.HashMap String Int #-}
+{-# SPECIALIZE insertWithKey :: [(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.HashMap Int Int -> HM.HashMap Int Int #-}