Rename mapAccumWithKey{L,R} to mapAccum{L,R}WithKey. (#221)

Author: jonathanknowles

src/benchmark/Main.hs

@@ -127,17 +127,17 @@ main = do
             , bench "RecoveredMap" $
                 nf (mapAccumR (\s v -> (s + v, v)) 0) rm_natural
             ]
-        , bgroup "mapAccumWithKeyL"
+        , bgroup "mapAccumLWithKey"
             [ bench "Data.Map.Strict" $
                 nf (mapAccumL (\s v -> (s + v, v)) 0) om_natural
             , bench "RecoveredMap" $
                 nf (mapAccumL (\s v -> (s + v, v)) 0) rm_natural
             ]
-        , bgroup "mapAccumWithKeyR"
+        , bgroup "mapAccumRWithKey"
             [ bench "Data.Map.Strict" $
-                nf (mapAccumWithKeyR (\s k v -> (s + k + v, v)) 0) om_natural
+                nf (mapAccumRWithKey (\s k v -> (s + k + v, v)) 0) om_natural
             , bench "RecoveredMap" $
-                nf (mapAccumWithKeyR (\s k v -> (s + k + v, v)) 0) rm_natural
+                nf (mapAccumRWithKey (\s k v -> (s + k + v, v)) 0) rm_natural
             ]
         ]
   where
@@ -172,8 +172,8 @@ class Ord k => Map m k v where
     lookup :: k -> m k v -> Maybe v
     mapAccumL :: (s -> v -> (s, v)) -> s -> m k v -> (s, m k v)
     mapAccumR :: (s -> v -> (s, v)) -> s -> m k v -> (s, m k v)
-    mapAccumWithKeyL :: (s -> k -> v -> (s, v)) -> s -> m k v -> (s, m k v)
-    mapAccumWithKeyR :: (s -> k -> v -> (s, v)) -> s -> m k v -> (s, m k v)
+    mapAccumLWithKey :: (s -> k -> v -> (s, v)) -> s -> m k v -> (s, m k v)
+    mapAccumRWithKey :: (s -> k -> v -> (s, v)) -> s -> m k v -> (s, m k v)
 
 instance Ord k => Map OMap.Map k v where
     fromList = OMap.fromList
@@ -182,8 +182,8 @@ instance Ord k => Map OMap.Map k v where
     lookup = OMap.lookup
     mapAccumL = OMap.mapAccum
     mapAccumR f = OMap.mapAccumRWithKey (\s _ v -> f s v)
-    mapAccumWithKeyL = OMap.mapAccumWithKey
-    mapAccumWithKeyR = OMap.mapAccumRWithKey
+    mapAccumLWithKey = OMap.mapAccumWithKey
+    mapAccumRWithKey = OMap.mapAccumRWithKey
 
 instance (Ord k, Eq v) => Map RMap.Map k v where
     fromList = RMap.fromList
@@ -192,8 +192,8 @@ instance (Ord k, Eq v) => Map RMap.Map k v where
     lookup = RMap.lookup
     mapAccumL = RMap.mapAccumL
     mapAccumR = RMap.mapAccumR
-    mapAccumWithKeyL = RMap.mapAccumWithKeyL
-    mapAccumWithKeyR = RMap.mapAccumWithKeyR
+    mapAccumLWithKey = RMap.mapAccumLWithKey
+    mapAccumRWithKey = RMap.mapAccumRWithKey
 
 deleteMany :: (Map m k v, Num v) => [k] -> m k v -> m k v
 deleteMany xs m = foldl' (flip delete) m xs

src/examples/Examples/RecoveredMap.hs

@@ -21,9 +21,9 @@ module Examples.RecoveredMap
     , member
     , map
     , mapAccumL
+    , mapAccumLWithKey
     , mapAccumR
-    , mapAccumWithKeyL
-    , mapAccumWithKeyR
+    , mapAccumRWithKey
     )
     where
 
