Core.System.Pretty

Re-exports of combinators for use when building Render instances.

Pretty Printing

from Data.Text.Prettyprint.Doc

Re-exported from Data.Text.Prettyprint.Doc in prettyprinter and Data.Text.Prettyprint.Doc.Render.Terminal in prettyprinter-ansi-terminal:

data Doc ann

The abstract data type Doc ann represents pretty documents that have been annotated with data of type ann.

More specifically, a value of type Doc represents a non-empty set of possible layouts of a document. The layout functions select one of these possibilities, taking into account things like the width of the output document.

The annotation is an arbitrary piece of data associated with (part of) a document. Annotations may be used by the rendering backends in order to display output differently, such as

• color information (e.g. when rendering to the terminal)
• mouseover text (e.g. when rendering to rich HTML)
• whether to show something or not (to allow simple or detailed versions)

The simplest way to display a Doc is via the Show class.

>>> putStrLn (show (vsep ["hello", "world"]))
hello
world

Instances

Functor Doc

Alter the document’s annotations.

This instance makes Doc more flexible (because it can be used in Functor-polymorphic values), but fmap is much less readable compared to using reAnnotate in code that only works for Doc anyway. Consider using the latter when the type does not matter.

Defined in Prettyprinter.Internal

Methods

fmap :: (a -> b) -> Doc a -> Doc b

(<$) :: a -> Doc b -> Doc a

IsString (Doc ann)

>>> pretty ("hello\nworld")
hello
world

This instance uses the Pretty Doc instance, and uses the same newline to line conversion.

Defined in Prettyprinter.Internal

Methods

fromString :: String -> Doc ann

Monoid (Doc ann)

mempty = emptyDoc
mconcat = hcat

>>> mappend "hello" "world" :: Doc ann
helloworld

Defined in Prettyprinter.Internal

Methods

mempty :: Doc ann

mappend :: Doc ann -> Doc ann -> Doc ann

mconcat :: [Doc ann] -> Doc ann

Semigroup (Doc ann)

x <> y = hcat [x, y]

>>> "hello" <> "world" :: Doc ann
helloworld

Defined in Prettyprinter.Internal

Methods

(<>) :: Doc ann -> Doc ann -> Doc ann

sconcat :: NonEmpty (Doc ann) -> Doc ann

stimes :: Integral b => b -> Doc ann -> Doc ann

Generic (Doc ann)

Defined in Prettyprinter.Internal

Associated Types

type Rep (Doc ann) :: Type -> Type

Methods

from :: Doc ann -> Rep (Doc ann) x

to :: Rep (Doc ann) x -> Doc ann

Show (Doc ann)

(show doc) prettyprints document doc with defaultLayoutOptions, ignoring all annotations.

Defined in Prettyprinter.Internal

Methods

showsPrec :: Int -> Doc ann -> ShowS

show :: Doc ann -> String

showList :: [Doc ann] -> ShowS

type Rep (Doc ann)

Defined in Prettyprinter.Internal

type Rep (Doc ann) = D1 ('MetaData "Doc" "Prettyprinter.Internal" "prettyprinter-1.7.1-Fnq1Vt2JMTY81kvR0W9kdP" 'False) (((C1 ('MetaCons "Fail" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "Empty" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Char" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Char)))) :+: (C1 ('MetaCons "Text" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Int) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Text)) :+: (C1 ('MetaCons "Line" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "FlatAlt" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Doc ann)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Doc ann)))))) :+: ((C1 ('MetaCons "Cat" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Doc ann)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Doc ann))) :+: (C1 ('MetaCons "Nest" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Int) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Doc ann))) :+: C1 ('MetaCons "Union" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Doc ann)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Doc ann))))) :+: ((C1 ('MetaCons "Column" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Int -> Doc ann))) :+: C1 ('MetaCons "WithPageWidth" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (PageWidth -> Doc ann)))) :+: (C1 ('MetaCons "Nesting" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Int -> Doc ann))) :+: C1 ('MetaCons "Annotated" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ann) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Doc ann)))))))

class Pretty a where

Overloaded conversion to Doc.

Laws:

1. output should be pretty. :-)

