Module Text.Pretty

Exported Functions

pPrint :: Doc -> String   

Standard printing with a column length of 80.

empty :: Doc   

The empty document

Further infos:

• solution complete, i.e., able to compute all solutions

isEmpty :: Doc -> Bool   

Is the document empty?

text :: String -> Doc   

The document (text s) contains the literal string s. The string shouldn't contain any newline (\n) characters. If the string contains newline characters, the function string should be used.

Further infos:

• solution complete, i.e., able to compute all solutions

linesep :: String -> Doc   

The document (linesep s) advances to the next line and indents to the current nesting level. Document (linesep s) behaves like (text s) if the line break is undone by group.

hardline :: Doc   

The document hardline advances to the next line and indents to the current nesting level. hardline cannot be undone by group.

Further infos:

• solution complete, i.e., able to compute all solutions

line :: Doc   

The document line advances to the next line and indents to the current nesting level. Document line behaves like (text " ") if the line break is undone by group.

linebreak :: Doc   

The document linebreak advances to the next line and indents to the current nesting level. Document linebreak behaves like (text "") if the line break is undone by group.

softline :: Doc   

The document softline behaves like space if the resulting output fits the page, otherwise it behaves like line. softline = group line

softbreak :: Doc   

The document softbreak behaves like (text "") if the resulting output fits the page, otherwise it behaves like line. softbreak = group linebreak

group :: Doc -> Doc   

The combinator group is used to specify alternative layouts. The document (group x) undoes all line breaks in document x. The resulting line is added to the current line if that fits the page. Otherwise, the document x is rendered without any changes.

nest :: Int -> Doc -> Doc   

The document (nest i d) renders document d with the current indentation level increased by i (See also hang, align and indent).

nest 2 (text "hello" $$ text "world") $$ text "!"

outputs as:

hello
  world
!

hang :: Int -> Doc -> Doc   

The combinator hang implements hanging indentation. The document (hang i d) renders document d with a nesting level set to the current column plus i. The following example uses hanging indentation for some text:

test = hang 4
         (fillSep
            (map text
                 (words "the hang combinator indents these words !")))

Which lays out on a page with a width of 20 characters as:

the hang combinator
    indents these
    words !

The hang combinator is implemented as:

hang i x  = align (nest i x)

align :: Doc -> Doc   

