Text.PrettyPrint.Mainland.Class

This module is based on A Prettier Printer by Phil Wadler in The Fun of Programming, Jeremy Gibbons and Oege de Moor (eds) http://homepages.inf.ed.ac.uk/wadler/papers/prettier/prettier.pdf

At the time it was originally written I didn't know about Daan Leijen's pretty printing module based on the same paper. I have since incorporated many of his improvements. This module is geared towards pretty printing source code; its main advantages over other libraries are the ability to automatically track the source locations associated with pretty printed values and output appropriate #line pragmas and the use of Text for output.

The Pretty type class for pretty printing

class Pretty a where

Minimal complete definition

pprPrec | ppr

Methods

ppr :: a -> Doc

pprPrec :: Int -> a -> Doc

pprList :: [a] -> Doc

Instances

Pretty Bool

Methods

ppr :: Bool -> Doc

pprPrec :: Int -> Bool -> Doc

pprList :: [Bool] -> Doc

Pretty Char

Methods

ppr :: Char -> Doc

pprPrec :: Int -> Char -> Doc

pprList :: [Char] -> Doc

Pretty Double

Methods

ppr :: Double -> Doc

pprPrec :: Int -> Double -> Doc

pprList :: [Double] -> Doc

Pretty Float

Methods

ppr :: Float -> Doc

pprPrec :: Int -> Float -> Doc

pprList :: [Float] -> Doc

Pretty Int

Methods

ppr :: Int -> Doc

pprPrec :: Int -> Int -> Doc

pprList :: [Int] -> Doc

Pretty Int8

Methods

ppr :: Int8 -> Doc

pprPrec :: Int -> Int8 -> Doc

pprList :: [Int8] -> Doc

Pretty Int16

Methods

ppr :: Int16 -> Doc

pprPrec :: Int -> Int16 -> Doc

pprList :: [Int16] -> Doc

Pretty Int32

Methods

ppr :: Int32 -> Doc

pprPrec :: Int -> Int32 -> Doc

pprList :: [Int32] -> Doc

Pretty Int64

Methods

ppr :: Int64 -> Doc

pprPrec :: Int -> Int64 -> Doc

pprList :: [Int64] -> Doc

Pretty Integer

Methods

ppr :: Integer -> Doc

pprPrec :: Int -> Integer -> Doc

pprList :: [Integer] -> Doc

Pretty Word8

Methods

ppr :: Word8 -> Doc

pprPrec :: Int -> Word8 -> Doc

pprList :: [Word8] -> Doc

Pretty Word16

Methods

ppr :: Word16 -> Doc

pprPrec :: Int -> Word16 -> Doc

pprList :: [Word16] -> Doc

Pretty Word32

Methods

ppr :: Word32 -> Doc

pprPrec :: Int -> Word32 -> Doc

pprList :: [Word32] -> Doc

Pretty Word64

Methods

ppr :: Word64 -> Doc

pprPrec :: Int -> Word64 -> Doc

pprList :: [Word64] -> Doc

Pretty ()

Methods

ppr :: () -> Doc

pprPrec :: Int -> () -> Doc

pprList :: [()] -> Doc

Pretty Pos

Methods

ppr :: Pos -> Doc

pprPrec :: Int -> Pos -> Doc

pprList :: [Pos] -> Doc

Pretty Loc

Methods

ppr :: Loc -> Doc

pprPrec :: Int -> Loc -> Doc

pprList :: [Loc] -> Doc

Pretty Text

Methods

ppr :: Text -> Doc

pprPrec :: Int -> Text -> Doc

pprList :: [Text] -> Doc

Pretty Text

Methods

ppr :: Text -> Doc

pprPrec :: Int -> Text -> Doc

pprList :: [Text] -> Doc

Pretty Doc

Methods

ppr :: Doc -> Doc

pprPrec :: Int -> Doc -> Doc

pprList :: [Doc] -> Doc

Pretty a => Pretty [a]

Methods

ppr :: [a] -> Doc

pprPrec :: Int -> [a] -> Doc

pprList :: [[a]] -> Doc

Pretty a => Pretty (Maybe a)

Methods

ppr :: Maybe a -> Doc

pprPrec :: Int -> Maybe a -> Doc

pprList :: [Maybe a] -> Doc

(Integral a, Pretty a) => Pretty (Ratio a)

Methods

ppr :: Ratio a -> Doc

pprPrec :: Int -> Ratio a -> Doc

pprList :: [Ratio a] -> Doc

(RealFloat a, Pretty a) => Pretty (Complex a)

Methods

ppr :: Complex a -> Doc

pprPrec :: Int -> Complex a -> Doc

pprList :: [Complex a] -> Doc

Pretty a => Pretty (Set a)

Methods

ppr :: Set a -> Doc

pprPrec :: Int -> Set a -> Doc

pprList :: [Set a] -> Doc

Pretty x => Pretty (L x)

Methods

ppr :: L x -> Doc

pprPrec :: Int -> L x -> Doc

pprList :: [L x] -> Doc

(Pretty a, Pretty b) => Pretty (a, b)

Methods

ppr :: (a, b) -> Doc

pprPrec :: Int -> (a, b) -> Doc

pprList :: [(a, b)] -> Doc

(Pretty k, Pretty v) => Pretty (Map k v)

Methods

ppr :: Map k v -> Doc

pprPrec :: Int -> Map k v -> Doc

pprList :: [Map k v] -> Doc

(Pretty a, Pretty b, Pretty c) => Pretty (a, b, c)

Methods

ppr :: (a, b, c) -> Doc

pprPrec :: Int -> (a, b, c) -> Doc

pprList :: [(a, b, c)] -> Doc

(Pretty a, Pretty b, Pretty c, Pretty d) => Pretty (a, b, c, d)

Methods

ppr :: (a, b, c, d) -> Doc

pprPrec :: Int -> (a, b, c, d) -> Doc

pprList :: [(a, b, c, d)] -> Doc

(Pretty a, Pretty b, Pretty c, Pretty d, Pretty e) => Pretty (a, b, c, d, e)

Methods

ppr :: (a, b, c, d, e) -> Doc

pprPrec :: Int -> (a, b, c, d, e) -> Doc

pprList :: [(a, b, c, d, e)] -> Doc

(Pretty a, Pretty b, Pretty c, Pretty d, Pretty e, Pretty f) => Pretty (a, b, c, d, e, f)

Methods

ppr :: (a, b, c, d, e, f) -> Doc

pprPrec :: Int -> (a, b, c, d, e, f) -> Doc

pprList :: [(a, b, c, d, e, f)] -> Doc

(Pretty a, Pretty b, Pretty c, Pretty d, Pretty e, Pretty f, Pretty g) => Pretty (a, b, c, d, e, f, g)

Methods

ppr :: (a, b, c, d, e, f, g) -> Doc

pprPrec :: Int -> (a, b, c, d, e, f, g) -> Doc

pprList :: [(a, b, c, d, e, f, g)] -> Doc

(Pretty a, Pretty b, Pretty c, Pretty d, Pretty e, Pretty f, Pretty g, Pretty h) => Pretty (a, b, c, d, e, f, g, h)

Methods

ppr :: (a, b, c, d, e, f, g, h) -> Doc

pprPrec :: Int -> (a, b, c, d, e, f, g, h) -> Doc

pprList :: [(a, b, c, d, e, f, g, h)] -> Doc

(Pretty a, Pretty b, Pretty c, Pretty d, Pretty e, Pretty f, Pretty g, Pretty h, Pretty i) => Pretty (a, b, c, d, e, f, g, h, i)

Methods

ppr :: (a, b, c, d, e, f, g, h, i) -> Doc

pprPrec :: Int -> (a, b, c, d, e, f, g, h, i) -> Doc

pprList :: [(a, b, c, d, e, f, g, h, i)] -> Doc

(Pretty a, Pretty b, Pretty c, Pretty d, Pretty e, Pretty f, Pretty g, Pretty h, Pretty i, Pretty j) => Pretty (a, b, c, d, e, f, g, h, i, j)

Methods

ppr :: (a, b, c, d, e, f, g, h, i, j) -> Doc

pprPrec :: Int -> (a, b, c, d, e, f, g, h, i, j) -> Doc

pprList :: [(a, b, c, d, e, f, g, h, i, j)] -> Doc

(Pretty a, Pretty b, Pretty c, Pretty d, Pretty e, Pretty f, Pretty g, Pretty h, Pretty i, Pretty j, Pretty k) => Pretty (a, b, c, d, e, f, g, h, i, j, k)

Methods

ppr :: (a, b, c, d, e, f, g, h, i, j, k) -> Doc

pprPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k) -> Doc

pprList :: [(a, b, c, d, e, f, g, h, i, j, k)] -> Doc

(Pretty a, Pretty b, Pretty c, Pretty d, Pretty e, Pretty f, Pretty g, Pretty h, Pretty i, Pretty j, Pretty k, Pretty l) => Pretty (a, b, c, d, e, f, g, h, i, j, k, l)

Methods

ppr :: (a, b, c, d, e, f, g, h, i, j, k, l) -> Doc

pprPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Doc

pprList :: [(a, b, c, d, e, f, g, h, i, j, k, l)] -> Doc

(Pretty a, Pretty b, Pretty c, Pretty d, Pretty e, Pretty f, Pretty g, Pretty h, Pretty i, Pretty j, Pretty k, Pretty l, Pretty m) => Pretty (a, b, c, d, e, f, g, h, i, j, k, l, m)

Methods

ppr :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Doc

pprPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Doc

pprList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m)] -> Doc

(Pretty a, Pretty b, Pretty c, Pretty d, Pretty e, Pretty f, Pretty g, Pretty h, Pretty i, Pretty j, Pretty k, Pretty l, Pretty m, Pretty n) => Pretty (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

Methods

ppr :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Doc

pprPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Doc

pprList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)] -> Doc

(Pretty a, Pretty b, Pretty c, Pretty d, Pretty e, Pretty f, Pretty g, Pretty h, Pretty i, Pretty j, Pretty k, Pretty l, Pretty m, Pretty n, Pretty o) => Pretty (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

Methods

ppr :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Doc

pprPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Doc

pprList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)] -> Doc

pprint :: (Pretty a, MonadIO m) => a -> m ()

The pprint function outputs a value of any type that is an instance of Pretty to the standard output device by calling ppr and adding a newline.