Copyright | (c) Nickolay Kudasov 2016 |
---|---|

License | BSD-style (see the file LICENSE) |

Maintainer | R.Paterson@city.ac.uk |

Stability | experimental |

Portability | portable |

Safe Haskell | Safe |

Language | Haskell2010 |

The lazy `AccumT`

monad transformer, which adds accumulation
capabilities (such as declarations or document patches) to a given monad.
Each computation has access to the combination of the input environment
and outputs added so far, and returns the outputs added.

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 Control.Monad.Trans.State instead.

## Synopsis

- type Accum w = AccumT w Identity
- accum :: forall (m :: Type -> Type) w a. Monad m => (w -> (a, w)) -> AccumT w m a
- runAccum :: Accum w a -> w -> (a, w)
- execAccum :: Accum w a -> w -> w
- evalAccum :: Monoid w => Accum w a -> w -> a
- mapAccum :: ((a, w) -> (b, w)) -> Accum w a -> Accum w b
- newtype AccumT w (m :: Type -> Type) a = AccumT (w -> m (a, w))
- runAccumT :: AccumT w m a -> w -> m (a, w)
- execAccumT :: Monad m => AccumT w m a -> w -> m w
- evalAccumT :: (Monad m, Monoid w) => AccumT w m a -> w -> m a
- mapAccumT :: (m (a, w) -> n (b, w)) -> AccumT w m a -> AccumT w n b
- look :: forall w (m :: Type -> Type). (Monoid w, Monad m) => AccumT w m w
- looks :: forall w (m :: Type -> Type) a. (Monoid w, Monad m) => (w -> a) -> AccumT w m a
- add :: forall (m :: Type -> Type) w. Monad m => w -> AccumT w m ()
- liftCallCC :: CallCC m (a, w) (b, w) -> CallCC (AccumT w m) a b
- liftCallCC' :: CallCC m (a, w) (b, w) -> CallCC (AccumT w m) a b
- liftCatch :: Catch e m (a, w) -> Catch e (AccumT w m) a
- liftListen :: Monad m => Listen w m (a, s) -> Listen w (AccumT s m) a
- liftPass :: Monad m => Pass w m (a, s) -> Pass w (AccumT s m) a
- readerToAccumT :: forall (m :: Type -> Type) w a. (Functor m, Monoid w) => ReaderT w m a -> AccumT w m a
- writerToAccumT :: forall w (m :: Type -> Type) a. WriterT w m a -> AccumT w m a
- accumToStateT :: forall (m :: Type -> Type) s a. (Functor m, Monoid s) => AccumT s m a -> StateT s m a

# The Accum monad

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
```

uses the output of `>>=`

k`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`

.)

# The AccumT monad transformer

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 `

uses the output of `>>=`

k`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.

AccumT (w -> m (a, w)) |

#### Instances

Monoid w => MonadTrans (AccumT w) Source # | |||||

(Monoid w, Functor m, MonadPlus m) => Alternative (AccumT w m) Source # | |||||

(Monoid w, Functor m, Monad m) => Applicative (AccumT w m) Source # | |||||

Defined in Control.Monad.Trans.Accum | |||||

Functor m => Functor (AccumT w m) Source # | |||||

(Monoid w, Functor m, Monad m) => Monad (AccumT w m) Source # | |||||

(Monoid w, Functor m, MonadPlus m) => MonadPlus (AccumT w m) Source # | |||||

(Monoid w, MonadFail m) => MonadFail (AccumT w m) Source # | |||||

Defined in Control.Monad.Trans.Accum | |||||

(Monoid w, Functor m, MonadFix m) => MonadFix (AccumT w m) Source # | |||||

Defined in Control.Monad.Trans.Accum | |||||

(Monoid w, Functor m, MonadIO m) => MonadIO (AccumT w m) Source # | |||||

Defined in Control.Monad.Trans.Accum | |||||

Generic (AccumT w m a) Source # | |||||

Defined in Control.Monad.Trans.Accum
| |||||

type Rep (AccumT w m a) Source # | |||||

Defined in Control.Monad.Trans.Accum |

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)

# Accum operations

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

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

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

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

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

is an action that produces the output `add`

w`w`

.

# Lifting other operations

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.

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.

# Monad transformations

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.