Control.Effect.Writer

The writer effect, similar to the MonadWriter type class from the mtl library.

Lazy and strict interpretations of the effect are available here: Control.Effect.Writer.Lazy and Control.Effect.Writer.Strict.

Tagged Writer Effect

class (Monad m, Monoid w) => Writer' tag w m | tag m -> w where

An effect that adds a write-only, accumulated output to a given computation.

Methods

tell' :: w -> m ()

Produces the output w. In other words, w is appended to the accumulated output.

listen' :: m a -> m (w, a)

Executes a sub-computation and appends w to the accumulated output.

censor'

Arguments

:: (w -> w)

The function which is applied to the output.

-> m a

The sub-computation which produces the modified output.

-> m a

The result of the sub-computation.

Executes a sub-computation and applies the function to its output.

Instances

(Monad m, Monoid w) => Writer' (tag :: k) w (WriterT w m)

Defined in Control.Effect.Writer

Methods

tell' :: w -> WriterT w m ()

listen' :: WriterT w m a -> WriterT w m (w, a)

censor' :: (w -> w) -> WriterT w m a -> WriterT w m a

(Monad m, Monoid w) => Writer' (tag :: k) w (WriterT w m)

Defined in Control.Effect.Writer

Methods

tell' :: w -> WriterT w m ()

listen' :: WriterT w m a -> WriterT w m (w, a)

censor' :: (w -> w) -> WriterT w m a -> WriterT w m a

Writer' tag w m => Writer' (tag :: k) w (Separation m)

Defined in Control.Effect.RWS

Methods

tell' :: w -> Separation m ()

listen' :: Separation m a -> Separation m (w, a)

censor' :: (w -> w) -> Separation m a -> Separation m a

(Monoid w, Monad m) => Writer' (tag :: k) w (WriterT w m)

Defined in Control.Effect.Writer.Strict

Methods

tell' :: w -> WriterT w m ()

listen' :: WriterT w m a -> WriterT w m (w, a)

censor' :: (w -> w) -> WriterT w m a -> WriterT w m a

Handle '[Monad] (Writer' tag w) others t m => Writer' (tag :: k) w (EachVia (Writer' tag w ': others) t m)

Defined in Control.Effect.Writer

Methods

tell' :: w -> EachVia (Writer' tag w ': others) t m ()

listen' :: EachVia (Writer' tag w ': others) t m a -> EachVia (Writer' tag w ': others) t m (w, a)

censor' :: (w -> w) -> EachVia (Writer' tag w ': others) t m a -> EachVia (Writer' tag w ': others) t m a

Find '[Monad] (Writer' tag w) other effs t m => Writer' (tag :: k) w (EachVia (other ': effs) t m)

Defined in Control.Effect.Writer

Methods

tell' :: w -> EachVia (other ': effs) t m ()

listen' :: EachVia (other ': effs) t m a -> EachVia (other ': effs) t m (w, a)

censor' :: (w -> w) -> EachVia (other ': effs) t m a -> EachVia (other ': effs) t m a

Control '[Monad] (Writer' tag w) t m => Writer' (tag :: k) w (EachVia ('[] :: [Effect]) t m)

Defined in Control.Effect.Writer

Methods

tell' :: w -> EachVia '[] t m ()

listen' :: EachVia '[] t m a -> EachVia '[] t m (w, a)

censor' :: (w -> w) -> EachVia '[] t m a -> EachVia '[] t m a

(Monad m, Monoid w) => Writer' (tag :: k) w (RWST r w s m)

Defined in Control.Effect.Writer

Methods

tell' :: w -> RWST r w s m ()

listen' :: RWST r w s m a -> RWST r w s m (w, a)

censor' :: (w -> w) -> RWST r w s m a -> RWST r w s m a

(Monad m, Monoid w) => Writer' (tag :: k) w (RWST r w s m)

Defined in Control.Effect.Writer

Methods

tell' :: w -> RWST r w s m ()

listen' :: RWST r w s m a -> RWST r w s m (w, a)

censor' :: (w -> w) -> RWST r w s m a -> RWST r w s m a

(Monad m, Monoid w) => Writer' (tag :: k) w (RWST r w s m)

Defined in Control.Effect.RWS.Strict

Methods

tell' :: w -> RWST r w s m ()

listen' :: RWST r w s m a -> RWST r w s m (w, a)

censor' :: (w -> w) -> RWST r w s m a -> RWST r w s m a

Writer' new w m => Writer' (tag :: k2) w (Tagger tag new m)

Defined in Control.Effect.Writer

Methods

tell' :: w -> Tagger tag new m ()

listen' :: Tagger tag new m a -> Tagger tag new m (w, a)

censor' :: (w -> w) -> Tagger tag new m a -> Tagger tag new m a

Convenience Functions

listens'

Arguments

:: forall tag w b m a. Writer' tag w m

=> (w -> b)

The function which is applied to the output.

-> m a

The sub-computation which produces the modified output.

-> m (b, a)

The result of the sub-computation, including the modified output.

Executes a sub-computation and applies the function to its output, thus adding an additional value to the result of the sub-computation.

Untagged Writer Effect

If you don't require disambiguation of multiple writer effects (i.e., you only have one writer effect in your monadic context), it is recommended to always use the untagged writer effect.

type Writer w = Writer' G w

tell :: Writer w m => w -> m ()

listen :: Writer w m => m a -> m (w, a)

censor :: Writer w m => (w -> w) -> m a -> m a

listens :: Writer w m => (w -> b) -> m a -> m (b, a)

Tagging and Untagging

Conversion functions between the tagged and untagged writer effect, usually used in combination with type applications, like:

    tagWriter' @"newTag" program
    retagWriter' @"oldTag" @"newTag" program
    untagWriter' @"erasedTag" program

tagWriter' :: forall new w m a. (Writer' G w `Via` Tagger G new) m a -> m a

retagWriter' :: forall tag new w m a. (Writer' tag w `Via` Tagger tag new) m a -> m a

untagWriter' :: forall tag w m a. (Writer' tag w `Via` Tagger tag G) m a -> m a