Remove fromFoldableWithIndexWith

Author: pete-murphy

src/Foreign/Object.purs

@@ -16,7 +16,6 @@ module Foreign.Object
   , fromFoldable
   , fromFoldableWith
   , fromFoldableWithIndex
-  , fromFoldableWithIndexWith
   , fromHomogeneous
   , delete
   , pop
@@ -232,24 +231,6 @@ fromFoldableWithIndex l = runST do
 
 foreign import _lookupST :: forall a r z. Fn4 z (a -> z) String (STObject r a) (ST r z)
 
--- | Create an `Object a` from an indexed foldable collection, using the
--- | specified functions to map key-value pairs to `String`-value pairs and
--- | combine values at duplicate `String` keys
-fromFoldableWithIndexWith
-  :: forall f k a b
-   . FoldableWithIndex k f
-  => (k -> a -> Tuple String b)
-  -> (b -> b -> b)
-  -> f a
-  -> Object b
-fromFoldableWithIndexWith f g l = runST do
-  s <- OST.new
-  let g' = flip g
-  forWithIndex_ l \k a -> do
-    let Tuple k' b = f k a
-    runFn4 _lookupST b (g' b) k' s >>= \b' -> OST.poke k' b' s
-  pure s
-
 -- | Create an `Object a` from a foldable collection of key/value pairs, using the
 -- | specified function to combine values for duplicate keys.
 fromFoldableWith :: forall f a. Foldable f => (a -> a -> a) -> f (Tuple String a) -> Object a
@@ -322,7 +303,7 @@ filterWithKey predicate m = runST go
     m' <- OST.new
     foldM step m' m
     where
-    step acc k v = if predicate k v then OST.poke k v acc else pure acc
+      step acc k v = if predicate k v then OST.poke k v acc else pure acc
 
 -- | Filter out those key/value pairs of a map for which a predicate
 -- | on the key fails to hold.

test/Test/Foreign/Object.purs

@@ -12,10 +12,8 @@ import Data.List as L
 import Data.List.NonEmpty as NEL
 import Data.Map as M
 import Data.Maybe (Maybe(..), fromMaybe)
-import Data.Profunctor.Strong (first)
 import Data.Semigroup.First (First(..))
 import Data.Semigroup.Last (Last(..))
-import Data.String (toUpper)
 import Data.Traversable (sequence, traverse)
 import Data.TraversableWithIndex (traverseWithIndex)
 import Data.Tuple (Tuple(..), fst, snd, uncurry)
@@ -161,14 +159,6 @@ objectTests = do
     quickCheck (O.lookup "1" nums == Just "one"  <?> "invalid lookup - 1")
     quickCheck (O.lookup "2" nums == Just "two"  <?> "invalid lookup - 2")
 
-  log "fromFoldableWithIndexWith"
-  do
-    let numsMap = M.fromFoldable [Tuple 0 "zero", Tuple 1 "one", Tuple 2 "two"]
-        f n = if n == 0 then "0" else "1"
-        nums = O.fromFoldableWithIndexWith (\k v -> Tuple (f k) v) (<>) numsMap
-    quickCheck (O.lookup "0" nums == Just "zero"   <?> "invalid lookup - 0")
-    quickCheck (O.lookup "1" nums == Just "onetwo" <?> "invalid lookup - 1")
-
   log "fromFoldableWith const [] = empty"
   quickCheck (O.fromFoldableWith const [] == (O.empty :: O.Object Unit)
     <?> "was not empty")
@@ -198,17 +188,6 @@ objectTests = do
     let f m1 = O.fromFoldable ((O.toUnfoldable m1) :: L.List (Tuple String Int)) in
     O.fromFoldableWithIndex m == f m <?> show m
 
-  log "fromFoldableWithIndexWith f const ~ fromFoldable . map (first f) . toUnfoldable"
-  quickCheck $ \(TestObject m) ->
-    O.fromFoldableWithIndexWith (\k v -> Tuple (toUpper k) v) const m ==
-    O.fromFoldable (first toUpper <$> (O.toUnfoldable m :: L.List (Tuple String Int))) <?> show m
-
-  log "fromFoldableWithIndexWith Tuple const = fromFoldableWithIndex"
-  quickCheck $ \arr ->
-    let m = M.fromFoldable (arr :: L.List (Tuple String Int)) in
-    O.fromFoldableWithIndexWith Tuple const m ==
-    O.fromFoldableWithIndex m <?> show m
-
   log "fromFoldableWith const = fromFoldable"
   quickCheck $ \arr -> O.fromFoldableWith const arr ==
                        O.fromFoldable (arr :: L.List (Tuple String Int)) <?> show arr