Methods

pretty :: a -> Doc ann

>>> pretty 1 <+> pretty "hello" <+> pretty 1.234
1 hello 1.234

Instances

Pretty Void

Finding a good example for printing something that does not exist is hard, so here is an example of printing a list full of nothing.

>>> pretty ([] :: [Void])
[]

Defined in Prettyprinter.Internal

Methods

pretty :: Void -> Doc ann

prettyList :: [Void] -> Doc ann

Pretty Int16

Defined in Prettyprinter.Internal

Methods

pretty :: Int16 -> Doc ann

prettyList :: [Int16] -> Doc ann

Pretty Int32

Defined in Prettyprinter.Internal

Methods

pretty :: Int32 -> Doc ann

prettyList :: [Int32] -> Doc ann

Pretty Int64

Defined in Prettyprinter.Internal

Methods

pretty :: Int64 -> Doc ann

prettyList :: [Int64] -> Doc ann

Pretty Int8

Defined in Prettyprinter.Internal

Methods

pretty :: Int8 -> Doc ann

prettyList :: [Int8] -> Doc ann

Pretty Word16

Defined in Prettyprinter.Internal

Methods

pretty :: Word16 -> Doc ann

prettyList :: [Word16] -> Doc ann

Pretty Word32

Defined in Prettyprinter.Internal

Methods

pretty :: Word32 -> Doc ann

prettyList :: [Word32] -> Doc ann

Pretty Word64

Defined in Prettyprinter.Internal

Methods

pretty :: Word64 -> Doc ann

prettyList :: [Word64] -> Doc ann

Pretty Word8

Defined in Prettyprinter.Internal

Methods

pretty :: Word8 -> Doc ann

prettyList :: [Word8] -> Doc ann

Pretty JsonKey

Defined in Core.Encoding.Json

Methods

pretty :: JsonKey -> Doc ann

prettyList :: [JsonKey] -> Doc ann

Pretty JsonValue

Defined in Core.Encoding.Json

Methods

pretty :: JsonValue -> Doc ann

prettyList :: [JsonValue] -> Doc ann

Pretty LongName

Defined in Core.Program.Arguments

Methods

pretty :: LongName -> Doc ann

prettyList :: [LongName] -> Doc ann

Pretty Rope

Defined in Core.Text.Rope

Methods

pretty :: Rope -> Doc ann

prettyList :: [Rope] -> Doc ann

Pretty Text

Automatically converts all newlines to line.

>>> pretty ("hello\nworld" :: Text)
hello
world

Note that line can be undone by group:

>>> group (pretty ("hello\nworld" :: Text))
hello world

Manually use hardline if you definitely want newlines.

Defined in Prettyprinter.Internal

Methods

pretty :: Text -> Doc ann

prettyList :: [Text] -> Doc ann

Pretty Text

(lazy Doc instance, identical to the strict version)

Defined in Prettyprinter.Internal

Methods

pretty :: Text -> Doc ann

prettyList :: [Text] -> Doc ann

Pretty Integer

>>> pretty (2^123 :: Integer)
10633823966279326983230456482242756608

Defined in Prettyprinter.Internal

Methods

pretty :: Integer -> Doc ann

prettyList :: [Integer] -> Doc ann

Pretty Natural

Defined in Prettyprinter.Internal

Methods

pretty :: Natural -> Doc ann

prettyList :: [Natural] -> Doc ann

Pretty ()

>>> pretty ()
()

The argument is not used:

>>> pretty (error "Strict?" :: ())
()

Defined in Prettyprinter.Internal

Methods

pretty :: () -> Doc ann

prettyList :: [()] -> Doc ann

Pretty Bool

>>> pretty True
True

Defined in Prettyprinter.Internal

Methods

pretty :: Bool -> Doc ann

prettyList :: [Bool] -> Doc ann

Pretty Char

Instead of (pretty 'n'), consider using line as a more readable alternative.

>>> pretty 'f' <> pretty 'o' <> pretty 'o'
foo
>>> pretty ("string" :: String)
string

Defined in Prettyprinter.Internal

Methods

pretty :: Char -> Doc ann