@@ -98,13 +98,13 @@ mapAccumL f s m = Map <$> MonoidMap.mapAccumL (accum f) s (unMap m)
 mapAccumR :: (s -> v1 -> (s, v2)) -> s -> Map k v1 -> (s, Map k v2)
 mapAccumR f s m = Map <$> MonoidMap.mapAccumR (accum f) s (unMap m)
 
-mapAccumWithKeyL :: (s -> k -> v1 -> (s, v2)) -> s -> Map k v1 -> (s, Map k v2)
-mapAccumWithKeyL f s m =
-    Map <$> MonoidMap.mapAccumWithKeyL (accumWithKey f) s (unMap m)
+mapAccumLWithKey :: (s -> k -> v1 -> (s, v2)) -> s -> Map k v1 -> (s, Map k v2)
+mapAccumLWithKey f s m =
+    Map <$> MonoidMap.mapAccumLWithKey (accumWithKey f) s (unMap m)
 
-mapAccumWithKeyR :: (s -> k -> v1 -> (s, v2)) -> s -> Map k v1 -> (s, Map k v2)
-mapAccumWithKeyR f s m =
-    Map <$> MonoidMap.mapAccumWithKeyR (accumWithKey f) s (unMap m)
+mapAccumRWithKey :: (s -> k -> v1 -> (s, v2)) -> s -> Map k v1 -> (s, Map k v2)
+mapAccumRWithKey f s m =
+    Map <$> MonoidMap.mapAccumRWithKey (accumWithKey f) s (unMap m)
 
 --------------------------------------------------------------------------------
 -- Utilities

src/internal/Data/MonoidMap/Internal.hs

@@ -81,9 +81,9 @@ module Data.MonoidMap.Internal
     , traverse
     , traverseWithKey
     , mapAccumL
+    , mapAccumLWithKey
     , mapAccumR
-    , mapAccumWithKeyL
-    , mapAccumWithKeyR
+    , mapAccumRWithKey
 
     -- * Monoidal operations
 
@@ -1273,51 +1273,51 @@ mapAccumR f s m =
 -- Satisfies the following property:
 --
 -- @
--- 'mapAccumWithKeyL' f s m '=='
+-- 'mapAccumLWithKey' f s m '=='
 -- 'fmap' 'fromMap' ('Map'.'Map.mapAccumWithKey' f s ('toMap' m))
 -- @
 --
 -- @since 0.0.1.9
 --
-mapAccumWithKeyL
+mapAccumLWithKey
     :: MonoidNull v2
     => (s -> k -> v1 -> (s, v2))
     -> s
     -> MonoidMap k v1
     -> (s, MonoidMap k v2)
-mapAccumWithKeyL f s0 m =
+mapAccumLWithKey f s0 m =
     (coerce
         :: ((k -> v1 -> StateL s  v2 ) -> MM k v1 -> StateL s (MM k v2))
         -> ((k -> v1 -> s ->  (s, v2)) -> MM k v1 -> s ->  (s, MM k v2))
     )
     traverseWithKey (\k v1 s -> f s k v1) m s0
