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


-- | Some useful combinators for the prettyprinter package
--   
--   Various utilities that make writing Pretty instances easier.
--   
--   Notable utilites include automatic deriving of Pretty instance via
--   Generic, Data, or Show instance.
@package prettyprinter-combinators
@version 0.1.2


module Prettyprinter.MetaDoc
data DocKind
Atomic :: DocKind
Composite :: DocKind
data MetaDoc ann
mdPayload :: MetaDoc ann -> Doc ann
mdKind :: MetaDoc ann -> DocKind
compositeMetaDoc :: Doc ann -> MetaDoc ann
atomicMetaDoc :: Doc ann -> MetaDoc ann
metaDocInt :: Int -> MetaDoc ann
metaDocFloat :: Float -> MetaDoc ann
metaDocDouble :: Double -> MetaDoc ann
metaDocInteger :: Integer -> MetaDoc ann
metaDocNatural :: Natural -> MetaDoc ann
metaDocWord :: Word -> MetaDoc ann
metaDocWord8 :: Word8 -> MetaDoc ann
metaDocWord16 :: Word16 -> MetaDoc ann
metaDocWord32 :: Word32 -> MetaDoc ann
metaDocWord64 :: Word64 -> MetaDoc ann
metaDocInt8 :: Int8 -> MetaDoc ann
metaDocInt16 :: Int16 -> MetaDoc ann
metaDocInt32 :: Int32 -> MetaDoc ann
metaDocInt64 :: Int64 -> MetaDoc ann
metaDocUnit :: () -> MetaDoc ann
metaDocBool :: Bool -> MetaDoc ann
metaDocChar :: Char -> MetaDoc ann
stringMetaDoc :: String -> MetaDoc ann
strictTextMetaDoc :: Text -> MetaDoc ann
lazyTextMetaDoc :: Text -> MetaDoc ann
strictByteStringMetaDoc :: ByteString -> MetaDoc ann
lazyByteStringMetaDoc :: ByteString -> MetaDoc ann
shortByteStringMetaDoc :: ShortByteString -> MetaDoc ann
constructorAppMetaDoc :: MetaDoc ann -> [MetaDoc ann] -> MetaDoc ann
instance GHC.Enum.Bounded Prettyprinter.MetaDoc.DocKind
instance GHC.Enum.Enum Prettyprinter.MetaDoc.DocKind
instance GHC.Classes.Ord Prettyprinter.MetaDoc.DocKind
instance GHC.Classes.Eq Prettyprinter.MetaDoc.DocKind
instance GHC.Base.Semigroup (Prettyprinter.MetaDoc.MetaDoc ann)
instance GHC.Base.Monoid (Prettyprinter.MetaDoc.MetaDoc ann)
instance GHC.Base.Semigroup Prettyprinter.MetaDoc.DocKind
instance GHC.Base.Monoid Prettyprinter.MetaDoc.DocKind


module Prettyprinter.Combinators

-- | Overloaded conversion to <a>Doc</a>.
--   
--   Laws:
--   
--   <ol>
--   <li>output should be pretty. :-)</li>
--   </ol>
class Pretty a

-- | <pre>
--   &gt;&gt;&gt; pretty 1 &lt;+&gt; pretty "hello" &lt;+&gt; pretty 1.234
--   1 hello 1.234
--   </pre>
pretty :: Pretty a => a -> Doc ann

-- | <tt><a>prettyList</a></tt> is only used to define the <tt>instance
--   <a>Pretty</a> a =&gt; <a>Pretty</a> [a]</tt>. In normal circumstances
--   only the <tt><a>pretty</a></tt> function is used.
--   
--   <pre>
--   &gt;&gt;&gt; prettyList [1, 23, 456]
--   [1, 23, 456]
--   </pre>
prettyList :: Pretty a => [a] -> Doc ann

