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


-- | Prettyprinting transformers.
--   
--   Prettyprinting transformers for rainbow parens, precedence, etc.
@package silkscreen
@version 0.0.0.2


-- | Silkscreen is a library of pretty-printing transformers built around
--   the <a>prettyprinter</a> package. This module defines the core
--   <a>Printer</a> abstraction and a few instances.
--   
--   More documentation can be found in <a>Prettyprinter</a>.
module Silkscreen

-- | A <a>Printer</a> abstracts pretty-printing to allow the composition of
--   behaviours such as e.g. rainbow parentheses, precedence handling, and
--   so forth.
class Monoid p => Printer p where {
    
    -- | The type of annotations supported by the printer.
    --   
    --   We provide this as a type family instead of defining <a>Printer</a>
    --   over kind <tt>Type -&gt; Type</tt> in order to allow instances to
    --   constrain annotations.
    type family Ann p;
}

-- | Lift a <a>Doc</a> to a <a>Printer</a>.
liftDoc0 :: Printer p => Doc (Ann p) -> p

-- | Lift a unary function on <a>Doc</a> to a <a>Printer</a>.
liftDoc1 :: Printer p => (Doc (Ann p) -> Doc (Ann p)) -> p -> p

-- | Lift a binary function on <a>Doc</a> to a <a>Printer</a>.
liftDoc2 :: Printer p => (Doc (Ann p) -> Doc (Ann p) -> Doc (Ann p)) -> p -> p -> p

-- | <tt><a>enclosing</a> l r x</tt> wraps <tt>x</tt> in <tt>l</tt> and
--   <tt>r</tt>.
--   
--   Distinct from <a>enclose</a> (which is not overloaded) so that
--   <a>enclose</a> remains available as a convenience for appending
--   documents without whatever extra semantics are implied by any
--   particular <a>Printer</a> (rainbow precedences, resetting precedence,
--   etc.).
--   
--   Overloadable to support e.g. rainbow parentheses.
enclosing :: Printer p => p -> p -> p -> p

-- | Wrap the argument in single quotes.
--   
--   The default definition is given in terms of <a>enclosing</a>.
--   Overloadable to support e.g. rainbow quotes (or disabling of same, if
--   desired).
squotes :: Printer p => p -> p

-- | Wrap the argument in double quotes.
--   
--   The default definition is given in terms of <a>enclosing</a>.
--   Overloadable to support e.g. rainbow quotes (or disabling of same, if
--   desired).
dquotes :: Printer p => p -> p

-- | Parenthesize the argument.
--   
--   The default definition is given in terms of <a>enclosing</a>.
--   Overloadable to support e.g. rainbow parentheses (or disabling of
--   same, if desired).
parens :: Printer p => p -> p

-- | Wrap the argument in brackets.
--   
--   The default definition is given in terms of <a>enclosing</a>.
--   Overloadable to support e.g. rainbow brackets (or disabling of same,
--   if desired).
brackets :: Printer p => p -> p

-- | Wrap the argument in braces.
--   
--   The default definition is given in terms of <a>enclosing</a>.
--   Overloadable to support e.g. rainbow braces (or disabling of same, if
--   desired).
braces :: Printer p => p -> p

-- | Wrap the argument in angle brackets.
--   
--   The default definition is given in terms of <a>enclosing</a>.
--   Overloadable to support e.g. rainbow angle brackets (or disabling of
--   same, if desired).
angles :: Printer p => p -> p
column :: Printer p => (Int -> p) -> p
nesting :: Printer p => (Int -> p) -> p
pageWidth :: Printer p => (PageWidth -> p) -> p

-- | Pretty-print a value using the <a>Pretty</a> instance for its type.
pretty :: (Printer p, Pretty t) => t -> p
prettyList :: (Printer p, Pretty t) => [t] -> p

-- | Annotate a <a>Printer</a> with an <tt><a>Ann</a> p</tt>.
annotate :: Printer p => Ann p -> p -> p

-- | Try to unwrap the argument, if it will fit.
group :: Printer p => p -> p

-- | Print the first argument by default, or the second when an enclosing
--   <a>group</a> flattens it.
flatAlt :: Printer p => p -> p -> p

-- | Indent lines in the argument to the current column.
align :: Printer p => p -> p

-- | Indent following lines in the argument to the current column + some
--   delta.
hang :: Printer p => Int -> p -> p

-- | Indent lines in the argument to the current column + some delta.
indent :: Printer p => Int -> p -> p

-- | <tt><a>nest</a> i p</tt> changes the indentation level for new lines
--   in <tt>p</tt> by <tt>i</tt>.
nest :: Printer p => Int -> p -> p
concatWith :: (Monoid p, Foldable t) => (p -> p -> p) -> t p -> p
hsep :: Printer p => [p] -> p
vsep :: Printer p => [p] -> p
fillSep :: Printer p => [p] -> p
sep :: Printer p => [p] -> p
hcat :: Printer p => [p] -> p
vcat :: Printer p => [p] -> p
fillCat :: Printer p => [p] -> p
cat :: Printer p => [p] -> p
punctuate :: Printer p => p -> [p] -> [p]
width :: Printer p => p -> (Int -> p) -> p
fill :: Printer p => Int -> p -> p
fillBreak :: Printer p => Int -> p -> p
plural :: (Num amount, Eq amount) => doc -> doc -> amount -> doc

