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
30 , foldM_ -- :: (Monad m) => (a -> b -> m a) -> a -> [b] -> m ()
32 , liftM -- :: (Monad m) => (a -> b) -> (m a -> m b)
33 , liftM2 -- :: (Monad m) => (a -> b -> c) -> (m a -> m b -> m c)
38 , Monad((>>=), (>>), return, fail)
41 , mapM -- :: (Monad m) => (a -> m b) -> [a] -> m [b]
42 , mapM_ -- :: (Monad m) => (a -> m b) -> [a] -> m ()
43 , sequence -- :: (Monad m) => [m a] -> m [a]
44 , sequence_ -- :: (Monad m) => [m a] -> m ()
45 , replicateM -- :: (Monad m) => Int -> m a -> m [a]
46 , replicateM_ -- :: (Monad m) => Int -> m a -> m ()
47 , (=<<) -- :: (Monad m) => (a -> m b) -> m a -> m b
52 #ifdef __GLASGOW_HASKELL__
60 -- -----------------------------------------------------------------------------
61 -- Prelude monad functions
63 {-# SPECIALISE (=<<) :: (a -> [b]) -> [a] -> [b] #-}
64 (=<<) :: Monad m => (a -> m b) -> m a -> m b
67 sequence :: Monad m => [m a] -> m [a]
68 {-# INLINE sequence #-}
69 sequence ms = foldr k (return []) ms
71 k m m' = do { x <- m; xs <- m'; return (x:xs) }
73 sequence_ :: Monad m => [m a] -> m ()
74 {-# INLINE sequence_ #-}
75 sequence_ ms = foldr (>>) (return ()) ms
77 mapM :: Monad m => (a -> m b) -> [a] -> m [b]
79 mapM f as = sequence (map f as)
81 mapM_ :: Monad m => (a -> m b) -> [a] -> m ()
83 mapM_ f as = sequence_ (map f as)
86 -- -----------------------------------------------------------------------------
87 -- Monadic classes: MonadPlus
89 class Monad m => MonadPlus m where
91 mplus :: m a -> m a -> m a
93 instance MonadPlus [] where
97 instance MonadPlus Maybe where
100 Nothing `mplus` ys = ys
103 -- -----------------------------------------------------------------------------
104 -- Functions mandated by the Prelude
106 guard :: (MonadPlus m) => Bool -> m ()
107 guard True = return ()
110 -- This subsumes the list-based filter function.
112 filterM :: (Monad m) => (a -> m Bool) -> [a] -> m [a]
113 filterM _ [] = return []
114 filterM p (x:xs) = do
117 return (if flg then x:ys else ys)
119 -- This subsumes the list-based concat function.
121 msum :: MonadPlus m => [m a] -> m a
123 msum = foldr mplus mzero
125 -- -----------------------------------------------------------------------------
126 -- Other monad functions
128 join :: (Monad m) => m (m a) -> m a
131 mapAndUnzipM :: (Monad m) => (a -> m (b,c)) -> [a] -> m ([b], [c])
132 mapAndUnzipM f xs = sequence (map f xs) >>= return . unzip
134 zipWithM :: (Monad m) => (a -> b -> m c) -> [a] -> [b] -> m [c]
135 zipWithM f xs ys = sequence (zipWith f xs ys)
137 zipWithM_ :: (Monad m) => (a -> b -> m c) -> [a] -> [b] -> m ()
138 zipWithM_ f xs ys = sequence_ (zipWith f xs ys)
140 foldM :: (Monad m) => (a -> b -> m a) -> a -> [b] -> m a
141 foldM _ a [] = return a
142 foldM f a (x:xs) = f a x >>= \fax -> foldM f fax xs
144 foldM_ :: (Monad m) => (a -> b -> m a) -> a -> [b] -> m ()
145 foldM_ f a xs = foldM f a xs >> return ()
147 replicateM :: (Monad m) => Int -> m a -> m [a]
148 replicateM n x = sequence (replicate n x)
150 replicateM_ :: (Monad m) => Int -> m a -> m ()
151 replicateM_ n x = sequence_ (replicate n x)
153 unless :: (Monad m) => Bool -> m () -> m ()
154 unless p s = if p then return () else s
156 when :: (Monad m) => Bool -> m () -> m ()
157 when p s = if p then s else return ()
159 ap :: (Monad m) => m (a -> b) -> m a -> m b
162 liftM :: (Monad m) => (a1 -> r) -> m a1 -> m r
163 liftM2 :: (Monad m) => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r
164 liftM3 :: (Monad m) => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
165 liftM4 :: (Monad m) => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r
166 liftM5 :: (Monad m) => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r
168 liftM f m1 = do { x1 <- m1; return (f x1) }
169 liftM2 f m1 m2 = do { x1 <- m1; x2 <- m2; return (f x1 x2) }
170 liftM3 f m1 m2 m3 = do { x1 <- m1; x2 <- m2; x3 <- m3; return (f x1 x2 x3) }
171 liftM4 f m1 m2 m3 m4 = do { x1 <- m1; x2 <- m2; x3 <- m3; x4 <- m4; return (f x1 x2 x3 x4) }
172 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) }