-- | The abstract data type <tt><a>Doc</a> ann</tt> represents pretty
--   documents that have been annotated with data of type <tt>ann</tt>.
--   
--   More specifically, a value of type <tt><a>Doc</a></tt> represents a
--   non-empty set of possible layouts of a document. The layout functions
--   select one of these possibilities, taking into account things like the
--   width of the output document.
--   
--   The annotation is an arbitrary piece of data associated with (part of)
--   a document. Annotations may be used by the rendering backends in order
--   to display output differently, such as
--   
--   <ul>
--   <li>color information (e.g. when rendering to the terminal)</li>
--   <li>mouseover text (e.g. when rendering to rich HTML)</li>
--   <li>whether to show something or not (to allow simple or detailed
--   versions)</li>
--   </ul>
--   
--   The simplest way to display a <a>Doc</a> is via the <a>Show</a> class.
--   
--   <pre>
--   &gt;&gt;&gt; putStrLn (show (vsep ["hello", "world"]))
--   hello
--   world
--   </pre>
data Doc ann
putDocLn :: Doc ann -> IO ()
render :: Doc ann -> Text
renderLazy :: Doc ann -> Text
renderString :: Doc ann -> String
docFromString :: String -> Doc ann
docFromText :: Text -> Doc ann

-- | Convenience function to convert a <a>Show</a>able value to a
--   <a>Doc</a>. If the <a>String</a> does not contain newlines, consider
--   using the more performant <a>unsafeViaShow</a>.
viaShow :: Show a => a -> Doc ann
data MapEntry k v
(:->) :: k -> v -> MapEntry k v
infixr 0 :->

-- | Helper to make constructing <a>MapEntry</a> pairs easier by calling
--   pretty on value.
(-->) :: Pretty v => Text -> v -> MapEntry Text (Doc ann)
infixr 0 -->
ppMapEntryWith :: (k -> Doc ann) -> (v -> Doc ann) -> MapEntry k v -> Doc ann
ppMapEntryWithSep :: Doc ann -> (k -> Doc ann) -> (v -> Doc ann) -> MapEntry k v -> Doc ann
ppList :: Pretty a => [a] -> Doc ann
(##) :: Doc ann -> Doc ann -> Doc ann
infixr 6 ##
ppDictHeader :: Doc ann -> [MapEntry Text (Doc ann)] -> Doc ann
ppDictAssocList :: [MapEntry Text (Doc ann)] -> Doc ann
ppTuple :: Pretty a => [a] -> Doc ann
ppTupleWith :: (a -> Doc ann) -> [a] -> Doc ann
ppListWith :: (a -> Doc ann) -> [a] -> Doc ann
ppFoldableHeader :: (Pretty a, Foldable f) => Doc ann -> f a -> Doc ann
ppFoldableHeaderWith :: Foldable f => (a -> Doc ann) -> Doc ann -> f a -> Doc ann
ppNE :: Pretty a => NonEmpty a -> Doc ann
ppNEWith :: (a -> Doc ann) -> NonEmpty a -> Doc ann
ppMap :: (Pretty a, Pretty b) => Map a b -> Doc ann
ppMapWith :: (k -> Doc ann) -> (v -> Doc ann) -> Map k v -> Doc ann
ppSet :: Pretty a => Set a -> Doc ann
ppSetWith :: (a -> Doc ann) -> Set a -> Doc ann
ppBimap :: (Pretty k, Pretty v) => Bimap k v -> Doc ann
ppBimapWith :: (k -> Doc ann) -> (v -> Doc ann) -> Bimap k v -> Doc ann
ppIntSet :: IntSet -> Doc ann
ppIntSetWith :: (Int -> Doc ann) -> IntSet -> Doc ann
ppIntMap :: Pretty a => IntMap a -> Doc ann
ppIntMapWith :: (Int -> Doc ann) -> (a -> Doc ann) -> IntMap a -> Doc ann
ppHashSet :: Pretty a => HashSet a -> Doc ann
ppHashSetWith :: (a -> Doc ann) -> HashSet a -> Doc ann
ppHashMap :: (Pretty k, Pretty v) => HashMap k v -> Doc ann
ppHashMapWith :: (k -> Doc ann) -> (v -> Doc ann) -> HashMap k v -> Doc ann
ppVector :: (Vector v a, Pretty a) => v a -> Doc ann
ppVectorWith :: Vector v a => (a -> Doc ann) -> v a -> Doc ann
ppDList :: Pretty a => DList a -> Doc ann
ppDListWith :: (a -> Doc ann) -> DList a -> Doc ann
ppListWithDelim :: forall f ann. Foldable f => Doc ann -> Doc ann -> f (Doc ann) -> Doc ann
ppAssocList :: (Pretty k, Pretty v) => [(k, v)] -> Doc ann
ppAssocListWith :: (k -> Doc ann) -> (v -> Doc ann) -> [(k, v)] -> Doc ann
ppAssocListWithSep :: Doc ann -> (k -> Doc ann) -> (v -> Doc ann) -> [(k, v)] -> Doc ann
ppByteString :: ByteString -> Doc ann
ppByteStringLazy :: ByteString -> Doc ann
ppShortByteString :: ShortByteString -> Doc ann
ppCallStack :: CallStack -> Doc ann

-- | Pretty-print a CallStack just as GHC would.
ppCallStackGHC :: CallStack -> Doc ann
instance Data.Traversable.Traversable (Prettyprinter.Combinators.MapEntry k)
instance Data.Foldable.Foldable (Prettyprinter.Combinators.MapEntry k)
instance GHC.Base.Functor (Prettyprinter.Combinators.MapEntry k)
instance (GHC.Show.Show k, GHC.Show.Show v) => GHC.Show.Show (Prettyprinter.Combinators.MapEntry k v)
instance (GHC.Classes.Ord k, GHC.Classes.Ord v) => GHC.Classes.Ord (Prettyprinter.Combinators.MapEntry k v)
instance (GHC.Classes.Eq k, GHC.Classes.Eq v) => GHC.Classes.Eq (Prettyprinter.Combinators.MapEntry k v)
instance (Prettyprinter.Internal.Pretty k, Prettyprinter.Internal.Pretty v) => Prettyprinter.Internal.Pretty (Prettyprinter.Combinators.MapEntry k v)


module Prettyprinter.Generics

-- | Prettyprint using <a>Generic</a> instance.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   test = Test
--     { testSet         = Just $ Set.fromList [1..3]
--     , testMap         =
--         Map.fromList [("foo", Set.fromList [1.5]), ("foo", Set.fromList [2.5, 3, 4])]
--     , testIntSet      = IntSet.fromList [1, 2, 4, 5, 7]
--     , testIntMap      = IntMap.fromList $ zip [1..] ["3", "2foo", "11"]
--     , testInt         = 42
--     , testComplexMap  = Map.fromList
--         [ ( Nothing
--           , IntMap.fromList $ zip [0..] $ map Set.fromList
--               [ ["foo", "bar"]
--               , ["baz"]
--               , ["quux", "frob"]
--               ]
--           )
--         , ( Just (Set.fromList [1])
--           , IntMap.fromList $ zip [0..] $ map Set.fromList
--               [ ["quux"]
--               , ["fizz", "buzz"]
--               ]
--           )
--         , ( Just (Set.fromList [3, 4])
--           , IntMap.fromList $ zip [0..] $ map Set.fromList
--               [ ["quux", "5"]
--               , []
--               , ["fizz", "buzz"]
--               ]
--           )
--         ]
--     , testComplexMap2 =
--         Map.singleton
--           (Just (Set.fromList [1..5]))
--           (Map.fromList
--              [ (NonEmpty.fromList [1, 2],  Vector.fromList ["foo", "bar", "baz"])
--              , (NonEmpty.fromList [3],     Vector.fromList ["quux"])
--              , (NonEmpty.fromList [4..10], Vector.fromList ["must", "put", "something", "in", "here"])
--              ])
--     }
--   :}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; ppGeneric test
--   Test
--     { testSet         -&gt; Just ({1, 2, 3})
--     , testMap         -&gt; {foo -&gt; {2.5, 3.0, 4.0}}
--     , testIntSet      -&gt; {1, 2, 4, 5, 7}
--     , testIntMap      -&gt; {1 -&gt; 3, 2 -&gt; 2foo, 3 -&gt; 11}
--     , testInt         -&gt; 42
--     , testComplexMap  -&gt;
--         { Nothing -&gt; {0 -&gt; {bar, foo}, 1 -&gt; {baz}, 2 -&gt; {frob, quux}}
--         , Just ({1}) -&gt; {0 -&gt; {quux}, 1 -&gt; {buzz, fizz}}
--         , Just ({3, 4}) -&gt; {0 -&gt; {5, quux}, 1 -&gt; {}, 2 -&gt; {buzz, fizz}}
--         }
--     , testComplexMap2 -&gt;
--         { Just ({1, 2, 3, 4, 5}) -&gt;
--             { [1, 2] -&gt; [foo, bar, baz]
--             , [3] -&gt; [quux]
--             , [4, 5, 6, 7, 8, 9, 10] -&gt; [must, put, something, in, here]
--             } }
--     }
--   </pre>
ppGeneric :: (Generic a, GPretty (Rep a)) => a -> Doc ann

