-- Hoogle documentation, generated by Haddock -- See Hoogle, http://www.haskell.org/hoogle/ -- | Pretty-printing library -- -- This package contains a pretty-printing library, a set of API's that -- provides a way to easily print out text in a consistent format of your -- choosing. This is useful for compilers and related tools. -- -- This library produces more compact outputs than both Wadler-Leijen or -- Hughes-PJ algorithms, at the expense of computational ressources. The -- API is the same as Wadler-Leijen's. @package pretty-compact @version 1.0 module Text.PrettyPrint.Compact.Core data Doc Empty :: Doc Text :: Box -> Doc Line :: !Bool -> Doc Cat :: Doc -> Doc -> Doc Nest :: Indentation -> Doc -> Doc Union :: Doc -> Doc -> Doc Column :: (Indentation -> Doc) -> Doc Nesting :: (Indentation -> Doc) -> Doc render :: Double -> Indentation -> Doc -> String group :: Doc -> Doc flatten :: Doc -> Doc space :: Doc spacing :: Indentation -> Doc text :: String -> Doc instance Show Doc instance Ord Process instance Eq Process instance Monoid Doc instance IsString Doc module Text.PrettyPrint.Compact data Doc mempty :: Monoid a => a char :: Char -> Doc text :: String -> Doc (<>) :: Monoid m => m -> m -> m -- | The document (nest i x) renders document x 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
--   !
--

nest :: Indentation -> Doc -> Doc -- | The line document 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. line :: Doc -- | The linebreak document advances to the next line and indents -- to the current nesting level. Document linebreak behaves like -- empty if the line break is undone by group. linebreak :: Doc group :: Doc -> Doc -- | The document softline behaves like space if the -- resulting output fits the page, otherwise it behaves like line. -- --

--   softline = group line
--

softline :: Doc -- | The document softbreak behaves like empty if the -- resulting output fits the page, otherwise it behaves like line. -- --

--   softbreak  = group linebreak
--

softbreak :: Doc -- | The document (align x) renders document x 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
--

align :: Doc -> Doc -- | The hang combinator implements hanging indentation. The document -- (hang i x) renders document x 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)
--

hang :: Indentation -> Doc -> Doc -- | The document (indent i x) indents document x 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 !
--

indent :: Indentation -> Doc -> Doc -- | The document (enclosure l r sep xs) concatenates the -- documents xs separated by sep 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 separators are put in front of the elements. -- For example, the combinator list can be defined with -- enclosure: -- --

--   list xs = enclosure 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]
--

encloseSep :: Doc -> Doc -> Doc -> [Doc] -> Doc -- | The document (list xs) comma separates 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 separators are put in front of the -- elements. list :: [Doc] -> Doc -- | The document (tupled xs) comma separates 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 separators are put in front of the -- elements. tupled :: [Doc] -> Doc -- | The document (semiBraces xs) separates 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. semiBraces :: [Doc] -> Doc -- | The document (x <+> y) concatenates document x -- and y with a space in between. (infixr 6) (<+>) :: Doc -> Doc -> Doc (<$>) :: Functor f => (a -> b) -> f a -> f b -- | The document (x </> y) concatenates document x -- and y with a softline in between. This effectively -- puts x and y either next to each other (with a -- space in between) or underneath each other. (infixr 5) () :: Doc -> Doc -> Doc -- | The document (x <$$> y) concatenates document -- x and y with a linebreak in between. -- (infixr 5) (<$$>) :: Doc -> Doc -> Doc -- | The document (x <//> y) concatenates document -- x and y with a softbreak in between. This -- effectively puts x and y either right next to each -- other or underneath each other. (infixr 5) () :: Doc -> Doc -> Doc -- | The document (hsep xs) concatenates all documents xs -- horizontally with (<+>). hsep :: [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)
--

-- -- Which is printed as: -- --

--   some text
--        to
--        lay
--        out
--

vsep :: [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
--

fillSep :: [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)
--

sep :: [Doc] -> Doc -- | The document (hcat xs) concatenates all documents xs -- horizontally with (<>). hcat :: [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. vcat :: [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
--

fillCat :: [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)
--

cat :: [Doc] -> Doc -- | (punctuate p xs) concatenates all documents in 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.) punctuate :: Doc -> [Doc] -> [Doc] -- | The document (fill i x) renders document x. It than -- appends spaces until the width is equal to i. If the -- width of x 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","Indentation -> 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   :: Indentation -> Doc -> Doc
--       linebreak :: Doc
--

fill :: Indentation -> Doc -> Doc -- | The document (fillBreak i x) first renders document -- x. It than appends spaces until the width is equal -- to i. If the width of x 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   :: Indentation -> Doc -> Doc
--       linebreak
--              :: Doc
--

fillBreak :: Indentation -> Doc -> Doc -- | The document (enclose l r x) encloses document x -- between documents l and r using (<>). enclose :: Doc -> Doc -> Doc -> Doc -- | Document (squotes x) encloses document x with single -- quotes "'". squotes :: Doc -> Doc -- | Document (dquotes x) encloses document x with double -- quotes '"'. dquotes :: Doc -> Doc -- | Document (parens x) encloses document x in -- parenthesis, "(" and ")". parens :: Doc -> Doc -- | Document (angles x) encloses document x in angles, -- "<" and ">". angles :: Doc -> Doc -- | Document (braces x) encloses document x in braces, -- "{" and "}". braces :: Doc -> Doc -- | Document (brackets x) encloses document x in square -- brackets, "[" and "]". brackets :: Doc -> Doc -- | The document lparen contains a left parenthesis, "(". lparen :: Doc -- | The document rparen contains a right parenthesis, ")". rparen :: Doc -- | The document langle contains a left angle, "<". langle :: Doc -- | The document rangle contains a right angle, ">". rangle :: Doc -- | The document lbrace contains a left brace, "{". lbrace :: Doc -- | The document rbrace contains a right brace, "}". rbrace :: Doc -- | The document lbracket contains a left square bracket, "[". lbracket :: Doc -- | The document rbracket contains a right square bracket, "]". rbracket :: Doc -- | The document squote contains a single quote, "'". squote :: Doc -- | The document dquote contains a double quote, '"'. dquote :: Doc -- | The document semi contains a semi colon, ";". semi :: Doc -- | The document colon contains a colon, ":". colon :: Doc -- | The document comma contains a comma, ",". comma :: Doc space :: Doc -- | The document dot contains a single dot, ".". dot :: Doc -- | The document backslash contains a back slash, "\". backslash :: Doc -- | The document equals contains an equal sign, "=". equals :: 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. string :: String -> Doc -- | The document (int i) shows the literal integer i -- using text. int :: Int -> Doc -- | The document (integer i) shows the literal integer i -- using text. integer :: Integer -> Doc -- | The document (float f) shows the literal float f -- using text. float :: Float -> Doc -- | The document (double d) shows the literal double d -- using text. double :: Double -> Doc -- | The document (rational r) shows the literal rational -- r using text. rational :: Rational -> Doc bool :: Bool -> Doc render :: Double -> Indentation -> Doc -> String