Module Text.Pretty

pPrint :: Doc -> String   

Standard printing with a column length of 80.

empty :: Doc   

The empty document

Returns:

an 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.

Example call:

(text s)

Parameters:

• s : a string without newline (<code><a href="#\n">\n</a></code>) characters

Returns:

a document which contains the literal string

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.

Example call:

(linesep s)

Parameters:

• s : a string

Returns:

a document which advances to the next line or behaves like (text s)

hardline :: Doc   

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

Returns:

a document which advances to the next line

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.

Returns:

a document which advances to the next line or behaves like (text " ")

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.

Returns:

a document which advances to the next line or behaves like (text "")

softline :: Doc   

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

Returns:

a document which behaves like space or line

softbreak :: Doc   

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

Returns:

a document which behaves like (text "") or line

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.

Example call:

(group d)

Parameters:

• d : a document

Returns:

document d without line breaks if that fits the page.

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
!

Example call:

(nest i d)

Parameters:

• i : an integer which increases the indentation level
• d : a document

Returns:

document d with an indentation level increased by i

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)

Example call:

(hang i d)

Parameters:

• i : an integer which increases the indentation level
• d : a document

Returns:

document d with an indentation level set to the current column plus i

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

Example call:

(align d)

Parameters:

• d : a document

Returns:

document d with the nesting level set to the current column

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 !

Example call:

(indent i d)

Parameters:

• i : an integer which increases the indentation level
• d : a document

Returns:

document d with an indentation level set to the current column plus i

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

Example call:

(combine c d1 d2)

Parameters:

• c : the middle document
• d1 : the left document
• d2 : the right document

Returns:

concatenation of d1 and d2 with c in between unless one of the documents is empty

(<>) :: 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.

Example call:

(x <> y)

Parameters:

• x : the first document
• y : the second document

Returns:

concatenation of x and y without seperator 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 space in between with identity empty.

Example call:

(x <+> y)

Parameters:

• x : the first document
• y : the second document

Returns:

concatenation of x and y with a space in between

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.

Example call:

(x $$ y)

Parameters:

• x : the first document
• y : the second document

Returns:

concatenation of x and y with a line in between

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.

Example call:

(x <$+$> y)

Parameters:

• x : the first document
• y : the second document

Returns:

concatenation of x and y with a blank line in between

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.

Example call:

(x </> y)

Parameters:

• x : the first document
• y : the second document

Returns:

concatenation of x and y with a softline in between

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.

Example call:

(x <$$> y)

Parameters:

• x : the first document
• y : the second document

Returns:

concatenation of x and y with a linebreak in between

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.

Example call:

(x <//> y)

Parameters:

• x : the first document
• y : the second document

Returns:

concatenation of x and y with a softbreak in between

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.

Example call:

(x <$!$> y)

Parameters:

• x : the first document
• y : the second document

Returns:

concatenation of x and y with a hardline in between

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.

Example call:

(compose f xs)

Parameters:

• f : a combiner function
• xs : a list of documents

Returns:

concatenation of documents

hsep :: [Doc] -> Doc   

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

Example call:

(hsep xs)

Parameters:

• xs : a list of documents

Returns:

horizontal concatenation of documents

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

Example call:

(vsep xs)

Parameters:

• xs : a list of documents

Returns:

vertical concatenation of documents

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.

Example call:

(vsepBlank xs)

Parameters:

• xs : a list of documents

Returns:

vertical concatenation of documents

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

Example call:

(fillSep xs)

Parameters:

• xs : a list of documents

Returns:

horizontal concatenation of documents

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)

Example call:

(sep xs)

Parameters:

• xs : a list of documents

Returns:

horizontal concatenation of documents, if it fits the page, or vertical concatenation else

hcat :: [Doc] -> Doc   

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

Example call:

(hcat xs)

Parameters:

• xs : a list of documents

Returns:

horizontal concatenation of documents

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.

Example call:

(vcat xs)

Parameters:

• xs : a list of documents

Returns:

vertical concatenation of documents

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

Example call:

(fillCat xs)

Parameters:

• xs : a list of documents

Returns:

horizontal concatenation of documents

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)

Example call:

(cat xs)

Parameters:

• xs : a list of documents

Returns:

horizontal concatenation of documents

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.)

Example call:

(punctuate p xs)

Parameters:

• p : a document as seperator
• xs : a list of documents

Returns:

