1 {-# OPTIONS -fno-implicit-prelude #-}
2 -----------------------------------------------------------------------------
4 -- Module : Control.Monad
5 -- Copyright : (c) The University of Glasgow 2001
6 -- License : BSD-style (see the file libraries/base/LICENSE)
8 -- Maintainer : libraries@haskell.org
9 -- Stability : provisional
10 -- Portability : portable
12 -----------------------------------------------------------------------------
15 ( MonadPlus ( -- class context: Monad
16 mzero -- :: (MonadPlus m) => m a
17 , mplus -- :: (MonadPlus m) => m a -> m a -> m a
19 , join -- :: (Monad m) => m (m a) -> m a
20 , guard -- :: (MonadPlus m) => Bool -> m ()
21 , when -- :: (Monad m) => Bool -> m () -> m ()
22 , unless -- :: (Monad m) => Bool -> m () -> m ()
23 , ap -- :: (Monad m) => m (a -> b) -> m a -> m b
24 , msum -- :: (MonadPlus m) => [m a] -> m a
25 , filterM -- :: (Monad m) => (a -> m Bool) -> [a] -> m [a]
26 , mapAndUnzipM -- :: (Monad m) => (a -> m (b,c)) -> [a] -> m ([b], [c])
27 , zipWithM -- :: (Monad m) => (a -> b -> m c) -> [a] -> [b] -> m [c]
28 , zipWithM_ -- :: (Monad m) => (a -> b -> m c) -> [a] -> [b] -> m ()
29 , foldM -- :: (Monad m) => (a -> b -> m a) -> a -> [b] -> m a
31 , liftM -- :: (Monad m) => (a -> b) -> (m a -> m b)
32 , liftM2 -- :: (Monad m) => (a -> b -> c) -> (m a -> m b -> m c)
37 , Monad((>>=), (>>), return, fail)
40 , mapM -- :: (Monad m) => (a -> m b) -> [a] -> m [b]
41 , mapM_ -- :: (Monad m) => (a -> m b) -> [a] -> m ()
42 , sequence -- :: (Monad m) => [m a] -> m [a]
43 , sequence_ -- :: (Monad m) => [m a] -> m ()
44 , (=<<) -- :: (Monad m) => (a -> m b) -> m a -> m b
49 #ifdef __GLASGOW_HASKELL__
56 -- -----------------------------------------------------------------------------
57 -- Prelude monad functions
59 {-# SPECIALISE (=<<) :: (a -> [b]) -> [a] -> [b] #-}
60 (=<<) :: Monad m => (a -> m b) -> m a -> m b
63 sequence :: Monad m => [m a] -> m [a]
64 {-# INLINE sequence #-}
65 sequence ms = foldr k (return []) ms
67 k m m' = do { x <- m; xs <- m'; return (x:xs) }
69 sequence_ :: Monad m => [m a] -> m ()
70 {-# INLINE sequence_ #-}
71 sequence_ ms = foldr (>>) (return ()) ms
73 mapM :: Monad m => (a -> m b) -> [a] -> m [b]
75 mapM f as = sequence (map f as)
77 mapM_ :: Monad m => (a -> m b) -> [a] -> m ()
79 mapM_ f as = sequence_ (map f as)
81 -- -----------------------------------------------------------------------------
82 -- Monadic classes: MonadPlus
84 class Monad m => MonadPlus m where
86 mplus :: m a -> m a -> m a
88 instance MonadPlus [] where
92 instance MonadPlus Maybe where
95 Nothing `mplus` ys = ys
98 -- -----------------------------------------------------------------------------
99 -- Functions mandated by the Prelude
101 guard :: (MonadPlus m) => Bool -> m ()
102 guard True = return ()
105 -- This subsumes the list-based filter function.
107 filterM :: (Monad m) => (a -> m Bool) -> [a] -> m [a]
108 filterM _ [] = return []
109 filterM p (x:xs) = do
112 return (if flg then x:ys else ys)
114 -- This subsumes the list-based concat function.
116 msum :: MonadPlus m => [m a] -> m a
118 msum = foldr mplus mzero
120 -- -----------------------------------------------------------------------------
121 -- Other monad functions
123 join :: (Monad m) => m (m a) -> m a
126 mapAndUnzipM :: (Monad m) => (a -> m (b,c)) -> [a] -> m ([b], [c])
127 mapAndUnzipM f xs = sequence (map f xs) >>= return . unzip
129 zipWithM :: (Monad m) => (a -> b -> m c) -> [a] -> [b] -> m [c]
130 zipWithM f xs ys = sequence (zipWith f xs ys)
132 zipWithM_ :: (Monad m) => (a -> b -> m c) -> [a] -> [b] -> m ()
133 zipWithM_ f xs ys = sequence_ (zipWith f xs ys)
135 foldM :: (Monad m) => (a -> b -> m a) -> a -> [b] -> m a
136 foldM _ a [] = return a
137 foldM f a (x:xs) = f a x >>= \fax -> foldM f fax xs
139 unless :: (Monad m) => Bool -> m () -> m ()
140 unless p s = if p then return () else s
142 when :: (Monad m) => Bool -> m () -> m ()
143 when p s = if p then s else return ()
145 ap :: (Monad m) => m (a -> b) -> m a -> m b
148 liftM :: (Monad m) => (a1 -> r) -> m a1 -> m r
149 liftM2 :: (Monad m) => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r
150 liftM3 :: (Monad m) => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
151 liftM4 :: (Monad m) => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r
152 liftM5 :: (Monad m) => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r
154 liftM f m1 = do { x1 <- m1; return (f x1) }
155 liftM2 f m1 m2 = do { x1 <- m1; x2 <- m2; return (f x1 x2) }
156 liftM3 f m1 m2 m3 = do { x1 <- m1; x2 <- m2; x3 <- m3; return (f x1 x2 x3) }
157 liftM4 f m1 m2 m3 m4 = do { x1 <- m1; x2 <- m2; x3 <- m3; x4 <- m4; return (f x1 x2 x3 x4) }
158 liftM5 f m1 m2 m3 m4 m5 = do { x1 <- m1; x2 <- m2; x3 <- m3; x4 <- m4; x5 <- m5; return (f x1 x2 x3 x4 x5) }