(original) (raw)

{-# LANGUAGE Trustworthy #-} {-# LANGUAGE NoImplicitPrelude #-}

module Control.Monad (

  [Functor](GHC.Base.html#Functor)(..)
, [Monad](GHC.Base.html#Monad)([(>>=)](GHC.Base.html#%3E%3E%3D), [(>>)](GHC.Base.html#%3E%3E), [return](GHC.Base.html#return))
, [MonadFail](Control.Monad.Fail.html#MonadFail)([fail](Control.Monad.Fail.html#fail))
, [MonadPlus](GHC.Base.html#MonadPlus)([mzero](GHC.Base.html#mzero), [mplus](GHC.Base.html#mplus))


, [mapM](Data.Traversable.html#mapM)
, [mapM_](Data.Foldable.html#mapM%5F)
, [forM](Data.Traversable.html#forM)
, [forM_](Data.Foldable.html#forM%5F)
, [sequence](Data.Traversable.html#sequence)
, [sequence_](Data.Foldable.html#sequence%5F)
, [(=<<)](GHC.Base.html#%3D%3C%3C)
, [(>=>)](Control.Monad.html#%3E%3D%3E)
, [(<=<)](Control.Monad.html#%3C%3D%3C)
, [forever](Control.Monad.html#forever)
, [void](Data.Functor.html#void)


, [join](GHC.Base.html#join)
, [msum](Data.Foldable.html#msum)
, [mfilter](Control.Monad.html#mfilter)
, [filterM](Control.Monad.html#filterM)
, [mapAndUnzipM](Control.Monad.html#mapAndUnzipM)
, [zipWithM](Control.Monad.html#zipWithM)
, [zipWithM_](Control.Monad.html#zipWithM%5F)
, [foldM](Control.Monad.html#foldM)
, [foldM_](Control.Monad.html#foldM%5F)
, [replicateM](Control.Monad.html#replicateM)
, [replicateM_](Control.Monad.html#replicateM%5F)


, [guard](Control.Monad.html#guard)
, [when](GHC.Base.html#when)
, [unless](Control.Monad.html#unless)


, [liftM](GHC.Base.html#liftM)
, [liftM2](GHC.Base.html#liftM2)
, [liftM3](GHC.Base.html#liftM3)
, [liftM4](GHC.Base.html#liftM4)
, [liftM5](GHC.Base.html#liftM5)

, [ap](GHC.Base.html#ap)


, [(<$!>)](Control.Monad.html#%3C%24%21%3E)
) where

import Control.Monad.Fail ( MonadFail(fail) ) import Data.Foldable ( Foldable, sequence_, sequenceA_, msum, mapM_, foldlM, forM_ ) import Data.Functor ( void, (<$>) ) import Data.Traversable ( forM, mapM, traverse, sequence, sequenceA )

import GHC.Base hiding ( mapM, sequence ) import GHC.List ( zipWith, unzip ) import GHC.Num ( (-) )

guard :: (Alternative f) => Bool -> f () guard :: forall (f :: * -> *). Alternative f => Bool -> f () guard Bool True = () -> f () forall (f :: * -> *) a. Applicative f => a -> f a pure () guard Bool False = f () forall (f :: * -> *) a. Alternative f => f a empty

{-# INLINE filterM #-} filterM :: (Applicative m) => (a -> m Bool) -> [a] -> m [a] filterM :: forall (m :: * -> *) a. Applicative m => (a -> m Bool) -> [a] -> m [a] filterM a -> m Bool p = (a -> m [a] -> m [a]) -> m [a] -> [a] -> m [a] forall a b. (a -> b -> b) -> b -> [a] -> b foldr (\ a x -> (Bool -> [a] -> [a]) -> m Bool -> m [a] -> m [a] forall (f :: * -> *) a b c. Applicative f => (a -> b -> c) -> f a -> f b -> f c liftA2 (\ Bool flg -> if Bool flg then (a xa -> [a] -> [a] forall a. a -> [a] -> [a] :) else [a] -> [a] forall a. a -> a id) (a -> m Bool p a x)) ([a] -> m [a] forall (f :: * -> *) a. Applicative f => a -> f a pure [])

infixr 1 <=<, >=>

(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> (a -> m c) a -> m b f >=> :: forall (m :: * -> *) a b c. Monad m => (a -> m b) -> (b -> m c) -> a -> m c >=> b -> m c g = \a x -> a -> m b f a x m b -> (b -> m c) -> m c forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b >>= b -> m c g

(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> (a -> m c) <=< :: forall (m :: * -> *) b c a. Monad m => (b -> m c) -> (a -> m b) -> a -> m c (<=<) = ((a -> m b) -> (b -> m c) -> a -> m c) -> (b -> m c) -> (a -> m b) -> a -> m c forall a b c. (a -> b -> c) -> b -> a -> c flip (a -> m b) -> (b -> m c) -> a -> m c forall (m :: * -> *) a b c. Monad m => (a -> m b) -> (b -> m c) -> a -> m c (>=>)

forever :: (Applicative f) => f a -> f b {-# INLINE forever #-} forever :: forall (f :: * -> *) a b. Applicative f => f a -> f b forever f a a = let a' :: f b a' = f a a f a -> f b -> f b forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b *> f b a' in f b forall {b}. f b a'

mapAndUnzipM :: (Applicative m) => (a -> m (b,c)) -> [a] -> m ([b], [c]) {-# INLINE mapAndUnzipM #-}

mapAndUnzipM :: forall (m :: * -> *) a b c. Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c]) mapAndUnzipM a -> m (b, c) f [a] xs = [(b, c)] -> ([b], [c]) forall a b. [(a, b)] -> ([a], [b]) unzip ([(b, c)] -> ([b], [c])) -> m [(b, c)] -> m ([b], [c]) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> (a -> m (b, c)) -> [a] -> m [(b, c)] forall (t :: * -> *) (f :: * -> *) a b. (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b) traverse a -> m (b, c) f [a] xs

zipWithM :: (Applicative m) => (a -> b -> m c) -> [a] -> [b] -> m [c] {-# INLINE zipWithM #-}

zipWithM :: forall (m :: * -> *) a b c. Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c] zipWithM a -> b -> m c f [a] xs [b] ys = [m c] -> m [c] forall (t :: * -> *) (f :: * -> *) a. (Traversable t, Applicative f) => t (f a) -> f (t a) sequenceA ((a -> b -> m c) -> [a] -> [b] -> [m c] forall a b c. (a -> b -> c) -> [a] -> [b] -> [c] zipWith a -> b -> m c f [a] xs [b] ys)

zipWithM_ :: (Applicative m) => (a -> b -> m c) -> [a] -> [b] -> m () {-# INLINE zipWithM_ #-}

zipWithM_ :: forall (m :: * -> *) a b c. Applicative m => (a -> b -> m c) -> [a] -> [b] -> m () zipWithM_ a -> b -> m c f [a] xs [b] ys = [m c] -> m () forall (t :: * -> *) (f :: * -> *) a. (Foldable t, Applicative f) => t (f a) -> f () sequenceA_ ((a -> b -> m c) -> [a] -> [b] -> [m c] forall a b c. (a -> b -> c) -> [a] -> [b] -> [c] zipWith a -> b -> m c f [a] xs [b] ys)

foldM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b {-# INLINABLE foldM #-} {-# SPECIALISE foldM :: (a -> b -> IO a) -> a -> [b] -> IO a #-} {-# SPECIALISE foldM :: (a -> b -> Maybe a) -> a -> [b] -> Maybe a #-} foldM :: forall (t :: * -> *) (m :: * -> *) b a. (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b foldM = (b -> a -> m b) -> b -> t a -> m b forall (t :: * -> *) (m :: * -> *) b a. (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b foldlM

foldM_ :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m () {-# INLINABLE foldM_ #-} {-# SPECIALISE foldM_ :: (a -> b -> IO a) -> a -> [b] -> IO () #-} {-# SPECIALISE foldM_ :: (a -> b -> Maybe a) -> a -> [b] -> Maybe () #-} foldM_ :: forall (t :: * -> *) (m :: * -> *) b a. (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m () foldM_ b -> a -> m b f b a t a xs = (b -> a -> m b) -> b -> t a -> m b forall (t :: * -> *) (m :: * -> *) b a. (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b foldlM b -> a -> m b f b a t a xs m b -> m () -> m () forall (m :: * -> *) a b. Monad m => m a -> m b -> m b >> () -> m () forall (m :: * -> *) a. Monad m => a -> m a return ()

replicateM :: (Applicative m) => Int -> m a -> m [a] {-# INLINABLE replicateM #-} {-# SPECIALISE replicateM :: Int -> IO a -> IO [a] #-} {-# SPECIALISE replicateM :: Int -> Maybe a -> Maybe [a] #-} replicateM :: forall (m :: * -> *) a. Applicative m => Int -> m a -> m [a] replicateM Int cnt0 m a f = Int -> m [a] forall {t}. (Ord t, Num t) => t -> m [a] loop Int cnt0 where loop :: t -> m [a] loop t cnt | t cnt t -> t -> Bool forall a. Ord a => a -> a -> Bool <= t 0 = [a] -> m [a] forall (f :: * -> *) a. Applicative f => a -> f a pure [] | Bool otherwise = (a -> [a] -> [a]) -> m a -> m [a] -> m [a] forall (f :: * -> *) a b c. Applicative f => (a -> b -> c) -> f a -> f b -> f c liftA2 (:) m a f (t -> m [a] loop (t cnt t -> t -> t forall a. Num a => a -> a -> a - t 1))

replicateM_ :: (Applicative m) => Int -> m a -> m () {-# INLINABLE replicateM_ #-} {-# SPECIALISE replicateM_ :: Int -> IO a -> IO () #-} {-# SPECIALISE replicateM_ :: Int -> Maybe a -> Maybe () #-} replicateM_ :: forall (m :: * -> *) a. Applicative m => Int -> m a -> m () replicateM_ Int cnt0 m a f = Int -> m () forall {t}. (Ord t, Num t) => t -> m () loop Int cnt0 where loop :: t -> m () loop t cnt | t cnt t -> t -> Bool forall a. Ord a => a -> a -> Bool <= t 0 = () -> m () forall (f :: * -> *) a. Applicative f => a -> f a pure () | Bool otherwise = m a f m a -> m () -> m () forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b *> t -> m () loop (t cnt t -> t -> t forall a. Num a => a -> a -> a - t 1)

unless :: (Applicative f) => Bool -> f () -> f () {-# INLINABLE unless #-} {-# SPECIALISE unless :: Bool -> IO () -> IO () #-} {-# SPECIALISE unless :: Bool -> Maybe () -> Maybe () #-} unless :: forall (f :: * -> *). Applicative f => Bool -> f () -> f () unless Bool p f () s = if Bool p then () -> f () forall (f :: * -> *) a. Applicative f => a -> f a pure () else f () s

infixl 4 <$!>

(<$!>) :: Monad m => (a -> b) -> m a -> m b {-# INLINE (<$!>) #-} a -> b f <$!> :: forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b <$!> m a m = do a x <- m a m let z :: b z = a -> b f a x b z b -> m b -> m b seq b -> m b forall (m :: * -> *) a. Monad m => a -> m a return b z

mfilter :: (MonadPlus m) => (a -> Bool) -> m a -> m a {-# INLINABLE mfilter #-} mfilter :: forall (m :: * -> *) a. MonadPlus m => (a -> Bool) -> m a -> m a mfilter a -> Bool p m a ma = do a a <- m a ma if a -> Bool p a a then a -> m a forall (m :: * -> *) a. Monad m => a -> m a return a a else m a forall (m :: * -> *) a. MonadPlus m => m a mzero