filterValues and filterKeys (#97)

* filterValues and filterKeys

whitespace

pluralize

test fixes

simplify tests

use ST to reduce algorithmic complexity

* refactor filters in terms of k/v filter

also add documentation

* use ~>

* rename filter fns

following review: #97 (review)

Author: matthewleon

src/Data/StrMap.purs

@@ -22,6 +22,9 @@ module Data.StrMap
   , alter
   , update
   , mapWithKey
+  , filterWithKey
+  , filterKeys
+  , filter
   , keys
   , values
   , union
@@ -258,3 +261,26 @@ instance semigroupStrMap :: (Semigroup a) => Semigroup (StrMap a) where
 
 instance monoidStrMap :: (Semigroup a) => Monoid (StrMap a) where
   mempty = empty
+
+-- | Filter out those key/value pairs of a map for which a predicate
+-- | fails to hold.
+filterWithKey :: forall a. (String -> a -> Boolean) -> StrMap a -> StrMap a
+filterWithKey predicate m = pureST go
+  where
+  go :: forall h e. Eff (st :: ST.ST h | e) (SM.STStrMap h a)
+  go = do
+    m' <- SM.new
+    foldM step m' m
+
+    where
+    step acc k v = if predicate k v then SM.poke acc k v else pure acc
+
+-- | Filter out those key/value pairs of a map for which a predicate
+-- | on the key fails to hold.
+filterKeys :: (String -> Boolean) -> StrMap ~> StrMap
+filterKeys predicate = filterWithKey $ const <<< predicate
+
+-- | Filter out those key/value pairs of a map for which a predicate
+-- | on the value fails to hold.
+filter :: forall a. (a -> Boolean) -> StrMap a -> StrMap a
+filter predicate = filterWithKey $ const predicate

test/Test/Data/StrMap.purs

@@ -15,7 +15,7 @@ import Data.List.NonEmpty as NEL
 import Data.Maybe (Maybe(..))
 import Data.NonEmpty ((:|))
 import Data.StrMap as M
-import Data.Tuple (Tuple(..), fst)
+import Data.Tuple (Tuple(..), fst, uncurry)
 import Data.Traversable (sequence)
 
 import Partial.Unsafe (unsafePartial)
@@ -113,6 +113,30 @@ strMapTests = do
   log "Singleton to list"
   quickCheck $ \k v -> M.toUnfoldable (M.singleton k v :: M.StrMap Int) == L.singleton (Tuple k v)
 
+  log "filterWithKey gives submap"
+  quickCheck $ \(TestStrMap (s :: M.StrMap Int)) p ->
+                 M.isSubmap (M.filterWithKey p s) s
+
+  log "filterWithKey keeps those keys for which predicate is true"
+  quickCheck $ \(TestStrMap (s :: M.StrMap Int)) p ->
+                 A.all (uncurry p) (M.toAscUnfoldable (M.filterWithKey p s) :: Array (Tuple String Int))
+
+  log "filterKeys gives submap"
+  quickCheck $ \(TestStrMap (s :: M.StrMap Int)) p ->
+                 M.isSubmap (M.filterKeys p s) s
+
+  log "filterKeys keeps those keys for which predicate is true"
+  quickCheck $ \(TestStrMap (s :: M.StrMap Int)) p ->
+                 A.all p (M.keys (M.filterKeys p s))
+
+  log "filter gives submap"
+  quickCheck $ \(TestStrMap (s :: M.StrMap Int)) p ->
+                 M.isSubmap (M.filter p s) s
+
+  log "filter keeps those values for which predicate is true"
+  quickCheck $ \(TestStrMap (s :: M.StrMap Int)) p ->
+                 A.all p (M.values (M.filter p s))
+
   log "fromFoldable [] = empty"
   quickCheck (M.fromFoldable [] == (M.empty :: M.StrMap Unit)
     <?> "was not empty")