-- | Helper to use <a>Generic</a>-based prettyprinting with DerivingVia.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   data TestWithDeriving a b = TestWithDeriving
--     { testSet         :: Maybe (Set a)
--     , testB           :: b
--     , testIntMap      :: IntMap String
--     , testComplexMap  :: Map (Maybe (Set Int)) (IntMap (Set String))
--     }
--     deriving (Generic)
--     deriving Pretty via PPGeneric (TestWithDeriving a b)
--   :}
--   </pre>
newtype PPGeneric a
PPGeneric :: a -> PPGeneric a
[unPPGeneric] :: PPGeneric a -> a

-- | A class to override <a>Pretty</a> when calling <a>ppGeneric</a>
--   without introducing orphans for standard types.
class PPGenericOverride a
ppGenericOverride :: PPGenericOverride a => a -> MetaDoc ann

-- | Overloaded conversion to <a>Doc</a>.
--   
--   Laws:
--   
--   <ol>
--   <li>output should be pretty. :-)</li>
--   </ol>
class Pretty a

-- | <pre>
--   &gt;&gt;&gt; pretty 1 &lt;+&gt; pretty "hello" &lt;+&gt; pretty 1.234
--   1 hello 1.234
--   </pre>
pretty :: Pretty a => a -> Doc ann

-- | <tt><a>prettyList</a></tt> is only used to define the <tt>instance
--   <a>Pretty</a> a =&gt; <a>Pretty</a> [a]</tt>. In normal circumstances
--   only the <tt><a>pretty</a></tt> function is used.
--   
--   <pre>
--   &gt;&gt;&gt; prettyList [1, 23, 456]
--   [1, 23, 456]
--   </pre>
prettyList :: Pretty a => [a] -> Doc ann