prettyList :: [Char] -> Doc ann

Pretty Double

>>> pretty (exp 1 :: Double)
2.71828182845904...

Defined in Prettyprinter.Internal

Methods

pretty :: Double -> Doc ann

prettyList :: [Double] -> Doc ann

Pretty Float

>>> pretty (pi :: Float)
3.1415927

Defined in Prettyprinter.Internal

Methods

pretty :: Float -> Doc ann

prettyList :: [Float] -> Doc ann

Pretty Int

>>> pretty (123 :: Int)
123

Defined in Prettyprinter.Internal

Methods

pretty :: Int -> Doc ann

prettyList :: [Int] -> Doc ann

Pretty Word

Defined in Prettyprinter.Internal

Methods

pretty :: Word -> Doc ann

prettyList :: [Word] -> Doc ann

Pretty a => Pretty (Identity a)

>>> pretty (Identity 1)
1

Defined in Prettyprinter.Internal

Methods

pretty :: Identity a -> Doc ann

prettyList :: [Identity a] -> Doc ann

Pretty a => Pretty (NonEmpty a)

Defined in Prettyprinter.Internal

Methods

pretty :: NonEmpty a -> Doc ann

prettyList :: [NonEmpty a] -> Doc ann

Pretty a => Pretty (Maybe a)

Ignore Nothings, print Just contents.

>>> pretty (Just True)
True
>>> braces (pretty (Nothing :: Maybe Bool))
{}

>>> pretty [Just 1, Nothing, Just 3, Nothing]
[1, 3]

Defined in Prettyprinter.Internal

Methods

pretty :: Maybe a -> Doc ann

prettyList :: [Maybe a] -> Doc ann

Pretty a => Pretty [a]

>>> pretty [1,2,3]
[1, 2, 3]

Defined in Prettyprinter.Internal

Methods

pretty :: [a] -> Doc ann

prettyList :: [[a]] -> Doc ann

(Pretty a1, Pretty a2) => Pretty (a1, a2)

>>> pretty (123, "hello")
(123, hello)

Defined in Prettyprinter.Internal

Methods

pretty :: (a1, a2) -> Doc ann

prettyList :: [(a1, a2)] -> Doc ann

Pretty a => Pretty (Const a b)

Defined in Prettyprinter.Internal

Methods

pretty :: Const a b -> Doc ann

prettyList :: [Const a b] -> Doc ann

(Pretty a1, Pretty a2, Pretty a3) => Pretty (a1, a2, a3)

>>> pretty (123, "hello", False)
(123, hello, False)

Defined in Prettyprinter.Internal

Methods

pretty :: (a1, a2, a3) -> Doc ann

prettyList :: [(a1, a2, a3)] -> Doc ann

dquote :: Doc ann

>>> dquote
"

squote :: Doc ann

>>> squote
'

comma :: Doc ann

>>> comma
,

punctuate

Arguments

:: Doc ann

Punctuation, e.g. comma

-> [Doc ann]

-> [Doc ann]

(punctuate p xs) appends p to all but the last document in xs.

>>> let docs = punctuate comma (Util.words "lorem ipsum dolor sit amet")
>>> putDocW 80 (hsep docs)
lorem, ipsum, dolor, sit, amet

The separators are put at the end of the entries, which we can see if we position the result vertically:

>>> putDocW 20 (vsep docs)
lorem,
ipsum,
dolor,
sit,
amet

If you want put the commas in front of their elements instead of at the end, you should use tupled or, in general, encloseSep.

enclose

Arguments

:: Doc ann

L

-> Doc ann

R

-> Doc ann

x

-> Doc ann

LxR

(enclose l r x) encloses document x between documents l and r using <>.

>>> enclose "A" "Z" "·"
A·Z

enclose l r x = l <> x <> r

lbracket :: Doc ann

>>> lbracket
[

rbracket :: Doc ann

>>> rbracket
]

(<+>) :: Doc ann -> Doc ann -> Doc ann infixr 6

(x <+> y) concatenates document x and y with a space in between.

>>> "hello" <+> "world"
hello world

x <+> y = x <> space <> y

lbrace :: Doc ann