-- | <tt><a>enclose</a> l r x</tt> wraps <tt>x</tt> in <tt>l</tt> and
--   <tt>r</tt>.
enclose :: Printer p => p -> p -> p -> p
encloseSep :: Printer p => p -> p -> p -> [p] -> p
list :: Printer p => [p] -> p
tupled :: Printer p => [p] -> p

-- | <tt><a>surround</a> x l r</tt> wraps <tt>x</tt> in <tt>l</tt> and
--   <tt>r</tt>.
--   
--   This is a reordering of <a>enclose</a>, but allows for convenient use
--   in e.g. folds:
--   
--   <pre>
--   &gt;&gt;&gt; 'foldr1' ('surround' ('pretty' ", ")) ['pretty' "apple", 'pretty' "banana"]
--   apple, banana
--   </pre>
surround :: Printer p => p -> p -> p -> p

-- | Separate the arguments with a space.
(<+>) :: Printer p => p -> p -> p
infixr 6 <+>

-- | Separate the arguments with a line.
(</>) :: Printer p => p -> p -> p
infixr 6 </>

-- | Conditional parenthesization of a printer. Analogous to
--   <a>showParen</a>, but for printers.
parensIf :: Printer p => Bool -> p -> p
space :: Printer p => p
line :: Printer p => p
line' :: Printer p => p
softline :: Printer p => p
softline' :: Printer p => p
hardline :: Printer p => p
lparen :: Printer p => p
rparen :: Printer p => p
lbracket :: Printer p => p
rbracket :: Printer p => p
lbrace :: Printer p => p
rbrace :: Printer p => p
langle :: Printer p => p
rangle :: Printer p => p
squote :: Printer p => p
dquote :: Printer p => p
semi :: Printer p => p
comma :: Printer p => p
colon :: Printer p => p
dot :: Printer p => p
slash :: Printer p => p
backslash :: Printer p => p
equals :: Printer p => p
pipe :: Printer p => p
class Pretty a
data PageWidth
AvailablePerLine :: !Int -> !Double -> PageWidth
Unbounded :: PageWidth
instance Silkscreen.Printer (Prettyprinter.Internal.Doc ann)
instance (Silkscreen.Printer a, Silkscreen.Printer b, Silkscreen.Ann a GHC.Types.~ Silkscreen.Ann b) => Silkscreen.Printer (a, b)
instance Silkscreen.Printer b => Silkscreen.Printer (a -> b)

module Silkscreen.Nesting
class Printer p => NestingPrinter p

-- | Make a printer informed by the current nesting level.
askingNesting :: NestingPrinter p => (Int -> p) -> p

-- | Locally change the nesting level for a printer.
localNesting :: NestingPrinter p => (Int -> Int) -> p -> p

-- | Apply the current nesting level to a printer.
--   
--   Different instances can give different meanings to this, e.g.
--   annotating the argument with the nesting level or some other means of
--   rendering it differently.
applyNesting :: NestingPrinter p => p -> p

-- | Increment the nesting level of a printer.
--   
--   This should be used inside parentheses, brackets, braces, etc., and
--   will inform the annotation of their delimiters.
incrNesting :: NestingPrinter p => p -> p
encloseNesting :: NestingPrinter p => p -> p -> p -> p
instance Silkscreen.Nesting.NestingPrinter b => Silkscreen.Nesting.NestingPrinter (a -> b)

module Silkscreen.Precedence

-- | Pretty-printing with parenthesis insertion resolving precedence.
--   
--   Given:
--   
--   <pre>
--   data ArithLevel = Bottom | Add | Mult | Exp | Top
--     deriving (Eq, Ord)
--   
--   (+.) :: (PrecedencePrinter p, Level p ~ ArithLevel) =&gt; p -&gt; p -&gt; p
--   (+.) = <a>assoc</a> Add (<a>surround</a> (<a>pretty</a> " + "))
--   infixl 6 +.
--   
--   (*.) :: (PrecedencePrinter p, Level p ~ ArithLevel) =&gt; p -&gt; p -&gt; p
--   (*.) = <a>assoc</a> Mult (<a>surround</a> (<a>pretty</a> " * "))
--   infixl 7 *.
--   
--   (^.) :: (PrecedencePrinter p, Level p ~ ArithLevel) =&gt; p -&gt; p -&gt; p
--   (^.) = <a>rightAssoc</a> Exp Top (<a>surround</a> (<a>pretty</a> " ^ "))
--   infixr 8 ^.
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; putDoc . runPrec Bottom $ ('pretty' "a" +. 'pretty' "b") *. 'pretty' "c" ^. ('pretty' "d" *. 'pretty' "e")
--   (a + b) * c ^ (d * e)
--   </pre>
class Printer p => PrecedencePrinter p where {
    
