ghc/lib/required/Monad.lhs

   1 %
   2 % (c) The AQUA Project, Glasgow University, 1994-1996
   3 %
   4 \section[Monad]{Module @Monad@}
   5
   6 \begin{code}
   7 {-# OPTIONS -fno-implicit-prelude #-}
   8
   9 module Monad (
  10     Functor(..),
  11     Monad(..), MonadZero(..), MonadPlus(..),
  12
  13     -- Prelude monad functions
  14     accumulate, sequence,
  15     mapM, mapM_, guard, filter, concat, applyM,
  16
  17     -- Standard Monad interface:
  18     join,           -- :: (Monad m) => m (m a) -> m a
  19     mapAndUnzipM,   -- :: (Monad m) => (a -> m (b,c)) -> [a] -> m ([b], [c])
  20     zipWithM,       -- :: (Monad m) => (a -> b -> m c) -> [a] -> [b] -> m [c]
  21     foldM,          -- :: (Monad m) => (a -> b -> m a) -> a -> [b] -> m a
  22     when,           -- :: (Monad m) => Bool -> m () -> m ()
  23     unless,         -- :: (Monad m) => Bool -> m () -> m ()
  24     ap,             -- :: (Monad m) => (m (a -> b)) -> (m a) -> m b
  25     liftM, liftM2,
  26     liftM3, liftM4,
  27     liftM5
  28   ) where
  29
  30 import PrelList
  31 import PrelTup
  32 import PrelBase
  33 \end{code}
  34
  35 %*********************************************************
  36 %*                                                      *
  37 \subsection{Functions mandated by the Prelude}
  38 %*                                                      *
  39 %*********************************************************
  40
  41 \begin{code}
  42 accumulate      :: Monad m => [m a] -> m [a]
  43 accumulate []     = return []
  44 accumulate (m:ms) = do { x <- m; xs <- accumulate ms; return (x:xs) }
  45
  46 sequence        :: Monad m => [m a] -> m ()
  47 sequence        =  foldr (>>) (return ())
  48
  49 mapM            :: Monad m => (a -> m b) -> [a] -> m [b]
  50 mapM f as       =  accumulate (map f as)
  51
  52 mapM_           :: Monad m => (a -> m b) -> [a] -> m ()
  53 mapM_ f as      =  sequence (map f as)
  54
  55 guard           :: MonadZero m => Bool -> m ()
  56 guard p         =  if p then return () else zero
  57
  58 -- This subsumes the list-based filter function.
  59
  60 filter          :: MonadZero m => (a -> Bool) -> m a -> m a
  61 filter p        =  applyM (\x -> if p x then return x else zero)
  62
  63 -- This subsumes the list-based concat function.
  64
  65 concat          :: MonadPlus m => [m a] -> m a
  66 concat          =  foldr (++) zero
  67
  68 applyM          :: Monad m => (a -> m b) -> m a -> m b
  69 applyM f x      =  x >>= f
  70 \end{code}
  71
  72
  73 %*********************************************************
  74 %*                                                      *
  75 \subsection{Other monad functions}
  76 %*                                                      *
  77 %*********************************************************
  78
  79 \begin{code}
  80 join             :: (Monad m) => m (m a) -> m a
  81 join x           = x >>= id
  82
  83 mapAndUnzipM     :: (Monad m) => (a -> m (b,c)) -> [a] -> m ([b], [c])
  84 mapAndUnzipM f xs = accumulate (map f xs) >>= return . unzip
  85
  86 zipWithM         :: (Monad m) => (a -> b -> m c) -> [a] -> [b] -> m [c]
  87 zipWithM f xs ys = accumulate (zipWith f xs ys)
  88
  89 foldM            :: (Monad m) => (a -> b -> m a) -> a -> [b] -> m a
  90 foldM f a []     = return a
  91 foldM f a (x:xs) = f a x >>= \fax -> foldM f fax xs
  92
  93 unless           :: (Monad m) => Bool -> m () -> m ()
  94 unless p s       =  if p then return () else s
  95
  96 when             :: (Monad m) => Bool -> m () -> m ()
  97 when p s         =  if p then s else return ()
  98
  99 ap :: (Monad m) => m (a->b) -> m a -> m b
 100 ap = liftM2 ($)
 101
 102 liftM   :: (Monad m) => (a1 -> r) -> m a1 -> m r
 103 liftM2  :: (Monad m) => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r
 104 liftM3  :: (Monad m) => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
 105 liftM4  :: (Monad m) => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r
 106 liftM5  :: (Monad m) => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r
 107
 108 liftM f m1              = do { x1 <- m1; return (f x1) }
 109 liftM2 f m1 m2          = do { x1 <- m1; x2 <- m2; return (f x1 x2) }
 110 liftM3 f m1 m2 m3       = do { x1 <- m1; x2 <- m2; x3 <- m3; return (f x1 x2 x3) }
 111 liftM4 f m1 m2 m3 m4    = do { x1 <- m1; x2 <- m2; x3 <- m3; x4 <- m4; return (f x1 x2 x3 x4) }
 112 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) }
 113
 114 \end{code}