Control.Monad.Trans.MultiWriter.Lazy

The multi-valued version of mtl's Writer / WriterT

MultiWriterT

newtype MultiWriterT x m a

A Writer transformer monad patameterized by:

• x - The list of types that can be written (Monoid instances).
• m - The inner monad.

MultiWriterT corresponds to mtl's WriterT, but can contain a heterogenous list of types.

This heterogenous list is represented using Types.Data.List, i.e:

• '[] - The empty list,
• a ': b - A list where a is an arbitrary type and b is the rest list.

For example,

MultiWriterT '[Int, Bool] :: (* -> *) -> (* -> *)

is a Writer transformer containing the types [Int, Bool].

Constructors

MultiWriterT

Fields

runMultiWriterTRaw :: StateT (HList x) m a

Instances

MonadBase b m => MonadBase b (MultiWriterT c m)

MonadBaseControl b m => MonadBaseControl b (MultiWriterT c m)

MonadState s m => MonadState s (MultiWriterT c m)

MonadWriter w m => MonadWriter w (MultiWriterT c m)

(Monad m, ContainsType a c, Monoid a) => MonadMultiWriter a (MultiWriterT c m)

MonadTrans (MultiWriterT x)

MonadTransControl (MultiWriterT c)

Monad m => Monad (MultiWriterT x m)

Functor f => Functor (MultiWriterT x f)

MonadFix m => MonadFix (MultiWriterT w m)

(Applicative m, Monad m) => Applicative (MultiWriterT x m)

(Functor m, Applicative m, MonadPlus m) => Alternative (MultiWriterT c m)

MonadPlus m => MonadPlus (MultiWriterT c m)

MonadIO m => MonadIO (MultiWriterT c m)

type StT (MultiWriterT c) a = (a, HList c)

type StM (MultiWriterT c m) a = ComposeSt (MultiWriterT c) m a

type MultiWriterTNull = MultiWriterT `[]`

A MultiWriter transformer carrying an empty state.

type MultiWriter x a = MultiWriterT x Identity a

MonadMultiWriter class

class (Monad m, Monoid a) => MonadMultiWriter a m where

Methods

mTell :: a -> m ()

Instances

(MonadTrans t, Monad (t m), MonadMultiWriter a m) => MonadMultiWriter a (t m)

(Monad m, ContainsType a c, Monoid a) => MonadMultiWriter a (MultiWriterT c m)

(Monad m, ContainsType a c, Monoid a) => MonadMultiWriter a (MultiWriterT c m)

(Monad m, ContainsType a w, Monoid a) => MonadMultiWriter a (MultiRWST r w s m)

(Monad m, ContainsType a w, Monoid a) => MonadMultiWriter a (MultiRWST r w s m)

run-functions

runMultiWriterT :: (Monoid (HList w), Functor m) => MultiWriterT w m a -> m (a, HList w)

runMultiWriterTAW :: (Monoid (HList w), Functor m) => MultiWriterT w m a -> m (a, HList w)

runMultiWriterTWA :: (Monoid (HList w), Monad m) => MultiWriterT w m a -> m (HList w, a)

runMultiWriterTW :: (Monoid (HList w), Monad m) => MultiWriterT w m a -> m (HList w)

runMultiWriterTNil :: Monad m => MultiWriterT `[]` m a -> m a

runMultiWriterTNil_ :: Functor m => MultiWriterT `[]` m a -> m ()

with-functions (single Writer)

withMultiWriter :: (Monoid w, Monad m) => MultiWriterT (w : ws) m a -> MultiWriterT ws m (a, w)

withMultiWriterAW :: (Monoid w, Monad m) => MultiWriterT (w : ws) m a -> MultiWriterT ws m (a, w)

withMultiWriterWA :: (Monoid w, Monad m) => MultiWriterT (w : ws) m a -> MultiWriterT ws m (w, a)

withMultiWriterW :: (Monoid w, Monad m) => MultiWriterT (w : ws) m a -> MultiWriterT ws m w

with-functions (multiple Writers)

withMultiWriters :: forall w1 w2 m a. (Monoid (HList w1), Monad m, HInit w1) => MultiWriterT (Append w1 w2) m a -> MultiWriterT w2 m (a, HList w1)

withMultiWritersAW :: forall w1 w2 m a. (Monoid (HList w1), Monad m, HInit w1) => MultiWriterT (Append w1 w2) m a -> MultiWriterT w2 m (a, HList w1)

withMultiWritersWA :: forall w1 w2 m a. (Monoid (HList w1), Monad m, HInit w1) => MultiWriterT (Append w1 w2) m a -> MultiWriterT w2 m (HList w1, a)

withMultiWritersW :: forall w1 w2 m a. (Monoid (HList w1), Monad m, HInit w1) => MultiWriterT (Append w1 w2) m a -> MultiWriterT w2 m (HList w1)

inflate-function (run WriterT in MultiWriterT)

inflateWriter :: (Monad m, Monoid w, ContainsType w ws) => WriterT w m a -> MultiWriterT ws m a

other functions

mapMultiWriterT :: (m (a, HList w) -> m' (a', HList w)) -> MultiWriterT w m a -> MultiWriterT w m' a'

Map both the return value and the state of a computation using the given function.

mGetRaw :: Monad m => MultiWriterT a m (HList a)

A raw extractor of the contained HList (i.e. the complete state).

mPutRaw :: Monad m => HList s -> MultiWriterT s m ()