-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/
-- | The Wadler/Leijen Pretty Printer for colored ANSI terminal output
--
-- This is a pretty printing library based on Wadler's paper <a>A
-- Prettier Printer</a>. It has been enhanced with support for ANSI
-- terminal colored output using the ansi-terminal package.
@package ansi-wl-pprint
@version 0.6.7.1
-- | Pretty print module based on Philip Wadler's "prettier printer"
--
-- <pre>
-- "A prettier printer"
-- Draft paper, April 1997, revised March 1998.
-- <a>http://cm.bell-labs.com/cm/cs/who/wadler/papers/prettier/prettier.ps</a>
-- </pre>
--
-- PPrint is an implementation of the pretty printing combinators
-- described by Philip Wadler (1997). In their bare essence, the
-- combinators of Wadler are not expressive enough to describe some
-- commonly occurring layouts. The PPrint library adds new primitives to
-- describe these layouts and works well in practice.
--
-- The library is based on a single way to concatenate documents, which
-- is associative and has both a left and right unit. This simple design
-- leads to an efficient and short implementation. The simplicity is
-- reflected in the predictable behaviour of the combinators which make
-- them easy to use in practice.
--
-- A thorough description of the primitive combinators and their
-- implementation can be found in Philip Wadler's paper (1997). Additions
-- and the main differences with his original paper are:
--
-- <ul>
-- <li>The nil document is called empty.</li>
-- <li>The above combinator is called <a><$></a>. The operator
-- <a></></a> is used for soft line breaks.</li>
-- <li>There are three new primitives: <a>align</a>, <a>fill</a> and
-- <a>fillBreak</a>. These are very useful in practice.</li>
-- <li>Lots of other useful combinators, like <a>fillSep</a> and
-- <a>list</a>.</li>
-- <li>There are two renderers, <a>renderPretty</a> for pretty printing
-- and <a>renderCompact</a> for compact output. The pretty printing
-- algorithm also uses a ribbon-width now for even prettier output.</li>
-- <li>There are two displayers, <a>displayS</a> for strings and
-- <a>displayIO</a> for file based output.</li>
-- <li>There is a <a>Pretty</a> class.</li>
-- <li>The implementation uses optimised representations and strictness
-- annotations.</li>
-- </ul>
--
-- Full documentation for the original wl-pprint library available at
-- <a>http://www.cs.uu.nl/~daan/download/pprint/pprint.html</a>.
--
-- The library has been extended to allow formatting text for output to
-- ANSI style consoles. New combinators allow:
--
-- <ul>
-- <li>Control of foreground and background color of text</li>
-- <li>The abliity to make parts of the text bold or underlined</li>
-- </ul>
--
-- This functionality is, as far as possible, portable across platforms
-- with their varying terminals. However, one thing to be particularly
-- wary of is that console colors will not be displayed on Windows unless
-- the <a>Doc</a> value is output using the <a>putDoc</a> function or one
-- of it's friends. Rendering the <a>Doc</a> to a <a>String</a> and then
-- outputing <i>that</i> will only work on Unix-style operating systems.
module Text.PrettyPrint.ANSI.Leijen
-- | The abstract data type <tt>Doc</tt> represents pretty documents.
--
-- <tt>Doc</tt> is an instance of the <a>Show</a> class. <tt>(show
-- doc)</tt> pretty prints document <tt>doc</tt> with a page width of 100
-- characters and a ribbon width of 40 characters.
--
-- <pre>
-- show (text "hello" <$> text "world")
-- </pre>
--
-- Which would return the string "hello\nworld", i.e.
--
-- <pre>
-- hello
-- world
-- </pre>
data Doc
-- | The action <tt>(putDoc doc)</tt> pretty prints document <tt>doc</tt>
-- to the standard output, with a page width of 100 characters and a
-- ribbon width of 40 characters.
--
-- <pre>
-- main :: IO ()
-- main = do{ putDoc (text "hello" <+> text "world") }
-- </pre>
--
-- Which would output
--
-- <pre>
-- hello world
-- </pre>
--
-- Any ANSI colorisation in <tt>doc</tt> will be output.
putDoc :: Doc -> IO ()
-- | <tt>(hPutDoc handle doc)</tt> pretty prints document <tt>doc</tt> to
-- the file handle <tt>handle</tt> with a page width of 100 characters
-- and a ribbon width of 40 characters.
--
-- <pre>
-- main = do{ handle <- openFile "MyFile" WriteMode
-- ; hPutDoc handle (vcat (map text
-- ["vertical","text"]))
-- ; hClose handle
-- }
-- </pre>
--
-- Any ANSI colorisation in <tt>doc</tt> will be output.
hPutDoc :: Handle -> Doc -> IO ()
-- | The empty document is, indeed, empty. Although <tt>empty</tt> has no
-- content, it does have a 'height' of 1 and behaves exactly like
-- <tt>(text "")</tt> (and is therefore not a unit of
-- <tt><$></tt>).
empty :: Doc
-- | The document <tt>(char c)</tt> contains the literal character
-- <tt>c</tt>. The character shouldn't be a newline (<tt>'\n'</tt>), the
-- function <a>line</a> should be used for line breaks.
char :: Char -> Doc
-- | The document <tt>(text s)</tt> contains the literal string <tt>s</tt>.
-- The string shouldn't contain any newline (<tt>'\n'</tt>) characters.
-- If the string contains newline characters, the function <a>string</a>
-- should be used.
text :: String -> Doc
-- | The document <tt>(x <> y)</tt> concatenates document <tt>x</tt>
-- and document <tt>y</tt>. It is an associative operation having
-- <a>empty</a> as a left and right unit. (infixr 6)
(<>) :: Doc -> Doc -> Doc
-- | The document <tt>(nest i x)</tt> renders document <tt>x</tt> with the
-- current indentation level increased by i (See also <a>hang</a>,
-- <a>align</a> and <a>indent</a>).
--
-- <pre>
-- nest 2 (text "hello" <$> text "world") <$> text "!"
-- </pre>
--
-- outputs as:
--
-- <pre>
-- hello
-- world
-- !
-- </pre>
nest :: Int -> Doc -> Doc
-- | The <tt>line</tt> document advances to the next line and indents to
-- the current nesting level. Document <tt>line</tt> behaves like
-- <tt>(text " ")</tt> if the line break is undone by <a>group</a>.
line :: Doc
-- | The <tt>linebreak</tt> document advances to the next line and indents
-- to the current nesting level. Document <tt>linebreak</tt> behaves like
-- <a>empty</a> if the line break is undone by <a>group</a>.
linebreak :: Doc
-- | The <tt>group</tt> combinator is used to specify alternative layouts.
-- The document <tt>(group x)</tt> undoes all line breaks in document
-- <tt>x</tt>. The resulting line is added to the current line if that
-- fits the page. Otherwise, the document <tt>x</tt> is rendered without
-- any changes.
group :: Doc -> Doc
-- | The document <tt>softline</tt> behaves like <a>space</a> if the
-- resulting output fits the page, otherwise it behaves like <a>line</a>.
--
-- <pre>
-- softline = group line
-- </pre>
softline :: Doc
-- | The document <tt>softbreak</tt> behaves like <a>empty</a> if the
-- resulting output fits the page, otherwise it behaves like <a>line</a>.
--
-- <pre>
-- softbreak = group linebreak
-- </pre>
softbreak :: Doc
-- | A linebreak that will never be flattened; it is guaranteed to render
-- as a newline.
hardline :: Doc
-- | A document that is normally rendered as the first argument, but when
-- flattened, is rendered as the second document.
flatAlt :: Doc -> Doc -> Doc
-- | A slightly smarter rendering algorithm with more lookahead. It
-- provides provide earlier breaking on deeply nested structures For
-- example, consider this python-ish pseudocode:
-- <tt>fun(fun(fun(fun(fun([abcdefg, abcdefg])))))</tt> If we put a
-- softbreak (+ nesting 2) after each open parenthesis, and align the
-- elements of the list to match the opening brackets, this will render
-- with <tt>renderPretty</tt> and a page width of 20 as: <tt>
-- fun(fun(fun(fun(fun([ | abcdef, | abcdef, ] ))))) | </tt> Where the
-- 20c. boundary has been marked with |. Because <tt>renderPretty</tt>
-- only uses one-line lookahead, it sees that the first line fits, and is
-- stuck putting the second and third lines after the 20-c mark. In
-- contrast, <tt>renderSmart</tt> will continue to check that the
-- potential document up to the end of the indentation level. Thus, it
-- will format the document as:
--
-- <tt> fun( | fun( | fun( | fun( | fun([ | abcdef, abcdef, ] | ))))) |
-- </tt> Which fits within the 20c. boundary.
renderSmart :: Float -> Int -> Doc -> SimpleDoc
-- | The document <tt>(align x)</tt> renders document <tt>x</tt> with the
-- nesting level set to the current column. It is used for example to
-- implement <a>hang</a>.
--
-- As an example, we will put a document right above another one,
-- regardless of the current nesting level:
--
-- <pre>
-- x $$ y = align (x <$> y)
-- </pre>
--
-- <pre>
-- test = text "hi" <+> (text "nice" $$ text "world")
-- </pre>
--
-- which will be layed out as:
--
-- <pre>
-- hi nice
-- world
-- </pre>
align :: Doc -> Doc
-- | The hang combinator implements hanging indentation. The document
-- <tt>(hang i x)</tt> renders document <tt>x</tt> with a nesting level
-- set to the current column plus <tt>i</tt>. The following example uses
-- hanging indentation for some text:
--
-- <pre>
-- test = hang 4 (fillSep (map text
-- (words "the hang combinator indents these words !")))
-- </pre>
--
-- Which lays out on a page with a width of 20 characters as:
--
-- <pre>
-- the hang combinator
-- indents these
-- words !
-- </pre>
--
-- The <tt>hang</tt> combinator is implemented as:
--
-- <pre>
-- hang i x = align (nest i x)
-- </pre>
hang :: Int -> Doc -> Doc
-- | The document <tt>(indent i x)</tt> indents document <tt>x</tt> with
-- <tt>i</tt> spaces.
--
-- <pre>
-- test = indent 4 (fillSep (map text
-- (words "the indent combinator indents these words !")))
-- </pre>
--
-- Which lays out with a page width of 20 as:
--
-- <pre>
-- the indent
-- combinator
-- indents these
-- words !
-- </pre>
indent :: Int -> Doc -> Doc
-- | The document <tt>(encloseSep l r sep xs)</tt> concatenates the
-- documents <tt>xs</tt> separated by <tt>sep</tt> and encloses the
-- resulting document by <tt>l</tt> and <tt>r</tt>. The documents are
-- rendered horizontally if that fits the page. Otherwise they are
-- aligned vertically. All separators are put in front of the elements.
-- For example, the combinator <a>list</a> can be defined with
-- <tt>encloseSep</tt>:
--
-- <pre>
-- list xs = encloseSep lbracket rbracket comma xs
-- test = text "list" <+> (list (map int [10,200,3000]))
-- </pre>
--
-- Which is layed out with a page width of 20 as:
--
-- <pre>
-- list [10,200,3000]
-- </pre>
--
-- But when the page width is 15, it is layed out as:
--
-- <pre>
-- list [10
-- ,200
-- ,3000]
-- </pre>
encloseSep :: Doc -> Doc -> Doc -> [Doc] -> Doc
-- | The document <tt>(list xs)</tt> comma separates the documents
-- <tt>xs</tt> and encloses them in square brackets. The documents are
-- rendered horizontally if that fits the page. Otherwise they are
-- aligned vertically. All comma separators are put in front of the
-- elements.
list :: [Doc] -> Doc
-- | The document <tt>(tupled xs)</tt> comma separates the documents
-- <tt>xs</tt> and encloses them in parenthesis. The documents are
-- rendered horizontally if that fits the page. Otherwise they are
-- aligned vertically. All comma separators are put in front of the
-- elements.
tupled :: [Doc] -> Doc
-- | The document <tt>(semiBraces xs)</tt> separates the documents
-- <tt>xs</tt> 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.
semiBraces :: [Doc] -> Doc
-- | The document <tt>(x <+> y)</tt> concatenates document <tt>x</tt>
-- and <tt>y</tt> with a <tt>space</tt> in between. (infixr 6)
(<+>) :: Doc -> Doc -> Doc
-- | The document <tt>(x <$> y)</tt> concatenates document <tt>x</tt>
-- and <tt>y</tt> with a <a>line</a> in between. (infixr 5)
(<$>) :: Doc -> Doc -> Doc
-- | The document <tt>(x </> y)</tt> concatenates document <tt>x</tt>
-- and <tt>y</tt> with a <a>softline</a> in between. This effectively
-- puts <tt>x</tt> and <tt>y</tt> either next to each other (with a
-- <tt>space</tt> in between) or underneath each other. (infixr 5)
(</>) :: Doc -> Doc -> Doc
-- | The document <tt>(x <$$> y)</tt> concatenates document
-- <tt>x</tt> and <tt>y</tt> with a <tt>linebreak</tt> in between.
-- (infixr 5)
(<$$>) :: Doc -> Doc -> Doc
-- | The document <tt>(x <//> y)</tt> concatenates document
-- <tt>x</tt> and <tt>y</tt> with a <a>softbreak</a> in between. This
-- effectively puts <tt>x</tt> and <tt>y</tt> either right next to each
-- other or underneath each other. (infixr 5)
(<//>) :: Doc -> Doc -> Doc
-- | The document <tt>(hsep xs)</tt> concatenates all documents <tt>xs</tt>
-- horizontally with <tt>(<+>)</tt>.
hsep :: [Doc] -> Doc
-- | The document <tt>(vsep xs)</tt> concatenates all documents <tt>xs</tt>
-- vertically with <tt>(<$>)</tt>. If a <a>group</a> undoes the
-- line breaks inserted by <tt>vsep</tt>, all documents are separated
-- with a space.
--
-- <pre>
-- someText = map text (words ("text to lay out"))
--
-- test = text "some" <+> vsep someText
-- </pre>
--
-- This is layed out as:
--
-- <pre>
-- some text
-- to
-- lay
-- out
-- </pre>
--
-- The <a>align</a> combinator can be used to align the documents under
-- their first element
--
-- <pre>
-- test = text "some" <+> align (vsep someText)
-- </pre>
--
-- Which is printed as:
--
-- <pre>
-- some text
-- to
-- lay
-- out
-- </pre>
vsep :: [Doc] -> Doc
-- | The document <tt>(fillSep xs)</tt> concatenates documents <tt>xs</tt>
-- horizontally with <tt>(<+>)</tt> as long as its fits the page,
-- than inserts a <tt>line</tt> and continues doing that for all
-- documents in <tt>xs</tt>.
--
-- <pre>
-- fillSep xs = foldr (\<\/\>) empty xs
-- </pre>
fillSep :: [Doc] -> Doc
-- | The document <tt>(sep xs)</tt> concatenates all documents <tt>xs</tt>
-- either horizontally with <tt>(<+>)</tt>, if it fits the page, or
-- vertically with <tt>(<$>)</tt>.
--
-- <pre>
-- sep xs = group (vsep xs)
-- </pre>
sep :: [Doc] -> Doc
-- | The document <tt>(hcat xs)</tt> concatenates all documents <tt>xs</tt>
-- horizontally with <tt>(<>)</tt>.
hcat :: [Doc] -> Doc
-- | The document <tt>(vcat xs)</tt> concatenates all documents <tt>xs</tt>
-- vertically with <tt>(<$$>)</tt>. If a <a>group</a> undoes the
-- line breaks inserted by <tt>vcat</tt>, all documents are directly
-- concatenated.
vcat :: [Doc] -> Doc
-- | The document <tt>(fillCat xs)</tt> concatenates documents <tt>xs</tt>
-- horizontally with <tt>(<>)</tt> as long as its fits the page,
-- than inserts a <tt>linebreak</tt> and continues doing that for all
-- documents in <tt>xs</tt>.
--
-- <pre>
-- fillCat xs = foldr (\<\/\/\>) empty xs
-- </pre>
fillCat :: [Doc] -> Doc
-- | The document <tt>(cat xs)</tt> concatenates all documents <tt>xs</tt>
-- either horizontally with <tt>(<>)</tt>, if it fits the page, or
-- vertically with <tt>(<$$>)</tt>.
--
-- <pre>
-- cat xs = group (vcat xs)
-- </pre>
cat :: [Doc] -> Doc
-- | <tt>(punctuate p xs)</tt> concatenates all documents in <tt>xs</tt>
-- with document <tt>p</tt> except for the last document.
--
-- <pre>
-- someText = map text ["words","in","a","tuple"]
-- test = parens (align (cat (punctuate comma someText)))
-- </pre>
--
-- This is layed out on a page width of 20 as:
--
-- <pre>
-- (words,in,a,tuple)
-- </pre>
--
-- But when the page width is 15, it is layed out as:
--
-- <pre>
-- (words,
-- in,
-- a,
-- tuple)
-- </pre>
--
-- (If you want put the commas in front of their elements instead of at
-- the end, you should use <a>tupled</a> or, in general,
-- <a>encloseSep</a>.)
punctuate :: Doc -> [Doc] -> [Doc]
-- | The document <tt>(fill i x)</tt> renders document <tt>x</tt>. It than
-- appends <tt>space</tt>s until the width is equal to <tt>i</tt>. If the
-- width of <tt>x</tt> is already larger, nothing is appended. This
-- combinator is quite useful in practice to output a list of bindings.
-- The following example demonstrates this.
--
-- <pre>
-- 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))
-- </pre>
--
-- Which is layed out as:
--
-- <pre>
-- let empty :: Doc
-- nest :: Int -> Doc -> Doc
-- linebreak :: Doc
-- </pre>
fill :: Int -> Doc -> Doc
-- | The document <tt>(fillBreak i x)</tt> first renders document
-- <tt>x</tt>. It than appends <tt>space</tt>s until the width is equal
-- to <tt>i</tt>. If the width of <tt>x</tt> is already larger than
-- <tt>i</tt>, the nesting level is increased by <tt>i</tt> and a
-- <tt>line</tt> is appended. When we redefine <tt>ptype</tt> in the
-- previous example to use <tt>fillBreak</tt>, we get a useful variation
-- of the previous output:
--
-- <pre>
-- ptype (name,tp)
-- = fillBreak 6 (text name) <+> text "::" <+> text tp
-- </pre>
--
-- The output will now be:
--
-- <pre>
-- let empty :: Doc
-- nest :: Int -> Doc -> Doc
-- linebreak
-- :: Doc
-- </pre>
fillBreak :: Int -> Doc -> Doc
-- | The document <tt>(enclose l r x)</tt> encloses document <tt>x</tt>
-- between documents <tt>l</tt> and <tt>r</tt> using <tt>(<>)</tt>.
--
-- <pre>
-- enclose l r x = l <> x <> r
-- </pre>
enclose :: Doc -> Doc -> Doc -> Doc
-- | Document <tt>(squotes x)</tt> encloses document <tt>x</tt> with single
-- quotes "'".
squotes :: Doc -> Doc
-- | Document <tt>(dquotes x)</tt> encloses document <tt>x</tt> with double
-- quotes '"'.
dquotes :: Doc -> Doc
-- | Document <tt>(parens x)</tt> encloses document <tt>x</tt> in
-- parenthesis, "(" and ")".
parens :: Doc -> Doc
-- | Document <tt>(angles x)</tt> encloses document <tt>x</tt> in angles,
-- "<" and ">".
angles :: Doc -> Doc
-- | Document <tt>(braces x)</tt> encloses document <tt>x</tt> in braces,
-- "{" and "}".
braces :: Doc -> Doc
-- | Document <tt>(brackets x)</tt> encloses document <tt>x</tt> in square
-- brackets, "[" and "]".
brackets :: Doc -> Doc
-- | The document <tt>lparen</tt> contains a left parenthesis, "(".
lparen :: Doc
-- | The document <tt>rparen</tt> contains a right parenthesis, ")".
rparen :: Doc
-- | The document <tt>langle</tt> contains a left angle, "<".
langle :: Doc
-- | The document <tt>rangle</tt> contains a right angle, ">".
rangle :: Doc
-- | The document <tt>lbrace</tt> contains a left brace, "{".
lbrace :: Doc
-- | The document <tt>rbrace</tt> contains a right brace, "}".
rbrace :: Doc
-- | The document <tt>lbracket</tt> contains a left square bracket, "[".
lbracket :: Doc
-- | The document <tt>rbracket</tt> contains a right square bracket, "]".
rbracket :: Doc
-- | The document <tt>squote</tt> contains a single quote, "'".
squote :: Doc
-- | The document <tt>dquote</tt> contains a double quote, '"'.
dquote :: Doc
-- | The document <tt>semi</tt> contains a semi colon, ";".
semi :: Doc
-- | The document <tt>colon</tt> contains a colon, ":".
colon :: Doc
-- | The document <tt>comma</tt> contains a comma, ",".
comma :: Doc
-- | The document <tt>space</tt> contains a single space, " ".
--
-- <pre>
-- x <+> y = x <> space <> y
-- </pre>
space :: Doc
-- | The document <tt>dot</tt> contains a single dot, ".".
dot :: Doc
-- | The document <tt>backslash</tt> contains a back slash, "\".
backslash :: Doc
-- | The document <tt>equals</tt> contains an equal sign, "=".
equals :: Doc
-- | Displays a document with the black forecolor
black :: Doc -> Doc
-- | Displays a document with the red forecolor
red :: Doc -> Doc
-- | Displays a document with the green forecolor
green :: Doc -> Doc
-- | Displays a document with the yellow forecolor
yellow :: Doc -> Doc
-- | Displays a document with the blue forecolor
blue :: Doc -> Doc
-- | Displays a document with the magenta forecolor
magenta :: Doc -> Doc
-- | Displays a document with the cyan forecolor
cyan :: Doc -> Doc
-- | Displays a document with the white forecolor
white :: Doc -> Doc
-- | Displays a document with the dull black forecolor
dullblack :: Doc -> Doc
-- | Displays a document with the dull red forecolor
dullred :: Doc -> Doc
-- | Displays a document with the dull green forecolor
dullgreen :: Doc -> Doc
-- | Displays a document with the dull yellow forecolor
dullyellow :: Doc -> Doc
-- | Displays a document with the dull blue forecolor
dullblue :: Doc -> Doc
-- | Displays a document with the dull magenta forecolor
dullmagenta :: Doc -> Doc
-- | Displays a document with the dull cyan forecolor
dullcyan :: Doc -> Doc
-- | Displays a document with the dull white forecolor
dullwhite :: Doc -> Doc
-- | Displays a document with the black backcolor
onblack :: Doc -> Doc
-- | Displays a document with the red backcolor
onred :: Doc -> Doc
-- | Displays a document with the green backcolor
ongreen :: Doc -> Doc
-- | Displays a document with the yellow backcolor
onyellow :: Doc -> Doc
-- | Displays a document with the blue backcolor
onblue :: Doc -> Doc
-- | Displays a document with the magenta backcolor
onmagenta :: Doc -> Doc
-- | Displays a document with the cyan backcolor
oncyan :: Doc -> Doc
-- | Displays a document with the white backcolor
onwhite :: Doc -> Doc
-- | Displays a document with the dull block backcolor
ondullblack :: Doc -> Doc
-- | Displays a document with the dull red backcolor
ondullred :: Doc -> Doc
-- | Displays a document with the dull green backcolor
ondullgreen :: Doc -> Doc
-- | Displays a document with the dull yellow backcolor
ondullyellow :: Doc -> Doc
-- | Displays a document with the dull blue backcolor
ondullblue :: Doc -> Doc
-- | Displays a document with the dull magenta backcolor
ondullmagenta :: Doc -> Doc
-- | Displays a document with the dull cyan backcolor
ondullcyan :: Doc -> Doc
-- | Displays a document with the dull white backcolor
ondullwhite :: Doc -> Doc
-- | Displays a document in a heavier font weight
bold :: Doc -> Doc
-- | Displays a document in the normal font weight
debold :: Doc -> Doc
-- | Displays a document with underlining
underline :: Doc -> Doc
-- | Displays a document with no underlining
deunderline :: Doc -> Doc
-- | Removes all colorisation, emboldening and underlining from a document
plain :: Doc -> Doc
-- | The document <tt>(string s)</tt> concatenates all characters in
-- <tt>s</tt> using <tt>line</tt> for newline characters and
-- <tt>char</tt> for all other characters. It is used instead of
-- <a>text</a> whenever the text contains newline characters.
string :: String -> Doc
-- | The document <tt>(int i)</tt> shows the literal integer <tt>i</tt>
-- using <a>text</a>.
int :: Int -> Doc
-- | The document <tt>(integer i)</tt> shows the literal integer <tt>i</tt>
-- using <a>text</a>.
integer :: Integer -> Doc
-- | The document <tt>(float f)</tt> shows the literal float <tt>f</tt>
-- using <a>text</a>.
float :: Float -> Doc
-- | The document <tt>(double d)</tt> shows the literal double <tt>d</tt>
-- using <a>text</a>.
double :: Double -> Doc
-- | The document <tt>(rational r)</tt> shows the literal rational
-- <tt>r</tt> using <a>text</a>.
rational :: Rational -> Doc
-- | The member <tt>prettyList</tt> is only used to define the <tt>instance
-- Pretty a => Pretty [a]</tt>. In normal circumstances only the
-- <tt>pretty</tt> function is used.
class Pretty a where prettyList = list . map pretty
pretty :: Pretty a => a -> Doc
prettyList :: Pretty a => [a] -> Doc
-- | The data type <tt>SimpleDoc</tt> represents rendered documents and is
-- used by the display functions.
--
-- The <tt>Int</tt> in <tt>SText</tt> contains the length of the string.
-- The <tt>Int</tt> in <tt>SLine</tt> contains the indentation for that
-- line. The library provides two default display functions
-- <a>displayS</a> and <a>displayIO</a>. You can provide your own display
-- function by writing a function from a <tt>SimpleDoc</tt> to your own
-- output format.
data SimpleDoc
SFail :: SimpleDoc
SEmpty :: SimpleDoc
SChar :: Char -> SimpleDoc -> SimpleDoc
SText :: !Int -> String -> SimpleDoc -> SimpleDoc
SLine :: !Int -> SimpleDoc -> SimpleDoc
SSGR :: [SGR] -> SimpleDoc -> SimpleDoc
-- | This is the default pretty printer which is used by <a>show</a>,
-- <a>putDoc</a> and <a>hPutDoc</a>. <tt>(renderPretty ribbonfrac width
-- x)</tt> renders document <tt>x</tt> with a page width of
-- <tt>width</tt> and a ribbon width of <tt>(ribbonfrac * width)</tt>
-- characters. The ribbon width is the maximal amount of non-indentation
-- characters on a line. The parameter <tt>ribbonfrac</tt> should be
-- between <tt>0.0</tt> and <tt>1.0</tt>. If it is lower or higher, the
-- ribbon width will be 0 or <tt>width</tt> respectively.
renderPretty :: Float -> Int -> Doc -> SimpleDoc
-- | <tt>(renderCompact x)</tt> renders document <tt>x</tt> without adding
-- any indentation. Since no 'pretty' printing is involved, this renderer
-- is very fast. The resulting output contains fewer characters than a
-- pretty printed version and can be used for output that is read by
-- other programs.
--
-- This rendering function does not add any colorisation information.
renderCompact :: Doc -> SimpleDoc
-- | <tt>(displayS simpleDoc)</tt> takes the output <tt>simpleDoc</tt> from
-- a rendering function and transforms it to a <a>ShowS</a> type (for use
-- in the <a>Show</a> class).
--
-- <pre>
-- showWidth :: Int -> Doc -> String
-- showWidth w x = displayS (renderPretty 0.4 w x) ""
-- </pre>
--
-- ANSI color information will be discarded by this function unless you
-- are running on a Unix-like operating system. This is due to a
-- technical limitation in Windows ANSI support.
displayS :: SimpleDoc -> ShowS
-- | <tt>(displayIO handle simpleDoc)</tt> writes <tt>simpleDoc</tt> to the
-- file handle <tt>handle</tt>. This function is used for example by
-- <a>hPutDoc</a>:
--
-- <pre>
-- hPutDoc handle doc = displayIO handle (renderPretty 0.4 100 doc)
-- </pre>
--
-- Any ANSI colorisation in <tt>simpleDoc</tt> will be output.
displayIO :: Handle -> SimpleDoc -> IO ()
bool :: Bool -> Doc
column :: (Int -> Doc) -> Doc
columns :: (Maybe Int -> Doc) -> Doc
nesting :: (Int -> Doc) -> Doc
width :: Doc -> (Int -> Doc) -> Doc
instance Show Doc
instance IsString Doc
instance Monoid Doc
instance Pretty a => Pretty (Maybe a)
instance (Pretty a, Pretty b, Pretty c) => Pretty (a, b, c)
instance (Pretty a, Pretty b) => Pretty (a, b)
instance Pretty Double
instance Pretty Float
instance Pretty Integer
instance Pretty Int
instance Pretty Char
instance Pretty Bool
instance Pretty ()
instance Pretty Doc
instance Pretty a => Pretty [a]