>>> lbrace
{

rbrace :: Doc ann

>>> rbrace
}

lparen :: Doc ann

>>> lparen
(

rparen :: Doc ann

>>> rparen
)

emptyDoc :: Doc ann

The empty document behaves like (pretty ""), so it has a height of 1. This may lead to surprising behaviour if we expect it to bear no weight inside e.g. vcat, where we get an empty line of output from it (parens for visibility only):

>>> vsep ["hello", parens emptyDoc, "world"]
hello
()
world

Together with <>, emptyDoc forms the Monoid Doc.

sep :: [Doc ann] -> Doc ann

(sep xs) tries laying out the documents xs separated with spaces, and if this does not fit the page, separates them with newlines. This is what differentiates it from vsep, which always lays out its contents beneath each other.

>>> let doc = "prefix" <+> sep ["text", "to", "lay", "out"]
>>> putDocW 80 doc
prefix text to lay out

With a narrower layout, the entries are separated by newlines:

>>> putDocW 20 doc
prefix text
to
lay
out

sep = group . vsep

hsep :: [Doc ann] -> Doc ann

(hsep xs) concatenates all documents xs horizontally with <+>, i.e. it puts a space between all entries.

>>> let docs = Util.words "lorem ipsum dolor sit amet"

>>> hsep docs
lorem ipsum dolor sit amet

hsep does not introduce line breaks on its own, even when the page is too narrow:

>>> putDocW 5 (hsep docs)
lorem ipsum dolor sit amet

For automatic line breaks, consider using fillSep instead.

vsep :: [Doc ann] -> Doc ann

(vsep xs) concatenates all documents xs above each other. If a group undoes the line breaks inserted by vsep, the documents are separated with a space instead.

Using vsep alone yields

>>> "prefix" <+> vsep ["text", "to", "lay", "out"]
prefix text
to
lay
out

grouping a vsep separates the documents with a space if it fits the page (and does nothing otherwise). See the sep convenience function for this use case.

The align function can be used to align the documents under their first element:

>>> "prefix" <+> align (vsep ["text", "to", "lay", "out"])
prefix text
       to
       lay
       out

Since grouping a vsep is rather common, sep is a built-in for doing that.

fillCat :: [Doc ann] -> Doc ann

(fillCat xs) concatenates documents xs horizontally with <> as long as it fits the page, then inserts a line' and continues doing that for all documents in xs. This is similar to how an ordinary word processor lays out the text if you just keep typing after you hit the maximum line length.

