--- libraries/base/Control/Monad.hs | 37 ++++++++++++++++--------------------- 1 file changed, 16 insertions(+), 21 deletions(-) diff --git a/libraries/base/Control/Monad.hs b/libraries/base/Control/Monad.hs index 6fa4a07..02eabd1 100644 --- a/libraries/base/Control/Monad.hs +++ b/libraries/base/Control/Monad.hs @@ -75,9 +75,9 @@ module Control.Monad , (<$!>) ) where -import Data.Foldable ( Foldable, sequence_, msum, mapM_, foldlM, forM_ ) -import Data.Functor ( void ) -import Data.Traversable ( forM, mapM, sequence ) +import Data.Functor ( void, (<$>) ) +import Data.Foldable ( Foldable, sequence_, sequenceA_, msum, mapM_, foldlM, forM_ ) +import Data.Traversable ( forM, mapM, traverse, sequence, sequenceA ) import GHC.Base hiding ( mapM, sequence ) import GHC.List ( zipWith, unzip, replicate ) @@ -94,13 +94,8 @@ guard False = empty -- | This generalizes the list-based 'filter' function. {-# INLINE filterM #-} -filterM :: (Monad m) => (a -> m Bool) -> [a] -> m [a] -filterM p = foldr go (return []) - where - go x r = do - flg <- p x - ys <- r - return (if flg then x:ys else ys) +filterM :: (Applicative m) => (a -> m Bool) -> [a] -> m [a] +filterM p = foldr (\ x -> liftA2 (\ flg -> if flg then (x:) else id) (p x)) (pure []) infixr 1 <=<, >=> @@ -125,19 +120,19 @@ forever a = let a' = a >> a' in a' -- | The 'mapAndUnzipM' function maps its first argument over a list, returning -- the result as a pair of lists. This function is mainly used with complicated -- data structures or a state-transforming monad. -mapAndUnzipM :: (Monad m) => (a -> m (b,c)) -> [a] -> m ([b], [c]) +mapAndUnzipM :: (Applicative m) => (a -> m (b,c)) -> [a] -> m ([b], [c]) {-# INLINE mapAndUnzipM #-} -mapAndUnzipM f xs = sequence (map f xs) >>= return . unzip +mapAndUnzipM f xs = unzip <$> traverse f xs --- | The 'zipWithM' function generalizes 'zipWith' to arbitrary monads. -zipWithM :: (Monad m) => (a -> b -> m c) -> [a] -> [b] -> m [c] +-- | The 'zipWithM' function generalizes 'zipWith' to arbitrary applicative functors. +zipWithM :: (Applicative m) => (a -> b -> m c) -> [a] -> [b] -> m [c] {-# INLINE zipWithM #-} -zipWithM f xs ys = sequence (zipWith f xs ys) +zipWithM f xs ys = sequenceA (zipWith f xs ys) -- | 'zipWithM_' is the extension of 'zipWithM' which ignores the final result. -zipWithM_ :: (Monad m) => (a -> b -> m c) -> [a] -> [b] -> m () +zipWithM_ :: (Applicative m) => (a -> b -> m c) -> [a] -> [b] -> m () {-# INLINE zipWithM_ #-} -zipWithM_ f xs ys = sequence_ (zipWith f xs ys) +zipWithM_ f xs ys = sequenceA_ (zipWith f xs ys) {- | The 'foldM' function is analogous to 'foldl', except that its result is encapsulated in a monad. Note that 'foldM' works from left-to-right over @@ -175,18 +170,18 @@ foldM_ f a xs = foldlM f a xs >> return () -- | @'replicateM' n act@ performs the action @n@ times, -- gathering the results. -replicateM :: (Monad m) => Int -> m a -> m [a] +replicateM :: (Applicative m) => Int -> m a -> m [a] {-# INLINEABLE replicateM #-} {-# SPECIALISE replicateM :: Int -> IO a -> IO [a] #-} {-# SPECIALISE replicateM :: Int -> Maybe a -> Maybe [a] #-} -replicateM n x = sequence (replicate n x) +replicateM n x = sequenceA (replicate n x) -- | Like 'replicateM', but discards the result. -replicateM_ :: (Monad m) => Int -> m a -> m () +replicateM_ :: (Applicative m) => Int -> m a -> m () {-# INLINEABLE replicateM_ #-} {-# SPECIALISE replicateM_ :: Int -> IO a -> IO () #-} {-# SPECIALISE replicateM_ :: Int -> Maybe a -> Maybe () #-} -replicateM_ n x = sequence_ (replicate n x) +replicateM_ n x = sequenceA_ (replicate n x) -- | The reverse of 'when'. unless :: (Applicative f) => Bool -> f () -> f () -- 2.3.1