transformers-0.6.1.1: Concrete functor and monad transformers
Copyright(c) Nickolay Kudasov 2016
LicenseBSD-style (see the file LICENSE)
MaintainerR.Paterson@city.ac.uk
Stabilityexperimental
Portabilityportable
Safe HaskellSafe
LanguageHaskell2010

Control.Monad.Trans.Accum

Description

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

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 >>= 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.

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.

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.

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 >>= 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.

Constructors

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

Instances

Instances details
Monoid w => MonadTrans (AccumT w) Source # 
Instance details

Defined in Control.Monad.Trans.Accum

Methods

lift :: Monad m => m a -> AccumT w m a Source #

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

Defined in Control.Monad.Trans.Accum

Methods

liftIO :: IO a -> AccumT w m a Source #

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

Defined in Control.Monad.Trans.Accum

Methods

empty :: AccumT w m a #

(<|>) :: AccumT w m a -> AccumT w m a -> AccumT w m a #

some :: AccumT w m a -> AccumT w m [a] #

many :: AccumT w m a -> AccumT w m [a] #

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

Defined in Control.Monad.Trans.Accum

Methods

pure :: a -> AccumT w m a #

(<*>) :: AccumT w m (a -> b) -> AccumT w m a -> AccumT w m b #

liftA2 :: (a -> b -> c) -> AccumT w m a -> AccumT w m b -> AccumT w m c #

(*>) :: AccumT w m a -> AccumT w m b -> AccumT w m b #

(<*) :: AccumT w m a -> AccumT w m b -> AccumT w m a #

Functor m => Functor (AccumT w m) Source # 
Instance details

Defined in Control.Monad.Trans.Accum

Methods

fmap :: (a -> b) -> AccumT w m a -> AccumT w m b #

(<$) :: a -> AccumT w m b -> AccumT w m a #

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

Defined in Control.Monad.Trans.Accum

Methods

(>>=) :: AccumT w m a -> (a -> AccumT w m b) -> AccumT w m b #

(>>) :: AccumT w m a -> AccumT w m b -> AccumT w m b #

return :: a -> AccumT w m a #

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

Defined in Control.Monad.Trans.Accum

Methods

mzero :: AccumT w m a #

mplus :: AccumT w m a -> AccumT w m a -> AccumT w m a #

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

Defined in Control.Monad.Trans.Accum

Methods

fail :: String -> AccumT w m a #

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

Defined in Control.Monad.Trans.Accum

Methods

mfix :: (a -> AccumT w m a) -> AccumT w m a #

Generic (AccumT w m a) Source # 
Instance details

Defined in Control.Monad.Trans.Accum

Associated Types

type Rep (AccumT w m a) 
Instance details

Defined in Control.Monad.Trans.Accum

type Rep (AccumT w m a) = D1 ('MetaData "AccumT" "Control.Monad.Trans.Accum" "transformers-0.6.1.1-2aba" 'True) (C1 ('MetaCons "AccumT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (w -> m (a, w)))))

Methods

from :: AccumT w m a -> Rep (AccumT w m a) x #

to :: Rep (AccumT w m a) x -> AccumT w m a #

type Rep (AccumT w m a) Source # 
Instance details

Defined in Control.Monad.Trans.Accum

type Rep (AccumT w m a) = D1 ('MetaData "AccumT" "Control.Monad.Trans.Accum" "transformers-0.6.1.1-2aba" 'True) (C1 ('MetaCons "AccumT" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (w -> m (a, w)))))

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.

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.

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.

Accum operations

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.

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.

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.