Added more efficient unionWith, eliminate transformation Map to List in Foldable{WithIndex} instances.

CHANGELOG.md

@@ -10,6 +10,7 @@ Breaking changes:
 New features:
 - Exported `Data.Map.Internal` data constructors (#52 by @natefaubion)
 - Add unbiased `Semigroup`/`Monoid` instances to `Map` with `Warn` (#54 by @JordanMartinez)
+- Improved speed of `foldr`, `foldl`, `foldMap`, `foldlWithIndex`, `foldrWithIndex`, `foldMapWithIndex`, `unionWith` (#60 by @xgrommx)
 
 Bugfixes:
 

bench/Bench/Data/Map.purs

@@ -4,6 +4,9 @@ import Prelude
 
 import Data.List as L
 import Data.Map as M
+import Bench.Data.Map2a0bff as Map2a0bff
+import Data.Foldable as F
+import Data.FoldableWithIndex as FI
 import Data.Tuple (Tuple(..))
 import Effect (Effect)
 import Effect.Console (log)
@@ -21,8 +24,38 @@ benchMap = do
   log "------------"
   benchFromFoldable
 
+  log ""
+
+  log "Foldable"
+  log "---------------"
+  benchFoldable
+
+  log ""
+
+  log "union"
+  log "---------------"
+  benchUnion
+
   where
 
+  benchUnion = do
+    let nats = L.range 0 999999
+        nats2 = L.range 999999 1999999
+        natPairs = (flip Tuple) unit <$> nats
+        natPairs2 = (flip Tuple) unit <$> nats2
+        bigMap = Map2a0bff.fromFoldable $ natPairs
+        bigMap2 = Map2a0bff.fromFoldable $ natPairs2
+        bigMap' = M.fromFoldable $ natPairs
+        bigMap2' = M.fromFoldable $ natPairs2
+        size = Map2a0bff.size bigMap
+        size' = M.size bigMap'
+
+    log $ "Map2a0bff.union: big map (" <> show size <> ")"
+    benchWith 10 \_ -> Map2a0bff.union bigMap bigMap2
+
+    log $ "M.union: big map (" <> show size' <> ")"
+    benchWith 10 \_ -> M.union bigMap' bigMap2'
+
   benchSize = do
     let nats = L.range 0 999999
         natPairs = (flip Tuple) unit <$> nats
@@ -43,6 +76,50 @@ benchMap = do
     log $ "size: big map (" <> show (M.size bigMap) <> ")"
     benchWith 10  \_ -> M.size bigMap
 
+  benchFoldable = do
+    let nats = L.range 0 999999
+        natPairs = (flip Tuple) unit <$> nats
+        bigMap = Map2a0bff.fromFoldable $ natPairs
+        bigMap' = M.fromFoldable $ natPairs
+        size = Map2a0bff.size bigMap
+        size' = M.size bigMap'
+
+    log $ "Map2a0bff.foldr big map (" <> show size <> ")"
+    benchWith 10 \_ -> F.foldr (\_ _ -> unit) unit bigMap
+
+    log $ "M.foldr big map (" <> show size' <> ")"
+    benchWith 10 \_ -> F.foldr (\_ _ -> unit) unit bigMap'
+
+    log $ "Map2a0bff.foldl big map (" <> show size <> ")"
+    benchWith 10 \_ -> F.foldl (\_ _ -> unit) unit bigMap
+
+    log $ "M.foldl big map (" <> show size' <> ")"
+    benchWith 10 \_ -> F.foldl (\_ _ -> unit) unit bigMap'
+
+    log $ "Map2a0bff.foldMap big map (" <> show size <> ")"
+    benchWith 10 \_ -> F.foldMap (\_ -> unit) bigMap
+
+    log $ "M.foldMap big map (" <> show size' <> ")"
+    benchWith 10 \_ -> F.foldMap (\_ -> unit) bigMap'
+
+    log $ "Map2a0bff.foldrWithIndex big map (" <> show size <> ")"
+    benchWith 10 \_ -> FI.foldrWithIndex (\_ _ _ -> unit) unit bigMap
+
+    log $ "M.foldrWithIndex big map (" <> show size' <> ")"
+    benchWith 10 \_ -> FI.foldrWithIndex (\_ _ _ -> unit) unit bigMap'
+
+    log $ "Map2a0bff.foldlWithIndex big map (" <> show size <> ")"
+    benchWith 10 \_ -> FI.foldlWithIndex (\_ _ _ -> unit) unit bigMap
+
+    log $ "M.foldlWithIndex big map (" <> show size' <> ")"
+    benchWith 10 \_ -> FI.foldlWithIndex (\_ _ _ -> unit) unit bigMap'
+
+    log $ "Map2a0bff.foldMapWithIndex big map (" <> show size <> ")"
+    benchWith 10 \_ -> FI.foldMapWithIndex (\_ _ -> unit) bigMap
+
+    log $ "M.foldMapWithIndex big map (" <> show size' <> ")"
+    benchWith 10 \_ -> FI.foldMapWithIndex (\_ _ -> unit) bigMap'
+
   benchFromFoldable = do
     let natStrs = show <$> L.range 0 99999
         natPairs = (flip Tuple) unit <$> natStrs