Text.PrettyPrint.Leijen

Deprecated: Compatibility module for users of wl-pprint - use Data.Text.Prettyprint.Doc instead

Documentation

type Doc = Doc ()

putDoc :: Doc -> IO ()

hPutDoc :: Handle -> Doc -> IO ()

empty :: Doc

char :: Char -> Doc

text :: String -> Doc

(<>) :: Monoid m => m -> m -> m infixr 6

An infix synonym for mappend.

Since: 4.5.0.0

nest :: Int -> Doc -> Doc

line :: Doc

linebreak :: Doc

group :: Doc -> Doc

softline :: Doc

softbreak :: Doc

align :: Doc -> Doc

hang :: Int -> Doc -> Doc

indent :: Int -> Doc -> Doc

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

list :: [Doc] -> Doc

tupled :: [Doc] -> Doc

semiBraces :: [Doc] -> Doc

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

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

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

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

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

hsep :: [Doc] -> Doc

vsep :: [Doc] -> Doc

fillSep :: [Doc] -> Doc

sep :: [Doc] -> Doc

hcat :: [Doc] -> Doc

vcat :: [Doc] -> Doc

fillCat :: [Doc] -> Doc

cat :: [Doc] -> Doc

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

fill :: Int -> Doc -> Doc

fillBreak :: Int -> Doc -> Doc

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

squotes :: Doc -> Doc

dquotes :: Doc -> Doc

parens :: Doc -> Doc

angles :: Doc -> Doc

braces :: Doc -> Doc

brackets :: Doc -> Doc

lparen :: Doc

rparen :: Doc

langle :: Doc

rangle :: Doc

lbrace :: Doc

rbrace :: Doc

lbracket :: Doc

rbracket :: Doc

squote :: Doc

dquote :: Doc

semi :: Doc

colon :: Doc

comma :: Doc

space :: Doc

dot :: Doc

backslash :: Doc

equals :: Doc

string :: String -> Doc

int :: Int -> Doc

integer :: Integer -> Doc

float :: Float -> Doc

double :: Double -> Doc

rational :: Rational -> Doc

class Pretty a where

Overloaded conversion to Doc.

Methods

pretty :: a -> Doc ann

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

prettyList :: [a] -> Doc ann

prettyList is only used to define the instance Pretty a => Pretty [a]. In normal circumstances only the pretty function is used.

>>> prettyList [1, 23, 456]
[1, 23, 456]

Instances

Pretty Bool

>>> pretty True
True

Methods

pretty :: Bool -> Doc ann

prettyList :: [Bool] -> Doc ann

Pretty Char

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

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

Methods

pretty :: Char -> Doc ann

prettyList :: [Char] -> Doc ann

Pretty Double

>>> pretty (exp 1 :: Double)
2.718281828459045

Methods

pretty :: Double -> Doc ann

prettyList :: [Double] -> Doc ann

Pretty Float

>>> pretty (pi :: Float)
3.1415927

Methods

pretty :: Float -> Doc ann

prettyList :: [Float] -> Doc ann

Pretty Int

>>> pretty (123 :: Int)
123

Methods

pretty :: Int -> Doc ann

prettyList :: [Int] -> Doc ann

Pretty Int8

Methods

pretty :: Int8 -> Doc ann

prettyList :: [Int8] -> Doc ann

Pretty Int16

Methods

pretty :: Int16 -> Doc ann

prettyList :: [Int16] -> Doc ann

Pretty Int32

Methods

pretty :: Int32 -> Doc ann

prettyList :: [Int32] -> Doc ann

Pretty Int64

Methods

pretty :: Int64 -> Doc ann

prettyList :: [Int64] -> Doc ann

Pretty Integer

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

Methods

pretty :: Integer -> Doc ann

prettyList :: [Integer] -> Doc ann

Pretty Word

Methods

pretty :: Word -> Doc ann

prettyList :: [Word] -> Doc ann

Pretty Word8

Methods

pretty :: Word8 -> Doc ann

prettyList :: [Word8] -> Doc ann

Pretty Word16

Methods

pretty :: Word16 -> Doc ann

prettyList :: [Word16] -> Doc ann

Pretty Word32

Methods

pretty :: Word32 -> Doc ann

prettyList :: [Word32] -> Doc ann

Pretty Word64

Methods

pretty :: Word64 -> Doc ann

prettyList :: [Word64] -> Doc ann

Pretty ()

>>> pretty ()
()

The argument is not used,

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

Methods

pretty :: () -> Doc ann

prettyList :: [()] -> Doc ann

Pretty Natural

Methods

pretty :: Natural -> Doc ann

prettyList :: [Natural] -> Doc ann

Pretty Void

I tried finding a good example to show here but could not find one

Methods

pretty :: Void -> Doc ann

prettyList :: [Void] -> Doc ann

Pretty Text

(lazy Text instance, identical to the strict version)

Methods

pretty :: Text -> Doc ann

prettyList :: [Text] -> Doc ann

Pretty Text

Automatically converts all newlines to line.

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

Note that line can be undone by group:

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

Manually use hardline if you definitely want newlines.

Methods

pretty :: Text -> Doc ann

prettyList :: [Text] -> Doc ann

Pretty a => Pretty [a]

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

Methods

pretty :: [a] -> Doc ann

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

Pretty a => Pretty (Maybe a)

Ignore Nothings, print Just contents.

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

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

Methods

pretty :: Maybe a -> Doc ann

prettyList :: [Maybe a] -> Doc ann

Pretty a => Pretty (NonEmpty a)

Methods

pretty :: NonEmpty a -> Doc ann

prettyList :: [NonEmpty a] -> Doc ann

Pretty (Doc ann)

Does not change the text, but removes all annotations. Pitfall: since this un-annotates its argument, nesting it means multiple, potentially costly, traversals over the Doc.

>>> pretty 123
123
>>> pretty (pretty 123)
123

Methods

pretty :: Doc ann -> Doc ann

prettyList :: [Doc ann] -> Doc ann

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

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

Methods

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

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

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

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

Methods

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

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

type SimpleDoc = SimpleDoc ()

renderPretty :: Float -> Int -> Doc -> SimpleDoc

renderCompact :: Doc -> SimpleDoc

displayS :: SimpleDoc -> ShowS

displayIO :: Handle -> SimpleDoc -> IO ()

bool :: Bool -> Doc

column :: (Int -> Doc) -> Doc

nesting :: (Int -> Doc) -> Doc

width :: Doc -> (Int -> Doc) -> Doc