| Copyright | (c) Andy Gill 2001 (c) Oregon Graduate Institute of Science and Technology 2001 |
|---|---|
| License | BSD-style (see the file LICENSE) |
| Maintainer | R.Paterson@city.ac.uk |
| Stability | experimental |
| Portability | portable |
| Safe Haskell | Safe |
| Language | Haskell98 |
Control.Monad.Trans.Writer.Lazy
Description
The lazy WriterT monad transformer, which adds collection of
outputs (such as a count or string output) to a given monad.
This monad transformer provides only limited access to the output during the computation. For more general access, use Control.Monad.Trans.State instead.
This version builds its output lazily; for a strict version with the same interface, see Control.Monad.Trans.Writer.Strict.
- type Writer w = WriterT w Identity
- writer :: Monad m => (a, w) -> WriterT w m a
- runWriter :: Writer w a -> (a, w)
- execWriter :: Writer w a -> w
- mapWriter :: ((a, w) -> (b, w')) -> Writer w a -> Writer w' b
- newtype WriterT w m a = WriterT {
- runWriterT :: m (a, w)
- execWriterT :: Monad m => WriterT w m a -> m w
- mapWriterT :: (m (a, w) -> n (b, w')) -> WriterT w m a -> WriterT w' n b
- tell :: Monad m => w -> WriterT w m ()
- listen :: Monad m => WriterT w m a -> WriterT w m (a, w)
- listens :: Monad m => (w -> b) -> WriterT w m a -> WriterT w m (a, b)
- pass :: Monad m => WriterT w m (a, w -> w) -> WriterT w m a
- censor :: Monad m => (w -> w) -> WriterT w m a -> WriterT w m a
- liftCallCC :: Monoid w => CallCC m (a, w) (b, w) -> CallCC (WriterT w m) a b
- liftCatch :: Catch e m (a, w) -> Catch e (WriterT w m) a
The Writer monad
writer :: Monad m => (a, w) -> WriterT w m a #
Construct a writer computation from a (result, output) pair.
(The inverse of runWriter.)
runWriter :: Writer w a -> (a, w) #
Unwrap a writer computation as a (result, output) pair.
(The inverse of writer.)
execWriter :: Writer w a -> w #
Extract the output from a writer computation.
execWriterm =snd(runWriterm)
The WriterT monad transformer
A writer monad parameterized by:
w- the output to accumulate.m- The inner monad.
The return function produces the output mempty, while >>=
combines the outputs of the subcomputations using mappend.
Constructors
| WriterT | |
Fields
| |
Instances
| Monoid w => MonadTrans (WriterT w) # | |
| (Monoid w, Monad m) => Monad (WriterT w m) # | |
| Functor m => Functor (WriterT w m) # | |
| (Monoid w, MonadFix m) => MonadFix (WriterT w m) # | |
| (Monoid w, MonadFail m) => MonadFail (WriterT w m) # | |
| (Monoid w, Applicative m) => Applicative (WriterT w m) # | |
| Foldable f => Foldable (WriterT w f) # | |
| Traversable f => Traversable (WriterT w f) # | |
| (Eq w, Eq1 m) => Eq1 (WriterT w m) # | |
| (Ord w, Ord1 m) => Ord1 (WriterT w m) # | |
| (Read w, Read1 m) => Read1 (WriterT w m) # | |
| (Show w, Show1 m) => Show1 (WriterT w m) # | |
| (Monoid w, MonadZip m) => MonadZip (WriterT w m) # | |
| (Monoid w, MonadIO m) => MonadIO (WriterT w m) # | |
| (Monoid w, Alternative m) => Alternative (WriterT w m) # | |
| (Monoid w, MonadPlus m) => MonadPlus (WriterT w m) # | |
| (Eq w, Eq1 m, Eq a) => Eq (WriterT w m a) # | |
| (Ord w, Ord1 m, Ord a) => Ord (WriterT w m a) # | |
| (Read w, Read1 m, Read a) => Read (WriterT w m a) # | |
| (Show w, Show1 m, Show a) => Show (WriterT w m a) # | |
execWriterT :: Monad m => WriterT w m a -> m w #
Extract the output from a writer computation.
execWriterTm =liftMsnd(runWriterTm)
mapWriterT :: (m (a, w) -> n (b, w')) -> WriterT w m a -> WriterT w' n b #
Map both the return value and output of a computation using the given function.
runWriterT(mapWriterTf m) = f (runWriterTm)
Writer operations
listen :: Monad m => WriterT w m a -> WriterT w m (a, w) #
listen mm and adds its
output to the value of the computation.
runWriterT(listenm) =liftM(\ (a, w) -> ((a, w), w)) (runWriterTm)
listens :: Monad m => (w -> b) -> WriterT w m a -> WriterT w m (a, b) #
listens f mm and adds
the result of applying f to the output to the value of the computation.
listensf m =liftM(id *** f) (listenm)runWriterT(listensf m) =liftM(\ (a, w) -> ((a, f w), w)) (runWriterTm)
pass :: Monad m => WriterT w m (a, w -> w) -> WriterT w m a #
pass mm, which returns
a value and a function, and returns the value, applying the function
to the output.
runWriterT(passm) =liftM(\ ((a, f), w) -> (a, f w)) (runWriterTm)
censor :: Monad m => (w -> w) -> WriterT w m a -> WriterT w m a #
censor f mm and
applies the function f to its output, leaving the return value
unchanged.
censorf m =pass(liftM(\ x -> (x,f)) m)runWriterT(censorf m) =liftM(\ (a, w) -> (a, f w)) (runWriterTm)