| Safe Haskell | Safe | 
|---|---|
| Language | Haskell2010 | 
Writer
Contents
Synopsis
- type Writer w = WriterT w Identity
 - runWriter :: Monoid w => Writer w a -> (a, w)
 - execWriter :: Monoid w => Writer w a -> w
 - mapWriter :: (Monoid w, Monoid w') => ((a, w) -> (b, w')) -> Writer w a -> Writer w' b
 - data WriterT w (m :: * -> *) a
 - writerT :: (Functor m, Monoid w) => m (a, w) -> WriterT w m a
 - runWriterT :: Monoid w => WriterT w m a -> m (a, w)
 - execWriterT :: (Monad m, Monoid w) => WriterT w m a -> m w
 - mapWriterT :: (Monad n, Monoid w, Monoid w') => (m (a, w) -> n (b, w')) -> WriterT w m a -> WriterT w' n b
 - class (Monoid w, Monad m) => MonadWriter w (m :: * -> *) | m -> w where
 - listens :: MonadWriter w m => (w -> b) -> m a -> m (a, b)
 - censor :: MonadWriter w m => (w -> w) -> m a -> m a
 
Writer
runWriter :: Monoid w => Writer w a -> (a, w) #
Unwrap a writer computation as a (result, output) pair.
 (The inverse of writer.)
execWriter :: Monoid w => Writer w a -> w #
Extract the output from a writer computation.
execWriterm =snd(runWriterm)
WriterT
data WriterT w (m :: * -> *) a #
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.
Instances
| MonadTrans (WriterT w) | |
Defined in Control.Monad.Trans.Writer.CPS.Internal  | |
| Monad m => Monad (WriterT w m) | |
| Functor m => Functor (WriterT w m) | |
| MonadFix m => MonadFix (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.CPS.Internal  | |
| MonadFail m => MonadFail (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.CPS.Internal  | |
| (Functor m, Monad m) => Applicative (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.CPS.Internal  | |
| (Functor m, MonadPlus m) => Alternative (WriterT w m) | |
| (Functor m, MonadPlus m) => MonadPlus (WriterT w m) | |
| MonadIO m => MonadIO (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.CPS.Internal  | |
writerT :: (Functor m, Monoid w) => m (a, w) -> WriterT w m a #
The WriterT constructor is deliberately not exported in the CPS module to avoid exposing the hidden state w. writerT provides a safe way to construct a WriterT with the same api as the original WriterT.
runWriterT :: Monoid w => WriterT w m a -> m (a, w) #
Unwrap a writer computation.
execWriterT :: (Monad m, Monoid w) => WriterT w m a -> m w #
Extract the output from a writer computation.
execWriterTm =liftMsnd(runWriterTm)
mapWriterT :: (Monad n, Monoid w, Monoid w') => (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)
MonadWriter
class (Monoid w, Monad m) => MonadWriter w (m :: * -> *) | m -> w where #
Methods
 embeds a simple writer action.writer (a,w)
 is an action that produces the output tell ww.
 is an action that executes the action listen mm and adds
 its output to the value of the computation.
pass :: m (a, w -> w) -> m a #
 is an action that executes the action pass mm, which
 returns a value and a function, and returns the value, applying
 the function to the output.
Instances
| MonadWriter w m => MonadWriter w (MaybeT m) | |
| Monoid w => MonadWriter w ((,) w) | NOTE: This instance is only defined for  Since: mtl-2.2.2  | 
| (Functor m, MonadWriter e m) => MonadWriter e (Free m) | |
| (Monoid w, Monad m) => MonadWriter w (WriterT w m) | |
| (Monoid w, Monad m) => MonadWriter w (WriterT w m) | |
| MonadWriter w m => MonadWriter w (StateT s m) | |
| MonadWriter w m => MonadWriter w (StateT s m) | |
| MonadWriter w m => MonadWriter w (IdentityT m) | |
| MonadWriter w m => MonadWriter w (ExceptT e m) | Since: mtl-2.2  | 
| (Error e, MonadWriter w m) => MonadWriter w (ErrorT e m) | |
| (Functor f, MonadWriter w m) => MonadWriter w (FreeT f m) | |
| MonadWriter w m => MonadWriter w (ReaderT r m) | |
| (Monoid w, Monad m) => MonadWriter w (RWST r w s m) | |
| (Monoid w, Monad m) => MonadWriter w (RWST r w s m) | |
listens :: MonadWriter w m => (w -> b) -> m a -> m (a, b) #