The document (align d) renders document d with the nesting level set to the current column. It is used for example to implement hang`.

As an example, we will put a document right above another one, regardless of the current nesting level:

x $$ y  = align (x $$ y)
test    = text "hi" <+> (text "nice" $$ text "world")

which will be layed out as:

hi nice
   world

indent :: Int -> Doc -> Doc   

The document (indent i d) indents document d with i spaces.

test  = indent 4 (fillSep (map text
        (words "the indent combinator indents these words !")))

Which lays out with a page width of 20 as:

the indent
combinator
indents these
words !

combine :: Doc -> Doc -> Doc -> Doc   

The document (combine c d1 d2) combines document d1 and d2 with document c in between using (<>) with identity empty. Thus, the following equations hold.

combine c d1    empty == d1
combine c empty d2    == d2
combine c d1    d2    == d1 <> c <> d2 if neither d1 nor d2 are empty

Further infos:

• partially defined

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

The document (x <> y) concatenates document x and document y. It is an associative operation having empty as a left and right unit.

Further infos:

• defined as left-associative infix operator with precedence 6
• partially defined

(<+>) :: Doc -> Doc -> Doc   

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

Further infos:

• defined as left-associative infix operator with precedence 6

($$) :: Doc -> Doc -> Doc   

The document (x $$ y) concatenates document x and y with a line in between with identity empty.

Further infos:

• defined as left-associative infix operator with precedence 5

(<$+$>) :: Doc -> Doc -> Doc   

The document (x <$+$> y) concatenates document x and y with a blank line in between with identity empty.

Further infos:

• defined as left-associative infix operator with precedence 5

(</>) :: Doc -> Doc -> Doc   

The document (x </> y) concatenates document x and y with a softline in between with identity empty. This effectively puts x and y either next to each other (with a space in between) or underneath each other.

Further infos:

• defined as left-associative infix operator with precedence 5

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

The document (x <$$> y) concatenates document x and y with a linebreak in between with identity empty.

Further infos:

• defined as left-associative infix operator with precedence 5

(<//>) :: Doc -> Doc -> Doc   

The document (x <//> y) concatenates document x and y with a softbreak in between with identity empty. This effectively puts x and y either right next to each other or underneath each other.

Further infos:

• defined as left-associative infix operator with precedence 5

(<$!$>) :: Doc -> Doc -> Doc   

The document (x <$!$> y) concatenates document x and y with a hardline in between with identity empty. This effectively puts x and y underneath each other.

Further infos:

• defined as left-associative infix operator with precedence 5

compose :: (Doc -> Doc -> Doc) -> [Doc] -> Doc   

The document (compose f xs) concatenates all documents xs with function f. Function f should be like (<+>), ($$) and so on.

hsep :: [Doc] -> Doc   

The document (hsep xs) concatenates all documents xs horizontally with (<+>).

vsep :: [Doc] -> Doc   

The document (vsep xs) concatenates all documents xs vertically with ($$). If a group undoes the line breaks inserted by vsep, all documents are separated with a space.

someText = map text (words ("text to lay out"))
test     = text "some" <+> vsep someText

This is layed out as:

some text
to
lay
out

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

test     = text "some" <+> align (vsep someText)

This is printed as:

some text
     to
     lay
     out

vsepBlank :: [Doc] -> Doc   

The document vsep xs concatenates all documents xs vertically with (<$+$>). If a group undoes the line breaks inserted by vsepBlank, all documents are separated with a space.

fillSep :: [Doc] -> Doc   

The document (fillSep xs) concatenates documents xs horizontally with (</>) as long as its fits the page, than inserts a line and continues doing that for all documents in xs. fillSep xs = foldr (</>) empty xs

sep :: [Doc] -> Doc   

The document (sep xs) concatenates all documents xs either horizontally with (<+>), if it fits the page, or vertically with ($$). sep xs = group (vsep xs) or vertical concatenation else

hcat :: [Doc] -> Doc   

The document (hcat xs) concatenates all documents xs horizontally with (<>).

vcat :: [Doc] -> Doc   

The document (vcat xs) concatenates all documents xs vertically with (<$$>). If a group undoes the line breaks inserted by vcat, all documents are directly concatenated.

fillCat :: [Doc] -> Doc   

The document (fillCat xs) concatenates documents xs horizontally with (<//>) as long as its fits the page, than inserts a linebreak and continues doing that for all documents in xs. fillCat xs = foldr (<//>) empty xs

cat :: [Doc] -> Doc   

The document (cat xs) concatenates all documents xs either horizontally with (<>), if it fits the page, or vertically with (<$$>). cat xs = group (vcat xs)

punctuate :: Doc -> [Doc] -> [Doc]   

(punctuate p xs) concatenates all documents xs with document p except for the last document.

someText = map text ["words","in","a","tuple"]
test     = parens (align (cat (punctuate comma someText)))

This is layed out on a page width of 20 as:

(words,in,a,tuple)

But when the page width is 15, it is layed out as:

(words,
 in,
 a,
 tuple)

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

encloseSep :: Doc -> Doc -> Doc -> [Doc] -> Doc   

The document (encloseSep l r s xs) concatenates the documents xs seperated by s and encloses the resulting document by l and r. The documents are rendered horizontally if that fits the page. Otherwise they are aligned vertically. All seperators are put in front of the elements.

For example, the combinator list can be defined with encloseSep:

list xs  = encloseSep lbracket rbracket comma xs
test     = text "list" <+> (list (map int [10,200,3000]))

Which is layed out with a page width of 20 as:

list [10,200,3000]

But when the page width is 15, it is layed out as:

list [10
     ,200
     ,3000]

encloseSepSpaced :: Doc -> Doc -> Doc -> [Doc] -> Doc   

The document (encloseSepSpaced l r s xs) concatenates the documents xs seperated by s and encloses the resulting document by l and r. In addition, after each occurrence of s, after l, and before r, a space is inserted. The documents are rendered horizontally if that fits the page. Otherwise they are aligned vertically. All seperators are put in front of the elements.

hEncloseSep :: Doc -> Doc -> Doc -> [Doc] -> Doc   

The document (hEncloseSep l r s xs) concatenates the documents xs seperated by s and encloses the resulting document by l and r.

The documents are rendered horizontally.

fillEncloseSep :: Doc -> Doc -> Doc -> [Doc] -> Doc   

The document (fillEncloseSep l r s xs) concatenates the documents xs seperated by s and encloses the resulting document by l and r.

The documents are rendered horizontally if that fits the page. Otherwise they are aligned vertically. All seperators are put in front of the elements.

fillEncloseSepSpaced :: Doc -> Doc -> Doc -> [Doc] -> Doc   

The document (fillEncloseSepSpaced l r s xs) concatenates the documents xs seperated by s and encloses the resulting document by l and r. In addition, after each occurrence of s, after l, and before r, a space is inserted.

The documents are rendered horizontally if that fits the page. Otherwise, they are aligned vertically. All seperators are put in front of the elements.

list :: [Doc] -> Doc   

The document (list xs) comma seperates the documents xs and encloses them in square brackets. The documents are rendered horizontally if that fits the page. Otherwise they are aligned vertically. All comma seperators are put in front of the elements.

listSpaced :: [Doc] -> Doc   

Spaced version of list

set :: [Doc] -> Doc   

The document (set xs) comma seperates the documents xs and encloses them in braces. The documents are rendered horizontally if that fits the page. Otherwise they are aligned vertically. All comma seperators are put in front of the elements.

setSpaced :: [Doc] -> Doc   

Spaced version of set

tupled :: [Doc] -> Doc   

The document (tupled xs) comma seperates the documents xs and encloses them in parenthesis. The documents are rendered horizontally if that fits the page. Otherwise they are aligned vertically. All comma seperators are put in front of the elements.

tupledSpaced :: [Doc] -> Doc   

Spaced version of tupled

semiBraces :: [Doc] -> Doc   

The document (semiBraces xs) seperates the documents xs with semi colons and encloses them in braces. The documents are rendered horizontally if that fits the page. Otherwise they are aligned vertically. All semi colons are put in front of the elements.

semiBracesSpaced :: [Doc] -> Doc   

Spaced version of semiBraces

enclose :: Doc -> Doc -> Doc -> Doc   

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

squotes :: Doc -> Doc   

Document (squotes x) encloses document x with single quotes "'".

dquotes :: Doc -> Doc   

Document (dquotes x) encloses document x with double quotes.

bquotes :: Doc -> Doc   

Document (bquotes x) encloses document x with back quotes "\`".

parens :: Doc -> Doc   

Document (parens x) encloses document x in parenthesis, "(" and ")".

parensIf :: Bool -> Doc -> Doc   

Document (parensIf x) encloses document x in parenthesis,"(" and ")", iff the condition is true.

angles :: Doc -> Doc   

Document (angles x) encloses document x in angles, "<" and ">".

braces :: Doc -> Doc   

Document (braces x) encloses document x in braces, "{" and "}".

brackets :: Doc -> Doc   

Document (brackets x) encloses document x in square brackets, "[" and "]".

bool :: Bool -> Doc   

The document (bool b) shows the boolean b using text.

char :: Char -> Doc   

The document (char c) contains the literal character c. The character should not be a newline (\n), the function line should be used for line breaks.

Further infos:

• solution complete, i.e., able to compute all solutions

string :: String -> Doc   

The document (string s) concatenates all characters in s using line for newline characters and char for all other characters. It is used instead of text whenever the text contains newline characters.

int :: Int -> Doc   

The document (int i) shows the literal integer i using text.

float :: Float -> Doc   

The document (float f) shows the literal float f using text.

lparen :: Doc   

The document lparen contains a left parenthesis, "(".

Further infos:

• solution complete, i.e., able to compute all solutions

rparen :: Doc   

The document rparen contains a right parenthesis, ")".

Further infos:

• solution complete, i.e., able to compute all solutions

langle :: Doc   

The document langle contains a left angle, "<".

Further infos:

• solution complete, i.e., able to compute all solutions

rangle :: Doc   

The document rangle contains a right angle, ">".

Further infos:

• solution complete, i.e., able to compute all solutions

lbrace :: Doc   

The document lbrace contains a left brace, "{".

Further infos:

• solution complete, i.e., able to compute all solutions

rbrace :: Doc   

The document rbrace contains a right brace, "}".

Further infos:

• solution complete, i.e., able to compute all solutions

lbracket :: Doc   

The document lbracket contains a left square bracket, "[".

Further infos:

• solution complete, i.e., able to compute all solutions

rbracket :: Doc   

The document rbracket contains a right square bracket, "]".

Further infos:

• solution complete, i.e., able to compute all solutions

squote :: Doc   

The document squote contains a single quote, "'".

Further infos:

• solution complete, i.e., able to compute all solutions

dquote :: Doc   

The document dquote contains a double quote.

Further infos:

• solution complete, i.e., able to compute all solutions

semi :: Doc   

The document semi contains a semi colon, ";".

Further infos:

• solution complete, i.e., able to compute all solutions

colon :: Doc   

The document colon contains a colon, ":".

Further infos:

• solution complete, i.e., able to compute all solutions

comma :: Doc   

The document comma contains a comma, ",".

Further infos:

• solution complete, i.e., able to compute all solutions

space :: Doc   

The document space contains a single space, " ".

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

Further infos:

• solution complete, i.e., able to compute all solutions

dot :: Doc   

The document dot contains a single dot, ".".

Further infos:

• solution complete, i.e., able to compute all solutions

backslash :: Doc   

The document backslash contains a back slash, "\\".

Further infos:

• solution complete, i.e., able to compute all solutions

equals :: Doc   

The document equals contains an equal sign, "=".

Further infos:

• solution complete, i.e., able to compute all solutions

larrow :: Doc   

The document larrow contains a left arrow sign, "<-".

Further infos:

• solution complete, i.e., able to compute all solutions

rarrow :: Doc   

The document rarrow contains a right arrow sign, "->".

Further infos:

• solution complete, i.e., able to compute all solutions

doubleArrow :: Doc   

The document doubleArrow contains an double arrow sign, "=>".

Further infos:

• solution complete, i.e., able to compute all solutions

doubleColon :: Doc   

The document doubleColon contains a double colon sign, "::".

Further infos:

• solution complete, i.e., able to compute all solutions

bar :: Doc   

The document bar contains a vertical bar sign, "|".

Further infos:

• solution complete, i.e., able to compute all solutions

at :: Doc   

The document at contains an at sign, "@".

Further infos:

• solution complete, i.e., able to compute all solutions

tilde :: Doc   

The document tilde contains a tilde sign, "~".

Further infos:

• solution complete, i.e., able to compute all solutions

fill :: Int -> Doc -> Doc   

The document (fill i d) renders document d. It than appends spaces until the width is equal to i. If the width of d is already larger, nothing is appended. This combinator is quite useful in practice to output a list of bindings. The following example demonstrates this.

types  = [("empty","Doc")
         ,("nest","Int -> Doc -> Doc")
         ,("linebreak","Doc")]

ptype (name,tp)
       = fill 6 (text name) <+> text "::" <+> text tp

test   = text "let" <+> align (vcat (map ptype types))

Which is layed out as:

let empty  :: Doc
    nest   :: Int -> Doc -> Doc
    linebreak :: Doc

Note that fill is not guaranteed to be linear-time bounded since it has to compute the width of a document before pretty printing it

fillBreak :: Int -> Doc -> Doc   

The document (fillBreak i d) first renders document d. It than appends spaces until the width is equal to i. If the width of d is already larger than i, the nesting level is increased by i and a line is appended. When we redefine ptype in the previous example to use fillBreak, we get a useful variation of the previous output:

ptype (name,tp)
     = fillBreak 6 (text name) <+> text "::" <+> text tp

The output will now be:

let empty  :: Doc
    nest   :: Int -> Doc -> Doc
    linebreak
           :: Doc

Note that fillBreak is not guaranteed to be linear-time bounded since it has to compute the width of a document before pretty printing it

bold :: Doc -> Doc   

The document (bold d) displays document d with bold text

faint :: Doc -> Doc   

The document (faint d) displays document d with faint text

blinkSlow :: Doc -> Doc   

The document (blinkSlow d) displays document d with slowly blinking text (rarely supported)

blinkRapid :: Doc -> Doc   

The document (blinkRapid d) displays document d with rapidly blinking text (rarely supported)

italic :: Doc -> Doc   

The document (italic d) displays document d with italicized text (rarely supported)

underline :: Doc -> Doc   

The document (underline d) displays document d with underlined text

crossout :: Doc -> Doc   

The document (crossout d) displays document d with crossed out text

inverse :: Doc -> Doc   

The document (inverse d) displays document d with inversed coloring, i.e. use text color of d as background color and background color of d as text color

black :: Doc -> Doc   

The document (black d) displays document d with black text color

red :: Doc -> Doc   

The document (red d) displays document d with red text color

green :: Doc -> Doc   

The document (green d) displays document d with green text color

yellow :: Doc -> Doc   

The document (yellow d) displays document d with yellow text color

blue :: Doc -> Doc   

The document (blue d) displays document d with blue text color

magenta :: Doc -> Doc   

The document (magenta d) displays document d with magenta text color

cyan :: Doc -> Doc   

The document (cyan d) displays document d with cyan text color

white :: Doc -> Doc   

The document (white d) displays document d with white text color

bgBlack :: Doc -> Doc   

The document (bgBlack d) displays document d with black background color

bgRed :: Doc -> Doc   

The document (bgRed d) displays document d with red background color

bgGreen :: Doc -> Doc   

The document (bgGreen d) displays document d with green background color

bgYellow :: Doc -> Doc   

The document (bgYellow d) displays document d with yellow background color

bgBlue :: Doc -> Doc   

The document (bgBlue d) displays document d with blue background color

bgMagenta :: Doc -> Doc   

The document (bgMagenta d) displays document d with magenta background color

bgCyan :: Doc -> Doc   

The document (bgCyan d) displays document d with cyan background color

bgWhite :: Doc -> Doc   

The document (bgWhite d) displays document d with white background color

Exported Classes

Methods: