-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Haskell2010 structured text formatting
--   
--   A modern take on structured text formatting, also known as
--   pretty-printing. Based on the classic pretty package by Hughes,
--   Peyton-Jones et al.
@package prettify
@version 1.0


-- | This library was based on <i>The Design of a Pretty-printing
--   Library</i> by Jeuring and Meijer.
--   
--   Heavily modified by Simon Peyton Jones (December 1996).
--   
--   Lightly modified by Hans Hoglund (October 2012).
module Text.Pretty

-- | Class of types that can be pretty-printed.
--   
--   The Pretty class is similar to <a>Show</a>, but converts values to
--   <a>Printer</a>s instead of <tt>Strings</tt>. A printer is essentially
--   a string with some extra structural information such as length and
--   indentation.
--   
--   Note that the instances for primitive types, lists and tuples all
--   satisfy
--   
--   <pre>
--   (show . pretty) x == show x
--   </pre>
class Pretty a where prettyList = brackets . sepBy (char ',') . map pretty
pretty :: Pretty a => a -> Printer
prettyList :: Pretty a => [a] -> Printer

-- | The abstract type of printers.
data Printer

-- | A printer of height and width 1, containing a literal character.
char :: Char -> Printer

-- | A printer of height 1 containing a literal string. <a>string</a>
--   satisfies the following laws:
--   
--   <ul>
--   <li><pre><a>string</a> s <a>&lt;&gt;</a> <a>string</a> t =
--   <a>string</a> (s<a>++</a>t)</pre></li>
--   <li><tt><a>string</a> "" <a>&lt;&gt;</a> x = x</tt>, if <tt>x</tt>
--   non-empty</li>
--   </ul>
--   
--   The side condition on the last law is necessary because
--   <tt><a>string</a> ""</tt> has height 1, while <a>empty</a> has no
--   height.
string :: String -> Printer

-- | Some string with any width. (<tt>string s = sizedText (length s)
--   s</tt>)
sizedText :: Int -> String -> Printer

-- | Some string, but without any width. Use for non-printing string such
--   as a HTML or Latex tags
zeroWidthText :: String -> Printer
int :: Int -> Printer
integer :: Integer -> Printer
float :: Float -> Printer
double :: Double -> Printer
rational :: Rational -> Printer

-- | The empty printer, with no height and no width. <a>empty</a> is the
--   identity for <a>&lt;&gt;</a>, <a>&lt;+&gt;</a>, <a>&lt;/&gt;</a> and
--   <a>&lt;//&gt;</a>, and anywhere in the argument list for <a>sep</a>,
--   <a>hcat</a>, <a>hsep</a>, <a>vcat</a>, <a>fcat</a> etc.
empty :: Printer

-- | Beside. <a>&lt;&gt;</a> is associative, with identity <a>empty</a>.
(<->) :: Printer -> Printer -> Printer

-- | Beside, separated by space, unless one of the arguments is
--   <a>empty</a>. <a>&lt;+&gt;</a> is associative, with identity
--   <a>empty</a>.
(<+>) :: Printer -> Printer -> Printer

-- | List version of <a>&lt;&gt;</a>.
hcat :: [Printer] -> Printer

-- | List version of <a>&lt;+&gt;</a>.
hsep :: [Printer] -> Printer

-- | Above, except that if the last line of the first argument stops at
--   least one position before the first line of the second begins, these
--   two lines are overlapped. For example:
--   
--   <pre>
--   string "hi" &lt;/&gt; nest 5 (string "there")
--   </pre>
--   
--   lays out as
--   
--   <pre>
--   hi   there
--   </pre>
--   
--   rather than
--   
--   <pre>
--   hi
--        there
--   </pre>
--   
--   <a>&lt;/&gt;</a> is associative, with identity <a>empty</a>, and also
--   satisfies
--   
--   <ul>
--   <li><tt>(x <a>&lt;/&gt;</a> y) <a>&lt;&gt;</a> z = x <a>&lt;/&gt;</a>
--   (y <a>&lt;&gt;</a> z)</tt>, if <tt>y</tt> non-empty.</li>
--   </ul>
(</>) :: Printer -> Printer -> Printer

