writer is:module

The MonadWriter class. Inspired by the paper Functional Programming with Overloading and Higher-Order Polymorphism, Mark P Jones (http://web.cecs.pdx.edu/~mpj/pubs/springschool.html) Advanced School of Functional Programming, 1995.

The WriterT monad transformer. This version builds its output lazily; for a constant-space version with almost the same interface, see Control.Monad.Trans.Writer.CPS.

Provides reexports of MonadWriter and related helpers.

The MonadWriter class. Inspired by the paper /Functional Programming with Overloading and Higher-Order Polymorphism/, Mark P Jones (http://web.cecs.pdx.edu/~mpj/pubs/springschool.html) Advanced School of Functional Programming, 1995.

Arrow transformer that adds accumulation of output.

Convenience functions for the Labeled Writer effect.

An effect allowing writes to an accumulated quantity alongside a computed value. A Writer w effect keeps track of a monoidal datum of type w and strictly appends to that monoidal value with the tell effect. Writes to that value can be detected and intercepted with the listen and censor effects. Predefined carriers:

• Control.Carrier.Writer.Church
• Control.Carrier.Writer.Strict. (A lazy carrier is not provided due to the inherent space leaks associated with lazy writer monads.)
• Control.Monad.Trans.RWS.CPS
• Control.Monad.Trans.RWS.Lazy
• Control.Monad.Trans.RWS.Strict
• Control.Monad.Trans.Writer.CPS
• Control.Monad.Trans.Writer.Lazy
• Control.Monad.Trans.Writer.Strict
• If Writer w is the last effect in a stack, it can be interpreted to a tuple (w, a) given some result type a and the presence of a Monoid instance for w.

The writer monad applied to LaTeX values. Useful to compose LaTeX values using the do notation:

anExample :: Monad m => LaTeXT m ()
anExample = do
documentclass [] article
author "Daniel Monad"
title "LaTeX and do notation"
document $ do
maketitle
section "Some words"
"Using " ; texttt "do" ; " notation "
"you avoid many ocurrences of the "
texttt "(<>)" ; " operator and a lot of "
"parentheses. With the cost of a monad."

Since LaTeXT is a monad transformer, you can do also:

anotherExample :: LaTeXT IO ()
anotherExample = lift (readFileTex "foo") >>= verbatim

This way, it is easy (without carrying arguments) to include IO outputs in the LaTeX document, like files, times or random objects. Another approach could be to have custom counters, label management or any other user-defined feature. Of course, you can always use the simpler interface provided by the plain LaTeX type.

Writer effects, for writing/appending values (line count, list of messages, etc.) to an output. Current value of Writer effect output is not accessible to the computation. Using http://okmij.org/ftp/Haskell/extensible/Eff1.hs as a starting point.

This module provides a function for serializing structured Xlsx into lazy bytestring

Overcome XML insanity, node by node.

{-# LANGUAGE OverloadedStrings #-}

let doc = document "root" $ do
element "hello" $ content "world"
element "hierarchy" $ do
element "simple" True
element "as" ("it should be" :: Text)
toXML $ Just . T.pack $ "like this"
comment "that's it!"

An Automaton with a WriterT layer outputs an extra monoid value on every step. It is based on the strict writer monad Strict, so when combining it with other modules such as mtl's, the strict version has to be included, i.e. Strict instead of Writer or Lazy.

MSFs with a Writer monadic layer. This module contains functions to work with MSFs that include a Writer monadic layer. This includes functions to create new MSFs that include an additional layer, and functions to flatten that layer out of the MSF's transformer stack. It is based on the _strict_ writer monad Strict, so when combining it with other modules such as mtl's, the strict version has to be included, i.e. Strict instead of Writer or Lazy.

Write PDF files It could be used to generate new PDF file or to incrementally update the existent one To generate new file, first call writeHeader, then a number of writeObject and finally writeXRefTable or writeXRefStream. To incrementally update PDF file just omit the writeHeader and append the result to the existent file. Make sure to use writeXRefTable if the original file uses xref table, or use writeXRefStream if it uses xref stream.

Defines a capability type class for writer effects. A writer program can output values with tell. The values output by two consecutive sub-computation are combined using a monoid's mappend. The interface of HasWriter follows that of MonadWriter. However, this module does not include a strategy to provide a HasWriter capability from a MonadWriter instance. It is generally a bad idea to use monads such as WriterT, as they tend to leak space, as described in this <https://blog.infinitenegativeutility.com/2016/7/writer-monads-and-space-leaks blog post> by Getty Ritter. Instead, you should use the WriterLog strategy that implements the writer monad on a state monad. There is no downside, as using HasWriter instead of HasState directly ensures your code adheres to the writer monad interface and does not misuse the underlying state monad.

Effects that can accumulate values monoidally in a context.