    -- | The type used to represent precedence levels. This is defined as an
    --   associated type so that consumers can use e.g. symbolic
    --   representations of their DSL’s precedence levels instead of e.g.
    --   unsemantic <a>Int</a>s.
    --   
    --   This type will usually be <a>Ord</a>ered, but this isn’t strictly
    --   required so that other means of determining precedence can be
    --   provided.
    type family Level p;
}

-- | Print informed by the current <a>Level</a>.
askingPrec :: PrecedencePrinter p => (Level p -> p) -> p

-- | Locally change the <a>Level</a> in a printer.
localPrec :: PrecedencePrinter p => (Level p -> Level p) -> p -> p

-- | Set a constant precedence.
--   
--   This function does not insert parentheses, and thus should be used
--   when inserting parentheses or otherwise resetting the precedence
--   level.
setPrec :: PrecedencePrinter p => Level p -> p -> p

-- | Set a constant precedence, parenthesizing in higher-precedence
--   contexts.
prec :: (PrecedencePrinter p, Ord (Level p)) => Level p -> p -> p

-- | Make an associative infix combinator at the given level.
assoc :: (PrecedencePrinter p, Ord (Level p)) => Level p -> (p -> p -> p) -> p -> p -> p

-- | Make a non-associative infix combinator at the given levels for the
--   operator itself and its operands.
nonAssoc :: (PrecedencePrinter p, Ord (Level p)) => Level p -> Level p -> (p -> p -> p) -> p -> p -> p

-- | Make a left-associative infix combinator at the given levels for the
--   operator itself and its right operand.
leftAssoc :: (PrecedencePrinter p, Ord (Level p)) => Level p -> Level p -> (p -> p -> p) -> p -> p -> p

-- | Make a right-associative infix combinator at the given levels for the
--   operator itself and its left operand.
rightAssoc :: (PrecedencePrinter p, Ord (Level p)) => Level p -> Level p -> (p -> p -> p) -> p -> p -> p

-- | Make an infix combinator at the given level for the operator itself,
--   applying functions to either operand.
infix_ :: (PrecedencePrinter p, Ord (Level p)) => Level p -> (p -> p) -> (p -> p) -> (p -> p -> p) -> p -> p -> p
instance Silkscreen.Precedence.PrecedencePrinter b => Silkscreen.Precedence.PrecedencePrinter (a -> b)

module Silkscreen.Printer.Prec
runPrec :: level -> Prec level a -> a
newtype Prec level a
Prec :: (level -> a) -> Prec level a
instance GHC.Base.Semigroup a => GHC.Base.Semigroup (Silkscreen.Printer.Prec.Prec level a)
instance GHC.Base.Monoid a => GHC.Base.Monoid (Silkscreen.Printer.Prec.Prec level a)
instance GHC.Base.Monad (Silkscreen.Printer.Prec.Prec level)
instance GHC.Base.Functor (Silkscreen.Printer.Prec.Prec level)
instance GHC.Base.Applicative (Silkscreen.Printer.Prec.Prec level)
instance (GHC.Enum.Bounded level, GHC.Show.Show a) => GHC.Show.Show (Silkscreen.Printer.Prec.Prec level a)
instance (GHC.Enum.Bounded level, Silkscreen.Printer a) => Silkscreen.Printer (Silkscreen.Printer.Prec.Prec level a)
instance (GHC.Enum.Bounded level, Silkscreen.Printer a) => Silkscreen.Precedence.PrecedencePrinter (Silkscreen.Printer.Prec.Prec level a)
instance (GHC.Enum.Bounded level, Silkscreen.Nesting.NestingPrinter p) => Silkscreen.Nesting.NestingPrinter (Silkscreen.Printer.Prec.Prec level p)

module Silkscreen.Printer.Rainbow
runRainbow :: (Int -> a -> a) -> Int -> Rainbow a -> a
newtype Rainbow a
Rainbow :: ((Int -> a -> a) -> Int -> a) -> Rainbow a
instance GHC.Base.Semigroup a => GHC.Base.Semigroup (Silkscreen.Printer.Rainbow.Rainbow a)
instance GHC.Base.Monoid a => GHC.Base.Monoid (Silkscreen.Printer.Rainbow.Rainbow a)
instance GHC.Show.Show a => GHC.Show.Show (Silkscreen.Printer.Rainbow.Rainbow a)
instance Silkscreen.Printer a => Silkscreen.Printer (Silkscreen.Printer.Rainbow.Rainbow a)
instance Silkscreen.Printer a => Silkscreen.Nesting.NestingPrinter (Silkscreen.Printer.Rainbow.Rainbow a)
instance Silkscreen.Precedence.PrecedencePrinter p => Silkscreen.Precedence.PrecedencePrinter (Silkscreen.Printer.Rainbow.Rainbow p)