Add filterA, a faster version of filterM

Change filterM to just be filterA in order to have this be a
non-breaking change.

This removes another use of uncons, refs #71

Author: hdgarrood

bower.json

@@ -26,6 +26,7 @@
   },
   "devDependencies": {
     "purescript-assert": "^2.0.0",
-    "purescript-console": "^2.0.0"
+    "purescript-console": "^2.0.0",
+    "purescript-const": "^2.0.0"
   }
 }

src/Data/Array.purs

@@ -67,6 +67,7 @@ module Data.Array
   , concatMap
   , filter
   , partition
+  , filterA
   , filterM
   , mapMaybe
   , catMaybes
@@ -110,21 +111,18 @@ module Data.Array
   ) where
 
 import Prelude
-
 import Control.Alt ((<|>))
 import Control.Alternative (class Alternative)
 import Control.Lazy (class Lazy, defer)
 import Control.Monad.Rec.Class (class MonadRec, Step(..), tailRecM2)
-
 import Data.Foldable (class Foldable, foldl, foldr)
 import Data.Foldable (foldl, foldr, foldMap, fold, intercalate, elem, notElem, find, findMap, any, all) as Exports
 import Data.Maybe (Maybe(..), maybe, isJust, fromJust)
 import Data.NonEmpty (NonEmpty, (:|))
 import Data.Traversable (scanl, scanr) as Exports
-import Data.Traversable (sequence)
+import Data.Traversable (sequence, traverse)
 import Data.Tuple (Tuple(..))
 import Data.Unfoldable (class Unfoldable, unfoldr)
-
 import Partial.Unsafe (unsafePartial)
 
 -- | Convert an `Array` into an `Unfoldable` structure.
@@ -417,17 +415,20 @@ foreign import partition
   -> Array a
   -> { yes :: Array a, no :: Array a }
 
--- | Filter where the predicate returns a monadic `Boolean`.
+-- | Filter where the predicate returns a `Boolean` in some `Applicative`.
 -- |
 -- | ```purescript
--- | powerSet :: forall a. [a] -> [[a]]
--- | powerSet = filterM (const [true, false])
+-- | powerSet :: forall a. Array a -> Array (Array a)
+-- | powerSet = filterA (const [true, false])
 -- | ```
+filterA :: forall a f. Applicative f => (a -> f Boolean) -> Array a -> f (Array a)
+filterA p =
+  traverse (\x -> Tuple x <$> p x)
+  >>> map (mapMaybe (\(Tuple x b) -> if b then Just x else Nothing))
+
+-- | Deprecated alias for `filterA`.
 filterM :: forall a m. Monad m => (a -> m Boolean) -> Array a -> m (Array a)
-filterM p = uncons' (\_ -> pure []) \x xs -> do
-  b <- p x
-  xs' <- filterM p xs
-  pure if b then x : xs' else xs'
+filterM = filterA
 
 -- | Apply a function to each element in an array, keeping only the results
 -- | which contain a value, creating a new array.

test/Test/Data/Array.purs

@@ -5,6 +5,7 @@ import Prelude
 import Control.Monad.Eff (Eff)
 import Control.Monad.Eff.Console (log, CONSOLE)
 
+import Data.Const (Const(..))
 import Data.Array as A
 import Data.Array ((:), (\\), (!!))
 import Data.Foldable (for_, foldMapDefaultR, class Foldable, all, traverse_)
@@ -205,9 +206,12 @@ testArray = do
   log "filter should remove items that don't match a predicate"
   assert $ A.filter odd (A.range 0 10) == [1, 3, 5, 7, 9]
 
-  log "filterM should remove items that don't match a predicate while using a monadic behaviour"
-  assert $ A.filterM (Just <<< odd) (A.range 0 10) == Just [1, 3, 5, 7, 9]
-  assert $ A.filterM (const Nothing) (A.range 0 10) == Nothing
+  log "filterA should remove items that don't match a predicate while using an applicative behaviour"
+  assert $ A.filterA (Just <<< odd) (A.range 0 10) == Just [1, 3, 5, 7, 9]
+  assert $ A.filterA (const Nothing) (A.range 0 10) == Nothing
+
+  log "filterA should apply effects in the right order"
+  assert $ A.filterA (Const <<< show) (A.range 1 5) == Const "12345"
 
   log "mapMaybe should transform every item in an array, throwing out Nothing values"
   assert $ A.mapMaybe (\x -> if x /= 0 then Just x else Nothing) [0, 1, 0, 0, 2, 3] == [1, 2, 3]