-{-# INLINE mapAccumWithKeyL #-}
+{-# INLINE mapAccumLWithKey #-}
 
 -- | \(O(n)\). Threads an accumulating argument through the map in descending
 --   order of keys.
 --
 -- Satisfies the following property:
 --
 -- @
--- 'mapAccumWithKeyR' f s m '=='
+-- 'mapAccumRWithKey' f s m '=='
 -- 'fmap' 'fromMap' ('Map'.'Map.mapAccumRWithKey' f s ('toMap' m))
 -- @
 --
 -- @since 0.0.1.9
 --
-mapAccumWithKeyR
+mapAccumRWithKey
     :: MonoidNull v2
     => (s -> k -> v1 -> (s, v2))
     -> s
     -> MonoidMap k v1
     -> (s, MonoidMap k v2)
-mapAccumWithKeyR f s0 m =
+mapAccumRWithKey f s0 m =
     (coerce
         :: ((k -> v1 -> StateR s  v2 ) -> MM k v1 -> StateR s (MM k v2))
         -> ((k -> v1 -> s ->  (s, v2)) -> MM k v1 -> s ->  (s, MM k v2))
     )
     traverseWithKey (\k v1 s -> f s k v1) m s0
-{-# INLINE mapAccumWithKeyR #-}
+{-# INLINE mapAccumRWithKey #-}
 
 --------------------------------------------------------------------------------
 -- Comparison

src/public/Data/MonoidMap.hs

@@ -80,9 +80,9 @@ module Data.MonoidMap
     , traverse
     , traverseWithKey
     , mapAccumL
+    , mapAccumLWithKey
     , mapAccumR
-    , mapAccumWithKeyL
-    , mapAccumWithKeyR
+    , mapAccumRWithKey
 
     -- * Monoidal operations
 

src/test/Data/MonoidMap/TraversalSpec.hs

@@ -96,22 +96,22 @@ specFor = makeSpec $ do
             prop_mapAccumR @String
                 @k @v & property
 
-    describe "mapAccumWithKeyL" $ do
+    describe "mapAccumLWithKey" $ do
 
-        it "prop_mapAccumWithKeyL_@Int" $
-            prop_mapAccumWithKeyL @Int
+        it "prop_mapAccumLWithKey_@Int" $
+            prop_mapAccumLWithKey @Int
                 @k @v & property
-        it "prop_mapAccumWithKeyL_@String" $
-            prop_mapAccumWithKeyL @String
+        it "prop_mapAccumLWithKey_@String" $
+            prop_mapAccumLWithKey @String
                 @k @v & property
 
-    describe "mapAccumWithKeyR" $ do
+    describe "mapAccumRWithKey" $ do
 
-        it "prop_mapAccumWithKeyR_@Int" $
-            prop_mapAccumWithKeyR @Int
+        it "prop_mapAccumRWithKey_@Int" $
+            prop_mapAccumRWithKey @Int
                 @k @v & property
-        it "prop_mapAccumWithKeyR_@String" $
-            prop_mapAccumWithKeyR @String
+        it "prop_mapAccumRWithKey_@String" $
+            prop_mapAccumRWithKey @String
                 @k @v & property
 
 prop_traverse
@@ -158,25 +158,25 @@ prop_mapAccumR (applyFun2 -> f) s m =
     ===
     fmap MonoidMap.fromMap (Traversable.mapAccumR f s (MonoidMap.toMap m))
 
-prop_mapAccumWithKeyL
+prop_mapAccumLWithKey
     :: forall s k v. (Test k v, Eq s, Show s)
     => Fun (s, k, v) (s, v)
     -> s
     -> MonoidMap k v
     -> Property
-prop_mapAccumWithKeyL (applyFun3 -> f) s m =
-    MonoidMap.mapAccumWithKeyL f s m
+prop_mapAccumLWithKey (applyFun3 -> f) s m =
+    MonoidMap.mapAccumLWithKey f s m
     ===
     fmap MonoidMap.fromMap (Map.mapAccumWithKey f s (MonoidMap.toMap m))
 
-prop_mapAccumWithKeyR
+prop_mapAccumRWithKey
     :: forall s k v. (Test k v, Eq s, Show s)
     => Fun (s, k, v) (s, v)
     -> s
     -> MonoidMap k v
     -> Property
-prop_mapAccumWithKeyR (applyFun3 -> f) s m =
-    MonoidMap.mapAccumWithKeyR f s m
+prop_mapAccumRWithKey (applyFun3 -> f) s m =
+    MonoidMap.mapAccumRWithKey f s m
     ===
     fmap MonoidMap.fromMap (Map.mapAccumRWithKey f s (MonoidMap.toMap m))
 

src/test/Examples/RecoveredMapSpec.hs

@@ -207,19 +207,19 @@ specFor keyType valueType = do
                     @k @v @v & property
 
         describe "MapAccumWithKeyL" $ do
-            it "prop_mapAccumWithKeyL @Int" $
-                prop_mapAccumWithKeyL @Int
+            it "prop_mapAccumLWithKey @Int" $
+                prop_mapAccumLWithKey @Int
                     @k @v @v & property
-            it "prop_mapAccumWithKeyL @String" $
-                prop_mapAccumWithKeyL @String
+            it "prop_mapAccumLWithKey @String" $
+                prop_mapAccumLWithKey @String
                     @k @v @v & property
 
         describe "MapAccumWithKeyR" $ do
-            it "prop_mapAccumWithKeyR @Int" $
-                prop_mapAccumWithKeyR @Int
+            it "prop_mapAccumRWithKey @Int" $
+                prop_mapAccumRWithKey @Int
                     @k @v @v & property
-            it "prop_mapAccumWithKeyR @String" $
-                prop_mapAccumWithKeyR @String
+            it "prop_mapAccumRWithKey @String" $
+                prop_mapAccumRWithKey @String
                     @k @v @v & property
 
 --------------------------------------------------------------------------------
@@ -534,33 +534,33 @@ prop_mapAccumR (applyFun2 -> f) s0 kvs =
 -- MapAccumWithKey
 --------------------------------------------------------------------------------
 
-prop_mapAccumWithKeyL
+prop_mapAccumLWithKey
     :: forall s k v1 v2. (Eq s, Eq v2, Ord k, Show k, Show s, Show v2)
     => Fun (s, k, v1) (s, v2)
     -> s
     -> [(k, v1)]
     -> Property
-prop_mapAccumWithKeyL (applyFun3 -> f) s0 kvs =
+prop_mapAccumLWithKey (applyFun3 -> f) s0 kvs =
     (===)
-        (RMap.toList <$> rmapAccumWithKeyL f s0 (RMap.fromList kvs))
-        (OMap.toList <$> omapAccumWithKeyL f s0 (OMap.fromList kvs))
+        (RMap.toList <$> rmapAccumLWithKey f s0 (RMap.fromList kvs))
+        (OMap.toList <$> omapAccumLWithKey f s0 (OMap.fromList kvs))
   where
-    rmapAccumWithKeyL = RMap.mapAccumWithKeyL
-    omapAccumWithKeyL = OMap.mapAccumWithKey
+    rmapAccumLWithKey = RMap.mapAccumLWithKey
+    omapAccumLWithKey = OMap.mapAccumWithKey
 
-prop_mapAccumWithKeyR
+prop_mapAccumRWithKey
     :: forall s k v1 v2. (Eq s, Eq v2, Ord k, Show k, Show s, Show v2)
     => Fun (s, k, v1) (s, v2)
     -> s
     -> [(k, v1)]
     -> Property
-prop_mapAccumWithKeyR (applyFun3 -> f) s0 kvs =
+prop_mapAccumRWithKey (applyFun3 -> f) s0 kvs =
     (===)
-        (RMap.toList <$> rmapAccumWithKeyR f s0 (RMap.fromList kvs))
-        (OMap.toList <$> omapAccumWithKeyR f s0 (OMap.fromList kvs))
+        (RMap.toList <$> rmapAccumRWithKey f s0 (RMap.fromList kvs))
+        (OMap.toList <$> omapAccumRWithKey f s0 (OMap.fromList kvs))
   where
-    rmapAccumWithKeyR = RMap.mapAccumWithKeyR
-    omapAccumWithKeyR = OMap.mapAccumRWithKey
+    rmapAccumRWithKey = RMap.mapAccumRWithKey
+    omapAccumRWithKey = OMap.mapAccumRWithKey
 
 --------------------------------------------------------------------------------
 -- Arbitrary instances