concatenation of documents with p in between

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]

Example call:

(encloseSep l r s xs)

Parameters:

• l : left document
• r : right document
• s : a document as seperator
• xs : a list of documents

Returns:

concatenation of l, xs (with s in between) and r

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.

Example call:

(encloseSepSpaced l r s xs)

Parameters:

• l : left document
• r : right document
• s : a document as seperator
• xs : a list of documents

Returns:

concatenation of l, xs (with s in between) and r

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.

Example call:

(hEncloseSep l r s xs)

Parameters:

• l : left document
• r : right document
• s : a document as seperator
• xs : a list of documents

Returns:

concatenation of l, xs (with s in between) and r

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.

Example call:

(fillEncloseSep l r s xs)

Parameters:

• l : left document
• r : right document
• s : a document as seperator
• xs : a list of documents

Returns:

concatenation of l, xs (with s in between) and r

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.

Example call:

(fillEncloseSepSpaced l r s xs)

Parameters:

• l : left document
• r : right document
• s : a document as seperator
• xs : a list of documents

Returns:

concatenation of l, xs (with s in between) and r

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.

Example call:

(list xs)

Parameters:

• xs : a list of documents

Returns:

comma seperated documents xs and enclosed in square brackets

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.

Example call:

(set xs)

Parameters:

• xs : a list of documents

Returns:

comma seperated documents xs and enclosed in braces

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.

Example call:

(tupled xs)

Parameters:

• xs : a list of documents

Returns:

comma seperated documents xs and enclosed in parenthesis

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.

Example call:

(semiBraces xs)

Parameters:

• xs : a list of documents

Returns:

documents xs seperated with semi colons and enclosed in braces

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

Example call:

(enclose l r x)

Parameters:

• l : the left document
• r : the right document
• x : the middle document

Returns:

concatenation of l, x and r

squotes :: Doc -> Doc   

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

Example call:

(squotes x)

Parameters:

• x : a document

Returns:

document x enclosed by single quotes

dquotes :: Doc -> Doc   

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

Example call:

(dquotes x)

Parameters:

• x : a document

Returns:

document x enclosed by double quotes

bquotes :: Doc -> Doc   

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

Example call:

(bquotes x)

Parameters:

• x : a document

Returns:

