DeepControl.Monad.Writer

This module is just a concise mimic for Reader Monad in mtl(monad-transformer-library). The qualifier "concise" means that this module doesn't make no attempt to transform functions of any kind of Monad automatically. So when making some new data type of WriterT, you have to manually define involved Monad instances, for example MonadError, by making use of the transformation functions such as trans, trans2, etc. Admittedly it is tedious though, you can deeply understand monad-transformation mechanism instead.

Documentation

class (Monoid w, Monad m) => MonadWriter w m | m -> w where

Minimal complete definition

(writer | tell), listen, pass

Methods

writer :: (a, w) -> m a

writer (a,w) embeds a simple writer action.

tell :: w -> m ()

tell w is an action that produces the output w.

listen :: m a -> m (a, w)

listen m is an action that executes the action m and adds its output to the value of the computation.

pass :: m (a, w -> w) -> m a

pass m is an action that executes the action m, 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)

MonadWriter w m => MonadWriter w (IdentityT m)

Monoid w => MonadWriter w (Writer w)

(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 (ReaderT r m)

MonadWriter w m => MonadWriter w (ExceptT e m)

(Error e, MonadWriter w m) => MonadWriter w (ErrorT e m)

(Monoid w, Monad m) => MonadWriter w (WriterT w m)

Monoid w => MonadWriter w (RWS r w s)

(Monoid w, Monad m1, Monad2 m2) => MonadWriter w (WriterT2 w m1 m2)

(Monoid w, Monad m) => MonadWriter w (RWST r w s m)

(Monoid w, Monad m) => MonadWriter w (RWST r w s m)

(Monoid w, Monad m) => MonadWriter w (RWST r w s m)

(Monoid w, Monad m1, Monad2 m2, Monad3 m3) => MonadWriter w (WriterT3 w m1 m2 m3)

(Monoid w, Monad m1, Monad2 m2) => MonadWriter w (RWST2 r w s m1 m2)

(Monoid w, Monad m1, Monad2 m2, Monad3 m3) => MonadWriter w (RWST3 r w s m1 m2 m3)

listens :: MonadWriter w m => (w -> b) -> m a -> m (a, b)

censor :: MonadWriter w m => (w -> w) -> m a -> m a

Level-0

newtype Writer w a

Constructors

Writer

Fields

runWriter :: (a, w)

Instances

Monoid w => MonadWriter w (Writer w)

Monoid w => Monad (Writer w)

Functor (Writer w)

Monoid w => Applicative (Writer w)

Monoid w => Monad5 (Writer w)

Monoid w => Monad4 (Writer w)

Monoid w => Monad3 (Writer w)

Monoid w => Monad2 (Writer w)

execWriter :: Writer w a -> w

mapWriter :: ((a, w) -> (b, w')) -> Writer w a -> Writer w' b

Level-1

newtype WriterT w m a

Constructors

WriterT

Fields

runWriterT :: m (a, w)

Instances

(Monoid w, Monad m) => MonadWriter w (WriterT w m)

Monoid w => MonadTrans (WriterT w)

(Monoid w, Monad m) => Monad (WriterT w m)

Monad m => Functor (WriterT w m)

(Monoid w, Monad m) => Applicative (WriterT w m)

(Monoid w, MonadIO m, Monad m) => MonadIO (WriterT w m)

execWriterT :: Monad m => WriterT w m a -> m w

mapWriterT :: (m (a, w) -> n (b, w')) -> WriterT w m a -> WriterT w' n b

liftCatch :: Catch e m (a, w) -> Catch e (WriterT w m) a

Level-2

newtype WriterT2 w m1 m2 a

Constructors

WriterT2

Fields

runWriterT2 :: m1 (m2 (a, w))

Instances

(Monoid w, Monad m1, Monad2 m2) => MonadWriter w (WriterT2 w m1 m2)

Monoid w => MonadTrans2 (WriterT2 w)

(Monoid w, Monad m1, Monad2 m2) => Monad (WriterT2 w m1 m2)

(Monad m1, Monad2 m2) => Functor (WriterT2 w m1 m2)

(Monoid w, Monad m1, Monad2 m2) => Applicative (WriterT2 w m1 m2)

(Monoid w, MonadIO m1, Monad m1, Monad2 m2) => MonadIO (WriterT2 w m1 m2)

execWriterT2 :: (Monad m1, Monad2 m2) => WriterT2 w m1 m2 a -> m1 (m2 w)

mapWriterT2 :: (m1 (m2 (a, w)) -> n1 (n2 (b, w'))) -> WriterT2 w m1 m2 a -> WriterT2 w' n1 n2 b

Level-3

newtype WriterT3 w m1 m2 m3 a

Constructors

WriterT3

Fields

runWriterT3 :: m1 (m2 (m3 (a, w)))

Instances

(Monoid w, Monad m1, Monad2 m2, Monad3 m3) => MonadWriter w (WriterT3 w m1 m2 m3)

Monoid w => MonadTrans3 (WriterT3 w)

(Monoid w, Monad m1, Monad2 m2, Monad3 m3) => Monad (WriterT3 w m1 m2 m3)

(Monad m1, Monad2 m2, Monad3 m3) => Functor (WriterT3 w m1 m2 m3)

(Monoid w, Monad m1, Monad2 m2, Monad3 m3) => Applicative (WriterT3 w m1 m2 m3)

(Monoid w, MonadIO m1, Monad m1, Monad2 m2, Monad3 m3) => MonadIO (WriterT3 w m1 m2 m3)

execWriterT3 :: (Monad m1, Monad2 m2, Monad3 m3) => WriterT3 w m1 m2 m3 a -> m1 (m2 (m3 w))

mapWriterT3 :: (m1 (m2 (m3 (a, w))) -> n1 (n2 (n3 (b, w')))) -> WriterT3 w m1 m2 m3 a -> WriterT3 w' n1 n2 n3 b