(line' means that if grouped, the documents are separated with nothing instead of newlines. See fillSep if you want a space instead.)

Observe the difference between fillSep and fillCat. fillSep concatenates the entries spaced when grouped:

>>> let docs = take 20 (cycle (["lorem", "ipsum", "dolor", "sit", "amet"]))
>>> putDocW 40 ("Grouped:" <+> group (fillSep docs))
Grouped: lorem ipsum dolor sit amet
lorem ipsum dolor sit amet lorem ipsum
dolor sit amet lorem ipsum dolor sit
amet

On the other hand, fillCat concatenates the entries directly when grouped:

>>> putDocW 40 ("Grouped:" <+> group (fillCat docs))
Grouped: loremipsumdolorsitametlorem
ipsumdolorsitametloremipsumdolorsitamet
loremipsumdolorsitamet

fillSep :: [Doc ann] -> Doc ann

(fillSep xs) concatenates the documents xs horizontally with <+> as long as it fits the page, then inserts a line and continues doing that for all documents in xs. (line means that if grouped, the documents are separated with a space instead of newlines. Use fillCat if you do not want a space.)

Let's print some words to fill the line:

>>> let docs = take 20 (cycle ["lorem", "ipsum", "dolor", "sit", "amet"])
>>> putDocW 80 ("Docs:" <+> fillSep docs)
Docs: lorem ipsum dolor sit amet lorem ipsum dolor sit amet lorem ipsum dolor
sit amet lorem ipsum dolor sit amet

The same document, printed at a width of only 40, yields

>>> putDocW 40 ("Docs:" <+> fillSep docs)
Docs: lorem ipsum dolor sit amet lorem
ipsum dolor sit amet lorem ipsum dolor
sit amet lorem ipsum dolor sit amet

flatAlt

Arguments

:: Doc ann

Default

-> Doc ann

Preferred when grouped

-> Doc ann

By default, (flatAlt x y) renders as x. However when grouped, y will be preferred, with x as the fallback for the case when y doesn't fit.

>>> let doc = flatAlt "a" "b"
>>> putDoc doc
a
>>> putDoc (group doc)
b
>>> putDocW 0 (group doc)
a

flatAlt is particularly useful for defining conditional separators such as

softline = group (flatAlt hardline " ")

>>> let hello = "Hello" <> softline <> "world!"
>>> putDocW 12 hello
Hello world!
>>> putDocW 11 hello
Hello
world!

Example: Haskell's do-notation

We can use this to render Haskell's do-notation nicely:

>>> let open        = flatAlt "" "{ "
>>> let close       = flatAlt "" " }"
>>> let separator   = flatAlt "" "; "
>>> let prettyDo xs = group ("do" <+> align (encloseSep open close separator xs))
>>> let statements  = ["name:_ <- getArgs", "let greet = \"Hello, \" <> name", "putStrLn greet"]

This is put into a single line with {;} style if it fits:

>>> putDocW 80 (prettyDo statements)
do { name:_ <- getArgs; let greet = "Hello, " <> name; putStrLn greet }

When there is not enough space the statements are broken up into lines nicely:

>>> putDocW 10 (prettyDo statements)
do name:_ <- getArgs
   let greet = "Hello, " <> name
   putStrLn greet

Notes

Users should be careful to choose x to be less wide than y. Otherwise, if y turns out not to fit the page, we fall back on an even wider layout:

>>> let ugly = group (flatAlt "even wider" "too wide")
>>> putDocW 7 ugly
even wider

Also note that group will flatten y:

>>> putDoc (group (flatAlt "x" ("y" <> line <> "y")))
y y

This also means that an "unflattenable" y which contains a hard linebreak will never be rendered:

>>> putDoc (group (flatAlt "x" ("y" <> hardline <> "y")))
x

hcat :: [Doc ann] -> Doc ann

(hcat xs) concatenates all documents xs horizontally with <> (i.e. without any spacing).

It is provided only for consistency, since it is identical to mconcat.

>>> let docs = Util.words "lorem ipsum dolor"
>>> hcat docs
loremipsumdolor

vcat :: [Doc ann] -> Doc ann

(vcat xs) vertically concatenates the documents xs. If it is grouped, the line breaks are removed.

In other words vcat is like vsep, with newlines removed instead of replaced by spaces.

>>> let docs = Util.words "lorem ipsum dolor"
>>> vcat docs
lorem
ipsum
dolor
>>> group (vcat docs)
loremipsumdolor

Since grouping a vcat is rather common, cat is a built-in shortcut for it.

annotate :: ann -> Doc ann -> Doc ann

Add an annotation to a Doc. This annotation can then be used by the renderer to e.g. add color to certain parts of the output. For a full tutorial example on how to use it, see the Prettyprinter.Render.Tutorials.StackMachineTutorial or Prettyprinter.Render.Tutorials.TreeRenderingTutorial modules.

This function is only relevant for custom formats with their own annotations, and not relevant for basic prettyprinting. The predefined renderers, e.g. Prettyprinter.Render.Text, should be enough for the most common needs.

unAnnotate :: Doc ann -> Doc xxx

Remove all annotations.

Although unAnnotate is idempotent with respect to rendering,

unAnnotate . unAnnotate = unAnnotate

it should not be used without caution, for each invocation traverses the entire contained document. If possible, it is preferrable to unannotate after producing the layout by using unAnnotateS.

line :: Doc ann

The line document advances to the next line and indents to the current nesting level.

>>> let doc = "lorem ipsum" <> line <> "dolor sit amet"
>>> doc
lorem ipsum
dolor sit amet

line behaves like space if the line break is undone by group:

>>> group doc
lorem ipsum dolor sit amet

line' :: Doc ann

line' is like line, but behaves like mempty if the line break is undone by group (instead of space).

>>> let doc = "lorem ipsum" <> line' <> "dolor sit amet"
>>> doc
lorem ipsum
dolor sit amet
>>> group doc
lorem ipsumdolor sit amet

softline :: Doc ann

softline behaves like space if the resulting output fits the page, otherwise like line.

Here, we have enough space to put everything in one line:

>>> let doc = "lorem ipsum" <> softline <> "dolor sit amet"
>>> putDocW 80 doc
lorem ipsum dolor sit amet

If we narrow the page to width 10, the layouter produces a line break:

>>> putDocW 10 doc
lorem ipsum
dolor sit amet

softline = group line

softline' :: Doc ann

softline' is like softline, but behaves like mempty if the resulting output does not fit on the page (instead of space). In other words, line is to line' how softline is to softline'.

With enough space, we get direct concatenation:

>>> let doc = "ThisWord" <> softline' <> "IsWayTooLong"
>>> putDocW 80 doc
ThisWordIsWayTooLong

If we narrow the page to width 10, the layouter produces a line break:

>>> putDocW 10 doc
ThisWord
IsWayTooLong

softline' = group line'

hardline :: Doc ann

A hardline is always laid out as a line break, even when grouped or when there is plenty of space. Note that it might still be simply discarded if it is part of a flatAlt inside a group.

>>> let doc = "lorem ipsum" <> hardline <> "dolor sit amet"
>>> putDocW 1000 doc
lorem ipsum
dolor sit amet

>>> group doc
lorem ipsum
dolor sit amet

group :: Doc ann -> Doc ann

(group x) tries laying out x into a single line by removing the contained line breaks; if this does not fit the page, or when a hardline within x prevents it from being flattened, x is laid out without any changes.

The group function is key to layouts that adapt to available space nicely.

See vcat, line, or flatAlt for examples that are related, or make good use of it.

hang

Arguments

:: Int

Change of nesting level, relative to the start of the first line

-> Doc ann

-> Doc ann

(hang i x) lays out the document x with a nesting level set to the current column plus i. Negative values are allowed, and decrease the nesting level accordingly.

>>> let doc = reflow "Indenting these words with hang"
>>> putDocW 24 ("prefix" <+> hang 4 doc)
prefix Indenting these
           words with
           hang

This differs from nest, which is based on the current nesting level plus i. When you're not sure, try the more efficient nest first. In our example, this would yield

>>> let doc = reflow "Indenting these words with nest"
>>> putDocW 24 ("prefix" <+> nest 4 doc)
prefix Indenting these
    words with nest

hang i doc = align (nest i doc)

indent

Arguments

:: Int

Number of spaces to increase indentation by

-> Doc ann

-> Doc ann

(indent i x) indents document x by i columns, starting from the current cursor position.

>>> let doc = reflow "The indent function indents these words!"
>>> putDocW 24 ("prefix" <> indent 4 doc)
prefix    The indent
          function
          indents these
          words!

indent i d = hang i ({i spaces} <> d)

nest

Arguments

:: Int

Change of nesting level

-> Doc ann

-> Doc ann

(nest i x) lays out the document x with the current nesting level (indentation of the following lines) increased by i. Negative values are allowed, and decrease the nesting level accordingly.

>>> vsep [nest 4 (vsep ["lorem", "ipsum", "dolor"]), "sit", "amet"]
lorem
    ipsum
    dolor
sit
amet

See also

• hang (nest relative to current cursor position instead of current nesting level)
• align (set nesting level to current cursor position)
• indent (increase indentation on the spot, padding with spaces).

concatWith :: Foldable t => (Doc ann -> Doc ann -> Doc ann) -> t (Doc ann) -> Doc ann

Concatenate all documents element-wise with a binary function.

concatWith _ [] = mempty
concatWith (**) [x,y,z] = x ** y ** z

Multiple convenience definitions based on concatWith are already predefined, for example:

hsep    = concatWith (<+>)
fillSep = concatWith (\x y -> x <> softline <> y)

This is also useful to define customized joiners:

>>> concatWith (surround dot) ["Prettyprinter", "Render", "Text"]
Prettyprinter.Render.Text