Control/Monad/List.hs

   1 -----------------------------------------------------------------------------
   2 -- |
   3 -- Module      :  Control.Monad.List
   4 -- Copyright   :  (c) Andy Gill 2001,
   5 --                (c) Oregon Graduate Institute of Science and Technology, 2001
   6 -- License     :  BSD-style (see the file libraries/core/LICENSE)
   7 --
   8 -- Maintainer  :  libraries@haskell.org
   9 -- Stability   :  experimental
  10 -- Portability :  non-portable ( requires mulit-parameter type classes )
  11 --
  12 -- $Id: List.hs,v 1.2 2002/04/24 16:31:38 simonmar Exp $
  13 --
  14 -- The List monad.
  15 --
  16 -----------------------------------------------------------------------------
  17
  18 module Control.Monad.List (
  19         ListT(..),
  20         runListT,
  21         mapListT,
  22         module Control.Monad,
  23         module Control.Monad.Trans,
  24   ) where
  25
  26 import Prelude
  27
  28 import Control.Monad
  29 import Control.Monad.Trans
  30 import Control.Monad.Reader
  31 import Control.Monad.State
  32 import Control.Monad.Cont
  33 import Control.Monad.Error
  34
  35 -- ---------------------------------------------------------------------------
  36 -- Our parameterizable list monad, with an inner monad
  37
  38 newtype ListT m a = ListT { runListT :: m [a] }
  39
  40 instance (Monad m) => Functor (ListT m) where
  41         fmap f m = ListT $ do
  42                 a <- runListT m
  43                 return (map f a)
  44
  45 instance (Monad m) => Monad (ListT m) where
  46         return a = ListT $ return [a]
  47         m >>= k  = ListT $ do
  48                 a <- runListT m
  49                 b <- mapM (runListT . k) a
  50                 return (concat b)
  51         fail _ = ListT $ return []
  52
  53 instance (Monad m) => MonadPlus (ListT m) where
  54         mzero       = ListT $ return []
  55         m `mplus` n = ListT $ do
  56                 a <- runListT m
  57                 b <- runListT n
  58                 return (a ++ b)
  59
  60 instance MonadTrans ListT where
  61         lift m = ListT $ do
  62                 a <- m
  63                 return [a]
  64
  65 instance (MonadIO m) => MonadIO (ListT m) where
  66         liftIO = lift . liftIO
  67
  68 instance (MonadReader s m) => MonadReader s (ListT m) where
  69         ask       = lift ask
  70         local f m = ListT $ local f (runListT m)
  71
  72 instance (MonadState s m) => MonadState s (ListT m) where
  73         get = lift get
  74         put = lift . put
  75
  76 instance (MonadCont m) => MonadCont (ListT m) where
  77         callCC f = ListT $
  78                 callCC $ \c ->
  79                 runListT (f (\a -> ListT $ c [a]))
  80
  81 instance (MonadError e m) => MonadError e (ListT m) where
  82         throwError       = lift . throwError
  83         m `catchError` h = ListT $ runListT m
  84                 `catchError` \e -> runListT (h e)
  85
  86 mapListT :: (m [a] -> n [b]) -> ListT m a -> ListT n b
  87 mapListT f m = ListT $ f (runListT m)