1 -----------------------------------------------------------------------------
3 -- Module : Control.Monad.Writer
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)
8 -- Maintainer : libraries@haskell.org
9 -- Stability : experimental
10 -- Portability : non-portable ( requires mulit-parameter type classes,
11 -- requires functional dependencies )
13 -- The MonadWriter class.
15 -- Inspired by the paper
16 -- \em{Functional Programming with Overloading and
17 -- Higher-Order Polymorphism},
18 -- \A[HREF="http://www.cse.ogi.edu/~mpj"]{Mark P Jones},
19 -- Advanced School of Functional Programming, 1995.}
20 -----------------------------------------------------------------------------
22 module Control.Monad.Writer (
35 module Control.Monad.Monoid,
36 module Control.Monad.Fix,
37 module Control.Monad.Trans,
43 import Control.Monad.Monoid
44 import Control.Monad.Fix
45 import Control.Monad.Trans
46 import Control.Monad.Reader
48 -- ---------------------------------------------------------------------------
51 -- tell is like tell on the MUD's it shouts to monad
52 -- what you want to be heard. The monad carries this 'packet'
53 -- upwards, merging it if needed (hence the Monoid requirement)}
55 -- listen listens to a monad acting, and returns what the monad "said".
57 -- pass lets you provide a writer transformer which changes internals of
58 -- the written object.
60 class (Monoid w, Monad m) => MonadWriter w m | m -> w where
62 listen :: m a -> m (a, w)
63 pass :: m (a, w -> w) -> m a
65 listens :: (MonadWriter w m) => (w -> w) -> m a -> m (a, w)
70 censor :: (MonadWriter w m) => (w -> w) -> m a -> m a
71 censor f m = pass $ do
75 -- ---------------------------------------------------------------------------
76 -- Our parameterizable writer monad
78 newtype Writer w a = Writer { runWriter :: (a, w) }
81 instance Functor (Writer w) where
82 fmap f m = Writer $ let (a, w) = runWriter m in (f a, w)
84 instance (Monoid w) => Monad (Writer w) where
85 return a = Writer (a, mempty)
86 m >>= k = Writer $ let
88 (b, w') = runWriter (k a)
89 in (b, w `mappend` w')
91 instance (Monoid w) => MonadFix (Writer w) where
92 mfix m = Writer $ let (a, w) = runWriter (m a) in (a, w)
94 instance (Monoid w) => MonadWriter w (Writer w) where
95 tell w = Writer ((), w)
96 listen m = Writer $ let (a, w) = runWriter m in ((a, w), w)
97 pass m = Writer $ let ((a, f), w) = runWriter m in (a, f w)
100 execWriter :: Writer w a -> w
101 execWriter m = snd (runWriter m)
103 mapWriter :: ((a, w) -> (b, w')) -> Writer w a -> Writer w' b
104 mapWriter f m = Writer $ f (runWriter m)
106 -- ---------------------------------------------------------------------------
107 -- Our parameterizable writer monad, with an inner monad
109 newtype WriterT w m a = WriterT { runWriterT :: m (a, w) }
112 instance (Monad m) => Functor (WriterT w m) where
113 fmap f m = WriterT $ do
114 (a, w) <- runWriterT m
117 instance (Monoid w, Monad m) => Monad (WriterT w m) where
118 return a = WriterT $ return (a, mempty)
119 m >>= k = WriterT $ do
120 (a, w) <- runWriterT m
121 (b, w') <- runWriterT (k a)
122 return (b, w `mappend` w')
123 fail msg = WriterT $ fail msg
125 instance (Monoid w, MonadPlus m) => MonadPlus (WriterT w m) where
126 mzero = WriterT mzero
127 m `mplus` n = WriterT $ runWriterT m `mplus` runWriterT n
129 instance (Monoid w, MonadFix m) => MonadFix (WriterT w m) where
130 mfix m = WriterT $ mfix $ \ ~(a, _) -> runWriterT (m a)
132 instance (Monoid w, Monad m) => MonadWriter w (WriterT w m) where
133 tell w = WriterT $ return ((), w)
134 listen m = WriterT $ do
135 (a, w) <- runWriterT m
137 pass m = WriterT $ do
138 ((a, f), w) <- runWriterT m
141 instance (Monoid w) => MonadTrans (WriterT w) where
142 lift m = WriterT $ do
146 instance (Monoid w, MonadIO m) => MonadIO (WriterT w m) where
147 liftIO = lift . liftIO
149 instance (Monoid w, MonadReader r m) => MonadReader r (WriterT w m) where
151 local f m = WriterT $ local f (runWriterT m)
154 execWriterT :: Monad m => WriterT w m a -> m w
156 (_, w) <- runWriterT m
159 mapWriterT :: (m (a, w) -> n (b, w')) -> WriterT w m a -> WriterT w' n b
160 mapWriterT f m = WriterT $ f (runWriterT m)
162 -- ---------------------------------------------------------------------------
163 -- MonadWriter instances for other monad transformers
165 instance (MonadWriter w m) => MonadWriter w (ReaderT r m) where
167 listen m = ReaderT $ \w -> listen (runReaderT m w)
168 pass m = ReaderT $ \w -> pass (runReaderT m w)