type Accum w = AccumT w Identity Source

An accumulation monad parameterized by the type w of output to accumulate.

This monad is a more complex extension of both the reader and writer monads. The return function produces the output mempty, while m >>= k uses the output of m both to extend the initial environment of k and to combine with the output of k:

In applications requiring only the ability to accumulate an output and to inspect the output so far, it would be considerably more efficient to use a state monad.

accum :: forall (m :: Type -> Type) w a. Monad m => (w -> (a, w)) -> AccumT w m a Source

Construct an accumulation computation from a (result, output) pair. (The inverse of runAccum.)

runAccum :: Accum w a -> w -> (a, w) Source

Unwrap an accumulation computation as a (result, output) pair. (The inverse of accum.)

execAccum :: Accum w a -> w -> w Source

Extract the output from an accumulation computation.

• execAccum m w = snd (runAccum m w)

evalAccum :: Monoid w => Accum w a -> w -> a Source

Evaluate an accumulation computation with the given initial output history and return the final value, discarding the final output.

• evalAccum m w = fst (runAccum m w)

mapAccum :: ((a, w) -> (b, w)) -> Accum w a -> Accum w b Source

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

• runAccum (mapAccum f m) = f . runAccum m

newtype AccumT w (m :: Type -> Type) a Source

An accumulation monad parameterized by:

• w - the output to accumulate.
• m - The inner monad.

This monad transformer is a more complex extension of both the reader and writer monad transformers. The return function produces the output mempty, while m >>= k uses the output of m both to extend the initial environment of k and to combine with the output of k:

In applications requiring only the ability to accumulate an output and to inspect the output so far, it would be considerably more efficient to use a state monad transformer.

runAccumT :: AccumT w m a -> w -> m (a, w) Source

Unwrap an accumulation computation. For example, in the call

    (value, locals) <- runAccumT action globals

the action is fed an initial environment globals, and locals is the sum of all arguments to calls of add executed by the action.

execAccumT :: Monad m => AccumT w m a -> w -> m w Source

Extract the output from an accumulation computation.

• execAccumT m w = liftM snd (runAccumT m w)

evalAccumT :: (Monad m, Monoid w) => AccumT w m a -> w -> m a Source

Evaluate an accumulation computation with the given initial output history and return the final value, discarding the final output.

• evalAccumT m w = liftM fst (runAccumT m w)

mapAccumT :: (m (a, w) -> n (b, w)) -> AccumT w m a -> AccumT w n b Source

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

• runAccumT (mapAccumT f m) = f . runAccumT m

look :: forall w (m :: Type -> Type). (Monoid w, Monad m) => AccumT w m w Source

look is an action that fetches all the previously accumulated output.

looks :: forall w (m :: Type -> Type) a. (Monoid w, Monad m) => (w -> a) -> AccumT w m a Source

look is an action that retrieves a function of the previously accumulated output.

add :: forall (m :: Type -> Type) w. Monad m => w -> AccumT w m () Source

add w is an action that produces the output w.

liftCallCC :: CallCC m (a, w) (b, w) -> CallCC (AccumT w m) a b Source

Uniform lifting of a callCC operation to the new monad. This version rolls back to the original output history on entering the continuation.

liftCallCC' :: CallCC m (a, w) (b, w) -> CallCC (AccumT w m) a b Source

In-situ lifting of a callCC operation to the new monad. This version uses the current output history on entering the continuation. It does not satisfy the uniformity property (see Control.Monad.Signatures).

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

Lift a catchE operation to the new monad. The uniformity property (see Control.Monad.Signatures) implies that the lifted catchE discards any output from the body on entering the handler.

liftListen :: Monad m => Listen w m (a, s) -> Listen w (AccumT s m) a Source

Lift a listen operation to the new monad.

liftPass :: Monad m => Pass w m (a, s) -> Pass w (AccumT s m) a Source

Lift a pass operation to the new monad.

readerToAccumT :: forall (m :: Type -> Type) w a. (Functor m, Monoid w) => ReaderT w m a -> AccumT w m a Source

Convert a read-only computation into an accumulation computation.

writerToAccumT :: forall w (m :: Type -> Type) a. WriterT w m a -> AccumT w m a Source

Convert a writer computation into an accumulation computation.

accumToStateT :: forall (m :: Type -> Type) s a. (Functor m, Monoid s) => AccumT s m a -> StateT s m a Source

Convert an accumulation (append-only) computation into a fully stateful computation.