Module

Control.Monad.Writer.Trans

Package
purescript-transformers
Repository
purescript/purescript-transformers

This module defines the writer monad transformer, WriterT.

#WriterTSource

newtype WriterT w m a

The writer monad transformer.

This monad transformer extends the base monad with a monoidal accumulator of type w.

The MonadWriter type class describes the operations supported by this monad.

Constructors

Instances

#runWriterTSource

runWriterT :: forall w m a. WriterT w m a -> m (Tuple a w)

Run a computation in the WriterT monad.

#execWriterTSource

execWriterT :: forall w m a. Functor m => WriterT w m a -> m w

Run a computation in the WriterT monad, discarding the result.

#mapWriterTSource

mapWriterT :: forall w1 w2 m1 m2 a b. (m1 (Tuple a w1) -> m2 (Tuple b w2)) -> WriterT w1 m1 a -> WriterT w2 m2 b

Change the accumulator and base monad types in a WriterT monad action.

Re-exports from Control.Monad.Trans

#MonadTransSource

class MonadTrans t  where

The MonadTrans type class represents monad transformers.

A monad transformer is a type constructor of kind (* -> *) -> * -> *, which takes a Monad as its first argument, and returns another Monad.

This allows us to add additional effects to an existing monad. By iterating this process, we create monad transformer stacks, which contain all of the effects required for a particular computation.

The laws state that lift is a Monad morphism.

Laws:

  • lift (pure a) = pure a
  • lift (do { x <- m ; y }) = do { x <- lift m ; lift y }

Members

Re-exports from Control.Monad.Writer.Class

#MonadWriterSource

class (Monad m) <= MonadWriter w m  where

The MonadWriter w type class represents those monads which support a monoidal accumulator of type w.

  • writer appends a value to the accumulator.
  • listen modifies the result to include the changes to the accumulator.
  • pass applies the returned function to the accumulator.

An implementation is provided for WriterT, and for other monad transformers defined in this library.

Laws:

  • writer a mempty = pure a
  • do { tell x ; tell y } = tell (x <> y)
  • listen (pure a) = pure (Tuple a mempty)
  • listen (writer a x) = tell x $> Tuple a x

Members

#tellSource

tell :: forall w m. MonadWriter w m => w -> m Unit

Append a value to the accumulator.

#listensSource

listens :: forall w m a b. MonadWriter w m => (w -> b) -> m a -> m (Tuple a b)

Read a value which depends on the modifications made to the accumulator during an action.

#censorSource

censor :: forall w m a. MonadWriter w m => (w -> w) -> m a -> m a

Modify the final accumulator value by applying a function.