document x enclosed by \` quotes

parens :: Doc -> Doc   

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

Example call:

(parens x)

Parameters:

• x : a document

Returns:

document x enclosed in parenthesis

parensIf :: Bool -> Doc -> Doc   

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

Example call:

(parensIf x)

Parameters:

• x : a document

Returns:

document x enclosed in parenthesis iff the condition is true

angles :: Doc -> Doc   

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

Example call:

(angles x)

Parameters:

• x : a document

Returns:

document x enclosed in angles

braces :: Doc -> Doc   

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

Example call:

(braces x)

Parameters:

• x : a document

Returns:

document x enclosed in braces

brackets :: Doc -> Doc   

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

Example call:

(brackets x)

Parameters:

• x : a document

Returns:

document x enclosed in square brackets

bool :: Bool -> Doc   

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

Example call:

(bool b)

Parameters:

• b : a boolean

Returns:

a document which contains the boolean b

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.

Example call:

(char c)

Parameters:

• c : a character (not \n)

Returns:

a document which contains the literal character c

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.

Example call:

(string s)

Parameters:

• s : a string

Returns:

a document which contains the string s

int :: Int -> Doc   

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

Example call:

(int i)

Parameters:

• i : an integer

Returns:

a document which contains the integer i

float :: Float -> Doc   

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

Example call:

(float f)

Parameters:

• f : a float

Returns:

a document which contains the float f

lparen :: Doc   

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

Returns:

a document which contains a left parenthesis

Further infos:

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

rparen :: Doc   

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

Returns:

a document which contains a right parenthesis

Further infos:

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

langle :: Doc   

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

Returns:

a document which contains a left angle

Further infos:

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

rangle :: Doc   

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

Returns:

a document which contains a right angle

Further infos:

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

lbrace :: Doc   

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

Returns:

a document which contains a left brace

Further infos:

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

rbrace :: Doc   

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

Returns:

a document which 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, "[".

Returns:

a document which 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, "]".

Returns:

a document which 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, "'".

Returns:

a document which contains a single quote

Further infos:

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

dquote :: Doc   

The document dquote contains a double quote.

Returns:

a document which contains a double quote

Further infos:

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

semi :: Doc   

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

Returns:

a document which contains a semi colon

Further infos:

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

colon :: Doc   

The document colon contains a colon, ":".

Returns:

a document which contains a colon

Further infos:

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

comma :: Doc   

The document comma contains a comma, ",".

Returns:

a document which 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

Returns:

a document which contains a single space

Further infos:

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

dot :: Doc   

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

Returns:

a document which contains a single dot

Further infos:

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

backslash :: Doc   

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

Returns:

a document which contains a back slash

Further infos:

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

equals :: Doc   

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

Returns:

a document which contains an equal

Further infos:

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

larrow :: Doc   

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

Returns:

a document which 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, "->".

Returns:

a document which 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, "=>".

Returns:

a document which 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, "::".

Returns:

a document which 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, "|".

Returns:

a document which 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, "@".

Returns:

a document which contains an at sign

Further infos:

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

tilde :: Doc   

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

Returns:

a document which 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

Example call:

(bold d)

Parameters:

• d : a document

Returns:

document d displayed with bold text

faint :: Doc -> Doc   

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

Example call:

(faint d)

Parameters:

• d : a document

Returns:

document d displayed with faint text

blinkSlow :: Doc -> Doc   

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

Example call:

(blinkSlow d)

Parameters:

• d : a document

Returns:

document d displayed with slowly blinking text

blinkRapid :: Doc -> Doc   

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

Example call:

(blinkRapid d)

Parameters:

• d : a document

Returns:

document d displayed with rapidly blinking text

italic :: Doc -> Doc   

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

Example call:

(italic d)

Parameters:

• d : a document

Returns:

document d displayed with italicized text

underline :: Doc -> Doc   

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

Example call:

(underline d)

Parameters:

• d : a document

Returns:

document d displayed with underlined text

crossout :: Doc -> Doc   

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

Example call:

(crossout d)

Parameters:

• d : a document

Returns:

document d displayed 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

Example call:

(inverse d)

Parameters:

• d : a document

Returns:

document d displayed with inversed coloring

black :: Doc -> Doc   

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

Example call:

(black d)

Parameters:

• d : a document

Returns:

document d displayed with black text color

red :: Doc -> Doc   

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

Example call:

(red d)

Parameters:

• d : a document

Returns:

document d displayed with red text color

green :: Doc -> Doc   

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

Example call:

(green d)

Parameters:

• d : a document

Returns:

document d displayed with green text color

yellow :: Doc -> Doc   

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

Example call:

(yellow d)

Parameters:

• d : a document

Returns:

document d displayed with yellow text color

blue :: Doc -> Doc   

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

Example call:

(blue d)

Parameters:

• d : a document

Returns:

document d displayed with blue text color

magenta :: Doc -> Doc   

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

Example call:

(magenta d)

Parameters:

• d : a document

Returns:

document d displayed with magenta text color

cyan :: Doc -> Doc   

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

Example call:

(cyan d)

Parameters:

• d : a document

Returns:

document d displayed with cyan text color

white :: Doc -> Doc   

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

Example call:

(white d)

Parameters:

• d : a document

Returns:

document d displayed with white text color

bgBlack :: Doc -> Doc   

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

Example call:

(bgBlack d)

Parameters:

• d : a document

Returns:

document d displayed with black background color

bgRed :: Doc -> Doc   

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

Example call:

(bgRed d)

Parameters:

• d : a document

Returns:

document d displayed with red background color

bgGreen :: Doc -> Doc   

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

Example call:

(bgGreen d)

Parameters:

• d : a document

Returns:

document d displayed with green background color

bgYellow :: Doc -> Doc   

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

Example call:

(bgYellow d)

Parameters:

• d : a document

Returns:

document d displayed with yellow background color

bgBlue :: Doc -> Doc   

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

Example call:

(bgBlue d)

Parameters:

• d : a document

Returns:

document d displayed with blue background color

bgMagenta :: Doc -> Doc   

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

Example call:

(bgMagenta d)

Parameters:

• d : a document

Returns:

document d displayed with magenta background color

bgCyan :: Doc -> Doc   

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

Example call:

(bgCyan d)

Parameters:

• d : a document

Returns:

document d displayed with cyan background color

bgWhite :: Doc -> Doc   

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

Example call:

(bgWhite d)

Parameters:

• d : a document

Returns:

document d displayed with white background color