-- | Above, with no overlapping. <a>&lt;//&gt;</a> is associative, with
--   identity <a>empty</a>.
(<//>) :: Printer -> Printer -> Printer

-- | List version of <a>&lt;/&gt;</a>.
vcat :: [Printer] -> Printer

-- | Either <a>hsep</a> or <a>vcat</a>.
sep :: [Printer] -> Printer

-- | Either <a>hcat</a> or <a>vcat</a>.
cat :: [Printer] -> Printer

-- | "Paragraph fill" version of <a>sep</a>.
fsep :: [Printer] -> Printer

-- | "Paragraph fill" version of <a>cat</a>.
fcat :: [Printer] -> Printer

-- | Wrap printer in the given characters.
wrap :: Char -> Char -> Printer -> Printer

-- | Wrap printer in <tt>(...)</tt>
parens :: Printer -> Printer

-- | Wrap printer in <tt>[...]</tt>
brackets :: Printer -> Printer

-- | Wrap printer in <tt>{...}</tt>
braces :: Printer -> Printer

-- | Wrap printer in <tt>'...'</tt>
quotes :: Printer -> Printer

-- | Wrap printer in <tt>"..."</tt>
doubleQuotes :: Printer -> Printer

-- | Nest (or indent) a printer by a given number of positions (which may
--   also be negative). <a>nest</a> satisfies the laws:
--   
--   <ul>
--   <li><pre><a>nest</a> 0 x = x</pre></li>
--   <li><pre><a>nest</a> k (<a>nest</a> k' x) = <a>nest</a> (k+k')
--   x</pre></li>
--   <li><pre><a>nest</a> k (x <a>&lt;&gt;</a> y) = <a>nest</a> k z
--   <a>&lt;&gt;</a> <a>nest</a> k y</pre></li>
--   <li><pre><a>nest</a> k (x <a>&lt;/&gt;</a> y) = <a>nest</a> k x
--   <a>&lt;/&gt;</a> <a>nest</a> k y</pre></li>
--   <li><pre><a>nest</a> k <a>empty</a> = <a>empty</a></pre></li>
--   <li><tt>x <a>&lt;&gt;</a> <a>nest</a> k y = x <a>&lt;&gt;</a> y</tt>,
--   if <tt>x</tt> non-empty</li>
--   </ul>
--   
--   The side condition on the last law is needed because <a>empty</a> is a
--   left identity for <a>&lt;&gt;</a>.
nest :: Int -> Printer -> Printer

-- | <pre>
--   hang d1 n d2 = sep [d1, nest n d2]
--   </pre>
hang :: Printer -> Int -> Printer -> Printer

-- | Join with separator.
--   
--   <pre>
--   sepBy q [x1,x2..xn] = x1 &lt;&gt; q &lt;&gt; x2 &lt;&gt; q .. xn.
--   </pre>
sepBy :: Printer -> [Printer] -> Printer

-- | Join with initiator.
--   
--   <pre>
--   initBy q [x1,x2..xn] = q &lt;&gt; x1 &lt;&gt; q &lt;&gt; x2 &lt;&gt; q .. xn.
--   </pre>
initBy :: Printer -> [Printer] -> Printer

-- | Join with terminator.
--   
--   <pre>
--   termBy q [x1,x2..xn] = x1 &lt;&gt; q &lt;&gt; x2 &lt;&gt; q .. xn &lt;&gt; q.
--   </pre>
termBy :: Printer -> [Printer] -> Printer

-- | Join with separator followed by space.
--   
--   <pre>
--   sepByS q [x1,x2..xn] = x1 &lt;&gt; q &lt;+&gt; x2 &lt;&gt; q &lt;+&gt;.. xn.
--   </pre>
sepByS :: Printer -> [Printer] -> Printer

-- | Join with initiator followed by space.
--   
--   <pre>
--   initByS q [x1,x2..xn] = q &lt;+&gt; x1 &lt;&gt; q &lt;+&gt; x2 &lt;&gt; q &lt;+&gt; .. xn.
--   </pre>
initByS :: Printer -> [Printer] -> Printer

-- | Join with terminator followed by space.
--   
--   <pre>
--   termByS q [x1,x2..xn] = x1 &lt;&gt; q &lt;+&gt; x2 &lt;&gt; q &lt;+&gt; .. xn &lt;&gt; q.
--   </pre>
termByS :: Printer -> [Printer] -> Printer

-- | Returns <a>True</a> if the printer is empty
isEmpty :: Printer -> Bool

-- | Render the <tt>Printer</tt> to a String using the default
--   <tt>Style</tt>.
runPrinter :: Printer -> String

-- | Rendering mode.
data Mode

-- | Normal
PageMode :: Mode

-- | With zig-zag cuts
ZigZagMode :: Mode

-- | No indentation, infinitely long lines
LeftMode :: Mode

-- | All on one line
OneLineMode :: Mode

-- | A printing style.
data Style
Style :: Mode -> Int -> Float -> Style

-- | The printing mode
mode :: Style -> Mode

-- | Length of line, in chars
lineLength :: Style -> Int

-- | Ratio of ribbon length to line length
ribbonsPerLine :: Style -> Float

-- | The default style (<tt>mode=PageMode, lineLength=100,
--   ribbonsPerLine=1.5</tt>).
style :: Style

-- | Render the <tt>Printer</tt> to a String using the given
--   <tt>Style</tt>.
runPrinterStyle :: Style -> Printer -> String
instance Show Printer
instance IsString Printer
instance Monoid Printer
instance Semigroup Printer
instance (Pretty a, Integral a) => Pretty (Ratio a)
instance Pretty a => Pretty (Maybe a)
instance Pretty a => Pretty [a]
instance (Pretty a, Pretty b) => Pretty (a, b)
instance Pretty Integer
instance Pretty Char
instance Pretty Double
instance Pretty Float
instance Pretty Int
instance Pretty ()
instance Pretty Printer