| 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 |
Control.Monad.Trans.Accum
Description
The lazy AccumT monad transformer, which adds accumulation
capabilities (such as declarations or document patches) to a given monad.
This monad transformer provides append-only accumulation during the computation. For more general access, 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
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.
The return function produces the output mempty, while >>=
combines the outputs of the subcomputations using mappend.
This monad transformer is similar to both state and writer monad transformers. Thus it can be seen as
- a restricted append-only version of a state monad transformer or
- a writer monad transformer with the extra ability to read all previous output.
Constructors
| AccumT (w -> m (a, w)) |
Instances
execAccumT :: Monad m => AccumT w m a -> w -> m w Source #
Extract the output from an accumulation computation.
execAccumTm w =liftMsnd(runAccumTm 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.
evalAccumTm w =liftMfst(runAccumTm w)
Accum operations
look :: forall w (m :: Type -> Type). (Monoid w, Monad m) => AccumT w m w Source #
look
looks :: forall w (m :: Type -> Type) a. (Monoid w, Monad m) => (w -> a) -> AccumT w m a Source #
look
add :: forall (m :: Type -> Type) w. Monad m => w -> AccumT w m () Source #
add ww.
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.