Render a Pretty printable a to String using a Config, that specifies how the a should be rendered. For example

pretty defConfig (1 :: Int)  -- evaluates to "1"

Render a Pretty printable a to stdout using a Config, that specifies how the a should be rendered.

Convenience function, defined as:

prettyPrint c = liftIO . putStrLn . pretty c

A Config allows to specify various pretty printing options, e.g. the maximum line width.

As the rendering functions, like pretty, take updates to an internal default Config, only the lenses of the Config fields are exported.

A custom Config can be specified as in the following example:

foo :: String
foo = pretty config "foo bar baz"
  where config :: State Config ()
        config = do cMaxLineWidth      .= Just 6
                    cInitIndent        .= 2
                    cIndentAfterBreaks .= 0

When a line gets longer, it is broken after the latest space, that still allows the line to remain below this maximum.

If there is no such space, an over-long line with a single indented word is printed.

This guarantees both progress and not to break identifiers into parts.

Default: Just 80

The character used for indentation. Usually ' ' for spaces or '\t' for tabs.

Default: ' '

How many cIndentChar characters for one indentation level.

Default: 2

How many cIndentChar characters to indent additionally, when a line break occurs, because cMaxLineWidth was exceeded.

Assuming the line to print has to be broken multiple times, the indentation of all resulting lines, except the first one, is increased by this amount. For example

pretty (do cMaxLineWidth .= Just 8; cIndentAfterBreaks .= 4) "foo bar baz boo"

evaluates to

foo bar
    baz
    boo

Default: 4

Indentation level to start pretty printing with.

Default: 0

Precendence level to start pretty printing with.

Default: (-1)

Leaves the default Config unchanged and returns ().

Convenience function defined as:

defConfig = pure ()

See example in pretty.

Instanciating this class for a type, declares how values of that type should be pretty printed.

As pretty printing may depend on some context, e.g. the current indentation level, a State monad for pretty printing (PrettyM) is used.

A default implementation is provided copying behavior from a Show instance. This can be convenient for deriving Pretty, e.g. for base types or debugging. The default implementation is defined by pp = pp . show.

The PrettyM monad is run in the pretty printing process, e.g. in pretty or prettyPrint.

PrettyM is internally a State monad manipulating a Config and a list of pretty printed lines.

Most of the combinators from this library take values of Pretty printable types, convert them to PrettyM () actions using pp, and combine the actions in some way resulting in a new PrettyM () action.

Print two Pretty printable things in sequence.

Example:

pretty defConfig $ "x" +> 1  -- ↪ "x1"

Convenience function, defined as

a +> b = pp a >> pp b

Print two Pretty printable things in sequence, separated by a space.

Example:

pretty defConfig $ "x" ~> 1  -- ↪ "x 1"

Convenience function, defined as

a ~> b = a +> " " +> b

Print two Pretty printable things in sequence, separated by a newline.

Example:

pretty defConfig $ "x" \> 1  -- ↪ "x
                                   1"

Convenience function, defined as

a \> b = a +> "\n" +> b

Print an a with indentation increased by a certain amount of cIndentChar characters.

Example:

pretty defConfig $
  "while (true) {" \>
  indentedByChars 2 ("f();" \> "g();") \>
  "}"
-- ↪ "while (true) {
--      f();
--      g();
--    }"

Same as indentedByChars but increases indentation in cIndentDepth steps.

Convenience function defined as:

indented = indentedBy 1

Print a [a] as a block, meaning that the indentation level is increased, and each a is printed on a single line.

Example:

pretty defConfig $ "do" ~> block ["putStrLn hello", "putStrLn world"]
-- ↪ "do
--      putStrLn hello
--      putStrLn world"

Same as block, but starts the block on the current line.

Example:

pretty defConfig $ "do" ~> block' ["putStrLn hello", "putStrLn world"]
-- ↪ "do putStrLn hello
--       putStrLn world"

Print an a as a left-associative operator of a certain fixity.

Print an a as a right-associative operator of a certain fixity.

Print an a as a non-associative operator of a certain fixity.

Print an a as the left argument of a mixfix operator.

Print an a as the right argument of a mixfix operator.

Print an a as an inner argument of a mixfix operator.

The constructors of this type can be used as short forms of left, right, and inner.

Print an a between each b.

Examples:

pretty defConfig $ "," `betweenEach` []          -- ↪ ""
pretty defConfig $ "," `betweenEach` ["x"]       -- ↪ "x"
pretty defConfig $ "," `betweenEach` ["x", "y"]  -- ↪ "x,y"

Print an a before each b.

Examples:

pretty defConfig $ "," `beforeEach` []          -- ↪ ""
pretty defConfig $ "," `beforeEach` ["x"]       -- ↪ ",x"
pretty defConfig $ "," `beforeEach` ["x", "y"]  -- ↪ ",x,y"

Print an a after each b.

Examples:

pretty defConfig $ "," `afterEach` []          -- ↪ ""
pretty defConfig $ "," `afterEach` ["x"]       -- ↪ "x,"
pretty defConfig $ "," `afterEach` ["x", "y"]  -- ↪ "x,y,"

Print a [a] similar to its Show instance.

Example:

pretty defConfig $ ppList [ "x", "y" ]  -- ↪ "[ x, y ]"

Print a list map [(k,v)] as ppList, but render (k,v) pairs as "k → v".

Example:

pretty defConfig $ ppListMap [ ("k1", "v1"), ("k2", "v2") ]
-- ↪ "[ k1 → v1, k2 → v2 ]"

Print a Data.Map in the same way as ppListMap.

Print a horizontal bar consisting of a Char as long as cMaxLineWidth (or 80 if it is Nothing).

Example:

pretty defConfig $ bar '-'
-- ↪ "-----------------------------------------…"

Print a horizontal bar consisting of a Char as long as cMaxLineWidth (or 80 if it is Nothing). The horizontal bar has a title String printed at column 6.

Example:

pretty defConfig $ titleBar '-' "Foo"
-- ↪ "----- Foo -------------------------------…"

Print a newline (line break).

Print a space.

The Pretty1 type class lifts Pretty printing to unary type constructors. It can be used in special cases to abstract over type constructors which are Pretty printable for any Pretty printable type argument.

The Pretty2 type class lifts Pretty printing to binary type constructors. It can be used in special cases to abstract over type constructors which are Pretty printable for any Pretty printable type arguments.

A state monad parameterized by the type s of the state to carry.

The return function leaves the state unchanged, while >>= uses the final state of the first computation as the initial state of the second.

Replace the target of a Lens or all of the targets of a Setter or Traversal in our monadic state with a new value, irrespective of the old.

This is an infix version of assign.

>>> execState (do _1 .= c; _2 .= d) (a,b)
(c,d)

>>> execState (both .= c) (a,b)
(c,c)

(.=) :: MonadState s m => Iso' s a       -> a -> m ()
(.=) :: MonadState s m => Lens' s a      -> a -> m ()
(.=) :: MonadState s m => Traversal' s a -> a -> m ()
(.=) :: MonadState s m => Setter' s a    -> a -> m ()

It puts the state in the monad or it gets the hose again.