-- | Representable types of kind <tt>*</tt>. This class is derivable in GHC
--   with the <tt>DeriveGeneric</tt> flag on.
--   
--   A <a>Generic</a> instance must satisfy the following laws:
--   
--   <pre>
--   <a>from</a> . <a>to</a> ≡ <a>id</a>
--   <a>to</a> . <a>from</a> ≡ <a>id</a>
--   </pre>
class Generic a
instance (GHC.TypeLits.KnownSymbol name, Prettyprinter.Generics.GCollectRecord f) => Prettyprinter.Generics.GPretty (GHC.Generics.M1 GHC.Generics.C ('GHC.Generics.MetaCons name _fixity 'GHC.Types.True) f)
instance (GHC.TypeLits.KnownSymbol name, Prettyprinter.Generics.GPretty a) => Prettyprinter.Generics.GCollectRecord (GHC.Generics.M1 GHC.Generics.S ('GHC.Generics.MetaSel ('GHC.Maybe.Just name) su ss ds) a)
instance forall k (f :: k -> *) (g :: k -> *). (Prettyprinter.Generics.GCollectRecord f, Prettyprinter.Generics.GCollectRecord g) => Prettyprinter.Generics.GCollectRecord (f GHC.Generics.:*: g)
instance Prettyprinter.Generics.GCollectRecord GHC.Generics.U1
instance (GHC.TypeLits.KnownSymbol name, Prettyprinter.Generics.GFields x) => Prettyprinter.Generics.GPretty (GHC.Generics.M1 GHC.Generics.C ('GHC.Generics.MetaCons name _fixity 'GHC.Types.False) x)
instance Prettyprinter.Generics.GFields GHC.Generics.U1
instance Prettyprinter.Generics.GPretty x => Prettyprinter.Generics.GFields (GHC.Generics.M1 GHC.Generics.S ('GHC.Generics.MetaSel a b c d) x)
instance forall k (f :: k -> *) (g :: k -> *). (Prettyprinter.Generics.GFields f, Prettyprinter.Generics.GFields g) => Prettyprinter.Generics.GFields (f GHC.Generics.:*: g)
instance Prettyprinter.Generics.PPGenericOverride a => Prettyprinter.Internal.Pretty (Prettyprinter.Generics.PPGenericOverrideToPretty a)
instance (Prettyprinter.Generics.PPGenericOverride a, Prettyprinter.Generics.PPGenericOverride b) => Prettyprinter.Generics.PPGenericOverride (a, b)
instance (Prettyprinter.Generics.PPGenericOverride a, Prettyprinter.Generics.PPGenericOverride b, Prettyprinter.Generics.PPGenericOverride c) => Prettyprinter.Generics.PPGenericOverride (a, b, c)
instance Prettyprinter.Generics.PPGenericOverride v => Prettyprinter.Generics.PPGenericOverride (GHC.Maybe.Maybe v)
instance Prettyprinter.Generics.PPGenericOverride a => Prettyprinter.Generics.GPretty (GHC.Generics.K1 i a)
instance Prettyprinter.Internal.Pretty a => Prettyprinter.Generics.PPGenericOverride a
instance Prettyprinter.Generics.PPGenericOverride GHC.Types.Int
instance Prettyprinter.Generics.PPGenericOverride GHC.Types.Float
instance Prettyprinter.Generics.PPGenericOverride GHC.Types.Double
instance Prettyprinter.Generics.PPGenericOverride GHC.Num.Integer.Integer
instance Prettyprinter.Generics.PPGenericOverride GHC.Num.Natural.Natural
instance Prettyprinter.Generics.PPGenericOverride GHC.Types.Word
instance Prettyprinter.Generics.PPGenericOverride GHC.Word.Word8
instance Prettyprinter.Generics.PPGenericOverride GHC.Word.Word16
instance Prettyprinter.Generics.PPGenericOverride GHC.Word.Word32
instance Prettyprinter.Generics.PPGenericOverride GHC.Word.Word64
instance Prettyprinter.Generics.PPGenericOverride GHC.Int.Int8
instance Prettyprinter.Generics.PPGenericOverride GHC.Int.Int16
instance Prettyprinter.Generics.PPGenericOverride GHC.Int.Int32
instance Prettyprinter.Generics.PPGenericOverride GHC.Int.Int64
instance Prettyprinter.Generics.PPGenericOverride ()
instance Prettyprinter.Generics.PPGenericOverride GHC.Types.Bool
instance Prettyprinter.Generics.PPGenericOverride GHC.Types.Char
instance Prettyprinter.Generics.PPGenericOverride a => Prettyprinter.Generics.PPGenericOverride (GHC.Real.Ratio a)
instance Prettyprinter.Generics.PPGenericOverride GHC.Stack.Types.CallStack
instance Prettyprinter.Generics.PPGenericOverride (Prettyprinter.Internal.Doc Data.Void.Void)
instance Prettyprinter.Generics.PPGenericOverride GHC.Base.String
instance Prettyprinter.Generics.PPGenericOverride Data.Text.Internal.Text
instance Prettyprinter.Generics.PPGenericOverride Data.Text.Internal.Lazy.Text
instance Prettyprinter.Generics.PPGenericOverride Data.ByteString.Internal.ByteString
instance Prettyprinter.Generics.PPGenericOverride Data.ByteString.Lazy.Internal.ByteString
instance Prettyprinter.Generics.PPGenericOverride Data.ByteString.Short.Internal.ShortByteString
instance Prettyprinter.Generics.PPGenericOverride (GHC.ForeignPtr.ForeignPtr a)
instance Prettyprinter.Generics.PPGenericOverride a => Prettyprinter.Generics.PPGenericOverride (Language.Haskell.TH.Syntax.TyVarBndr a)
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.OccName
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.NameFlavour
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.PkgName
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.NameSpace
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.ModName
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.Name
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.TyLit
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.Type
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.SourceUnpackedness
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.SourceStrictness
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.Bang
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.Con
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.Lit
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.Bytes
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.Stmt
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.Guard
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.Body
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.Match
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.Range
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.Exp
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.Pat
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.Clause
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.DerivStrategy
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.DerivClause
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.FunDep
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.Overlap
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.Callconv
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.Safety
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.Foreign
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.FixityDirection
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.Fixity
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.Inline
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.RuleMatch
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.Phases
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.RuleBndr
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.AnnTarget
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.Pragma
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.TySynEqn
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.FamilyResultSig
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.InjectivityAnn
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.TypeFamilyHead
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.Role
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.PatSynArgs
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.PatSynDir
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.Dec
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.Info
instance Prettyprinter.Generics.PPGenericOverride Language.Haskell.TH.Syntax.Specificity
instance Prettyprinter.Generics.PPGenericOverride v => Prettyprinter.Generics.PPGenericOverride [v]
instance (Prettyprinter.Generics.PPGenericOverride k, Prettyprinter.Generics.PPGenericOverride v) => Prettyprinter.Generics.PPGenericOverride [(k, v)]
instance Prettyprinter.Generics.PPGenericOverride k => Prettyprinter.Generics.PPGenericOverride (GHC.Base.NonEmpty k)
instance Prettyprinter.Generics.PPGenericOverride v => Prettyprinter.Generics.PPGenericOverride (Data.Vector.Vector v)
instance (Prettyprinter.Generics.PPGenericOverride k, Prettyprinter.Generics.PPGenericOverride v) => Prettyprinter.Generics.PPGenericOverride (Data.Map.Internal.Map k v)
instance Prettyprinter.Generics.PPGenericOverride v => Prettyprinter.Generics.PPGenericOverride (Data.Set.Internal.Set v)
instance (Prettyprinter.Generics.PPGenericOverride k, Prettyprinter.Generics.PPGenericOverride v) => Prettyprinter.Generics.PPGenericOverride (Data.Bimap.Bimap k v)
instance Prettyprinter.Generics.PPGenericOverride Data.IntSet.Internal.IntSet
instance Prettyprinter.Generics.PPGenericOverride v => Prettyprinter.Generics.PPGenericOverride (Data.IntMap.Internal.IntMap v)
instance Prettyprinter.Generics.PPGenericOverride v => Prettyprinter.Generics.PPGenericOverride (Data.HashSet.Internal.HashSet v)
instance (Prettyprinter.Generics.PPGenericOverride k, Prettyprinter.Generics.PPGenericOverride v) => Prettyprinter.Generics.PPGenericOverride (Data.HashMap.Internal.HashMap k v)
instance forall k k1 (f :: k -> *) (g :: k1 -> k) (a :: k1). Prettyprinter.Generics.PPGenericOverride (f (g a)) => Prettyprinter.Generics.PPGenericOverride (Data.Functor.Compose.Compose f g a)
instance (GHC.Generics.Generic a, Prettyprinter.Generics.GPretty (GHC.Generics.Rep a)) => Prettyprinter.Internal.Pretty (Prettyprinter.Generics.PPGeneric a)
instance Prettyprinter.Generics.GPretty GHC.Generics.V1
instance Prettyprinter.Generics.GPretty GHC.Generics.U1
instance (Prettyprinter.Generics.GPretty f, Prettyprinter.Generics.GPretty g) => Prettyprinter.Generics.GPretty (f GHC.Generics.:+: g)
instance (Prettyprinter.Generics.GPretty f, Prettyprinter.Generics.GPretty g) => Prettyprinter.Generics.GPretty (f GHC.Generics.:*: g)
instance Prettyprinter.Generics.GPretty x => Prettyprinter.Generics.GPretty (GHC.Generics.M1 GHC.Generics.D ('GHC.Generics.MetaData a b c d) x)
instance Prettyprinter.Generics.GPretty x => Prettyprinter.Generics.GPretty (GHC.Generics.M1 GHC.Generics.S ('GHC.Generics.MetaSel 'GHC.Maybe.Nothing b c d) x)


module Prettyprinter.Data

-- | Prettyprint using <a>Data</a> instance.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   test =
--     Bar
--       ("foo", 10, 20)
--       (Map.fromList (zip ["foo", "bar", "baz"] [1..]))
--       (Map.fromList (zip ["foo", "bar", "baz", "quux", "fizz", "buzz", "frob", "wat"] [1..]))
--       (Just
--         (Foo
--            1
--            []
--            3.14159265358979323846264338327950288
--            (Just
--               (Foo
--                  1
--                  [2]
--                  2.71828182
--                  (Just (Bar ("x", 1, 2) mempty mempty Nothing (NonEmpty.fromList [42])))))))
--       (NonEmpty.fromList [1..42])
--   :}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; ppData test
--   Bar
--     (foo, 10, 20)
--     {bar -&gt; 2, baz -&gt; 3, foo -&gt; 1}
--     { bar -&gt; 2
--     , baz -&gt; 3
--     , buzz -&gt; 6
--     , fizz -&gt; 5
--     , foo -&gt; 1
--     , frob -&gt; 7
--     , quux -&gt; 4
--     , wat -&gt; 8
--     }
--     Just Foo
--            1
--            {}
--            3.141592653589793
--            Just (Foo 1 [2] 2.71828182 (Just (Bar (x, 1, 2) {} {} Nothing [42])))
--     [ 1
--     , 2
--     , 3
--     , 4
--     , 5
--     , 6
--     , 7
--     , 8
--     , 9
--     , 10
--     , 11
--     , 12
--     , 13
--     , 14
--     , 15
--     , 16
--     , 17
--     , 18
--     , 19
--     , 20
--     , 21
--     , 22
--     , 23
--     , 24
--     , 25
--     , 26
--     , 27
--     , 28
--     , 29
--     , 30
--     , 31
--     , 32
--     , 33
--     , 34
--     , 35
--     , 36
--     , 37
--     , 38
--     , 39
--     , 40
--     , 41
--     , 42
--     ]
--   </pre>
ppData :: Data a => a -> Doc ann

-- | Prettyprint using <a>gshow</a>.
ppDataSimple :: Data a => a -> Doc ann

-- | The <a>Data</a> class comprehends a fundamental primitive
--   <a>gfoldl</a> for folding over constructor applications, say terms.
--   This primitive can be instantiated in several ways to map over the
--   immediate subterms of a term; see the <tt>gmap</tt> combinators later
--   in this class. Indeed, a generic programmer does not necessarily need
--   to use the ingenious gfoldl primitive but rather the intuitive
--   <tt>gmap</tt> combinators. The <a>gfoldl</a> primitive is completed by
--   means to query top-level constructors, to turn constructor
--   representations into proper terms, and to list all possible datatype
--   constructors. This completion allows us to serve generic programming
--   scenarios like read, show, equality, term generation.
--   
--   The combinators <a>gmapT</a>, <a>gmapQ</a>, <a>gmapM</a>, etc are all
--   provided with default definitions in terms of <a>gfoldl</a>, leaving
--   open the opportunity to provide datatype-specific definitions. (The
--   inclusion of the <tt>gmap</tt> combinators as members of class
--   <a>Data</a> allows the programmer or the compiler to derive
--   specialised, and maybe more efficient code per datatype. <i>Note</i>:
--   <a>gfoldl</a> is more higher-order than the <tt>gmap</tt> combinators.
--   This is subject to ongoing benchmarking experiments. It might turn out
--   that the <tt>gmap</tt> combinators will be moved out of the class
--   <a>Data</a>.)
--   
--   Conceptually, the definition of the <tt>gmap</tt> combinators in terms
--   of the primitive <a>gfoldl</a> requires the identification of the
--   <a>gfoldl</a> function arguments. Technically, we also need to
--   identify the type constructor <tt>c</tt> for the construction of the
--   result type from the folded term type.
--   
--   In the definition of <tt>gmapQ</tt><i>x</i> combinators, we use
--   phantom type constructors for the <tt>c</tt> in the type of
--   <a>gfoldl</a> because the result type of a query does not involve the
--   (polymorphic) type of the term argument. In the definition of
--   <a>gmapQl</a> we simply use the plain constant type constructor
--   because <a>gfoldl</a> is left-associative anyway and so it is readily
--   suited to fold a left-associative binary operation over the immediate
--   subterms. In the definition of gmapQr, extra effort is needed. We use
--   a higher-order accumulation trick to mediate between left-associative
--   constructor application vs. right-associative binary operation (e.g.,
--   <tt>(:)</tt>). When the query is meant to compute a value of type
--   <tt>r</tt>, then the result type within generic folding is <tt>r -&gt;
--   r</tt>. So the result of folding is a function to which we finally
--   pass the right unit.
--   
--   With the <tt>-XDeriveDataTypeable</tt> option, GHC can generate
--   instances of the <a>Data</a> class automatically. For example, given
--   the declaration
--   
--   <pre>
--   data T a b = C1 a b | C2 deriving (Typeable, Data)
--   </pre>
--   
--   GHC will generate an instance that is equivalent to
--   
--   <pre>
--   instance (Data a, Data b) =&gt; Data (T a b) where
--       gfoldl k z (C1 a b) = z C1 `k` a `k` b
--       gfoldl k z C2       = z C2
--   
--       gunfold k z c = case constrIndex c of
--                           1 -&gt; k (k (z C1))
--                           2 -&gt; z C2
--   
--       toConstr (C1 _ _) = con_C1
--       toConstr C2       = con_C2
--   
--       dataTypeOf _ = ty_T
--   
--   con_C1 = mkConstr ty_T "C1" [] Prefix
--   con_C2 = mkConstr ty_T "C2" [] Prefix
--   ty_T   = mkDataType "Module.T" [con_C1, con_C2]
--   </pre>
--   
--   This is suitable for datatypes that are exported transparently.
class Typeable a => Data a


module Prettyprinter.Show
ppShow :: Show a => a -> Doc ann

-- | Helper to use <a>Show</a>-based prettyprinting with DerivingVia.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   data TestWithDeriving a b = TestWithDeriving
--     { testSet         :: Maybe (Set a)
--     , testB           :: b
--     , testIntMap      :: IntMap String
--     , testComplexMap  :: Map (Maybe (Set Int)) (IntMap (Set String))
--     }
--     deriving (Show)
--     deriving Pretty via PPShow (TestWithDeriving a b)
--   :}
--   </pre>
newtype PPShow a
PPShow :: a -> PPShow a
[unPPShow] :: PPShow a -> a
instance GHC.Show.Show a => Prettyprinter.Internal.Pretty (Prettyprinter.Show.PPShow a)