#V_      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ "(c) The University of Glasgow 2015/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalportableSafeBVtponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"!      tponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"!      SafeF4"(c) The University of Glasgow 2003/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalportable Trustworthy 278=?ISXtemplate-haskellOTurn a value into a Template Haskell expression, suitable for use in a splice.template-haskell0Generate a fresh name, which cannot be captured.For example, this: *f = $(do nm1 <- newName "x" let nm2 =  "x" return (# [; nm1] (LamE [VarP nm2] ( nm1))) )will produce the splice f = \x0 -> \x -> x0In particular, the occurrence VarE nm1 refers to the binding VarP nm1%, and is not captured by the binding VarP nm2.Although names generated by newName cannot  be captured , they can capture other names. For example, this: og = $(do nm1 <- newName "x" let nm2 = mkName "x" return (LamE [VarP nm2] (LamE [VarP nm1] (VarE nm2))) )will produce the splice g = \x -> \x0 -> x0since the occurrence VarE nm2) is captured by the innermost binding of x , namely VarP nm1.template-haskellGenerate a capturable name. Occurrences of such names will be resolved according to the Haskell scoping rules at the occurrence site. For example: =f = [| pi + $(varE (mkName "pi")) |] ... g = let pi = 3 in $fIn this case, g is desugared to g = Prelude.pi + 3 Note that mkName" may be used with qualified names: mkName "Prelude.pi" See also  E for a useful combinator. The above example could be rewritten using   as f = [| pi + $(dyn "pi") |] template-haskellOnly used internallytemplate-haskellA  instance can have any of its values turned into a Template Haskell expression. This is needed when a value used within a Template Haskell quotation is bound outside the Oxford brackets ( [| ... |]+) but not at the top level. As an example: )add1 :: Int -> Q Exp add1 x = [| x + 1 |]2Template Haskell has no way of knowing what value x: will take on at splice-time, so it requires the type of x to be an instance of .A  instance must satisfy  $(lift x) "a x for all x, where $(...) is a Template Haskell splice.6 instances can be derived automatically by use of the  -XDeriveLift GHC language extension: {-# LANGUAGE DeriveLift #-} module Foo where import Language.Haskell.TH.Syntax data Bar a = Bar1 a (Bar a) | Bar2 String deriving Lifttemplate-haskellPattern in Haskell given in {}template-haskell7An abstract type representing names in the syntax tree.]s can be constructed in several ways, which come with different name-capture guarantees (see &Language.Haskell.TH.Syntax#namecapture% for an explanation of name capture):the built-in syntax 'f and ''T4 can be used to construct names, The expression 'f gives a Name which refers to the value f currently in scope, and ''T gives a Name which refers to the type T7 currently in scope. These names can never be captured. and  are similar to 'f and ''T respectively, but the Nameps are looked up at the point where the current splice is being run. These names can never be captured.D monadically generates a new name, which can never be captured. generates a capturable name.Names constructed using newName and mkName" may be used in bindings (such as  let x = ... or x -> ...), but names constructed using lookupValueName, lookupTypeName, 'f, ''T may not.template-haskellSince the advent of ConstraintKindsC, constraints are really just types. Equality constraints use the C constructor. Constraints may also be tuples of other constraints.template-haskellInjectivity annotationtemplate-haskell&Varieties of allowed instance overlap.template-haskell,May be overlapped by more specific instancestemplate-haskell#May overlap a more general instancetemplate-haskellBoth  and template-haskellBoth  and @, and pick an arbitrary one if multiple choices are available.xtemplate-haskell{To avoid duplication between kinds and types, they are defined to be the same. Naturally, you would never have a type be % and you would never have a kind be E, but many of the other constructors are shared. Note that the kind Bool is denoted with , not '. Similarly, tuple kinds are made with , not .ytemplate-haskell&Annotation target for reifyAnnotations|template-haskellRole annotations}template-haskell nominal~template-haskell representationaltemplate-haskell phantomtemplate-haskell _template-haskell 2template-haskell "Hello"template-haskellType family result signaturetemplate-haskell no signaturetemplate-haskell ktemplate-haskell = r, = (r :: k)template-haskell atemplate-haskell (a :: k)template-haskell forall <vars>. <ctxt> => <type>template-haskell T a btemplate-haskell T @k ttemplate-haskell t :: ktemplate-haskell atemplate-haskell Ttemplate-haskell 'Ttemplate-haskell T + Ttemplate-haskell T + TSee  Language.Haskell.TH.Syntax#infixtemplate-haskell (T)template-haskell (,), (,,), etc.template-haskell (#,#), (#,,#), etc.template-haskell (#|#), (#||#), etc.template-haskell ->template-haskell ~template-haskell []template-haskell '(), '(,), '(,,), etc.template-haskell '[]template-haskell (':)template-haskell *template-haskell  Constrainttemplate-haskell  0,1,2, etc.template-haskell _template-haskell ?x :: ttemplate-haskell"A pattern synonym's argument type.template-haskell pattern P {x y z} = ptemplate-haskell pattern {x P y} = ptemplate-haskell pattern P { {x,y,z} } = ptemplate-haskell#A pattern synonym's directionality.template-haskell pattern P x {<-} ptemplate-haskell pattern P x {=} ptemplate-haskell  pattern P x {<-} p where P x = etemplate-haskellAs of template-haskell-2.11.0.0,  has been replaced by .template-haskellAs of template-haskell-2.11.0.0,  has been replaced by .template-haskellAs of template-haskell-2.11.0.0,  has been replaced by .template-haskell C { {-# UNPACK #-} !}atemplate-haskellA single data constructor.The constructors for _ can roughly be divided up into two categories: those for constructors with "vanilla" syntax (, , and 0), and those for constructors with GADT syntax ( and ). The  constructor, which quantifies additional type variables and class contexts, can surround either variety of constructor. However, the type variables that it quantifies are different depending on what constructor syntax is used:If a : surrounds a constructor with vanilla syntax, then the  will only quantify  existential type variables. For example: % data Foo a = forall b. MkFoo a b In MkFoo,  will quantify b , but not a.If a 7 surrounds a constructor with GADT syntax, then the  will quantify all8 type variables used in the constructor. For example: > data Bar a b where MkBar :: (a ~ b) => c -> MkBar a b In MkBar,  will quantify a, b, and c.template-haskell C Int atemplate-haskell C { v :: Int, w :: a }template-haskell Int :+ atemplate-haskell forall a. Eq a => C [a]template-haskell C :: a -> b -> T b Inttemplate-haskell C :: { v :: Int } -> T b Inttemplate-haskellUnlike  and ,  refers to the strictness that the compiler chooses for a data constructor field, which may be different from what is written in source code. See  for more information.template-haskell C atemplate-haskell C {~}atemplate-haskell C {!}atemplate-haskell C atemplate-haskell C { {-# NOUNPACK #-} } atemplate-haskell C { {-# UNPACK #-} } atemplate-haskell +{ {-# COMPLETE C_1, ..., C_i [ :: T ] #-} }template-haskellOne equation of a type family instance or closed type family. The arguments are the left-hand-side type and the right-hand-side result.3For instance, if you had the following type family: Ftype family Foo (a :: k) :: k where forall k (a :: k). Foo @k a = a The  Foo @k a = a* equation would be represented as follows:  ( [ k,  a ( k)]) ( ( ( ''Foo) ( k)) ( a)) ( a) template-haskellCommon elements of  and S. By analogy with "head" for type classes and type class instances as defined in 0Type classes: an exploration of the design space, the TypeFamilyHead; is defined to be the elements of the declaration between  type family and where.template-haskell8A pattern synonym's type. Note that a pattern synonym's fully specified type has a peculiar shape coming with two forall quantifiers and two constraint contexts. For example, consider the pattern synonym 'pattern P x1 x2 ... xn = <some-pattern>*P's complete type is of the following form pattern P :: forall universals. required constraints => forall existentials. provided constraints => t1 -> t2 -> ... -> tn -> tconsisting of four parts: kthe (possibly empty lists of) universally quantified type variables and required constraints on them.qthe (possibly empty lists of) existentially quantified type variables and the provided constraints on them. the types t1, t2, .., tn of x1, x2, .., xn, respectively the type t of <some-pattern>, mentioning only universals.Pattern synonym types interact with TH when (a) reifying a pattern synonym, (b) pretty printing, or (c) specifying a pattern synonym's type signature explicitly:/Reification always returns a pattern synonym's fully( specified type in abstract syntax.Pretty printing via   abbreviates a pattern synonym's type unambiguously in concrete syntax: The rule of thumb is to print initial empty universals and the required context as () =>, if existentials and a provided context follow. If only universals and their required context, but no existentials are specified, only the universals and their required context are printed. If both or none are specified, so both (or none) are printed.>When specifying a pattern synonym's type explicitly with Z either one of the universals, the existentials, or their contexts may be left empty.USee the GHC user's guide for more information on pattern synonyms and their types:  bhttps://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#pattern-synonyms.template-haskell<What the user explicitly requests when deriving an instance.template-haskellA "standard" derived instancetemplate-haskell -XDeriveAnyClasstemplate-haskell -XGeneralizedNewtypeDerivingtemplate-haskell  -XDerivingViatemplate-haskell A single deriving! clause at the end of a datatype.template-haskell { deriving stock (Eq, Ord) }template-haskell { f p1 p2 = b where decs }template-haskell { p = b where decs }template-haskell T{ data Cxt x => T x = A x | B (T x) deriving (Z,W) deriving stock Eq }template-haskell S{ newtype Cxt x => T x = A (B x) deriving (Z,W Q) deriving stock Eq }template-haskell { type T x = (x,x) }template-haskell  { class Eq a => Ord a where ds }template-haskell A{ instance {-# OVERLAPS #-} Show w => Show [w] where ds }template-haskell { length :: [a] -> Int }template-haskell -{ foreign import ... } { foreign export ... }template-haskell { infix 3 foo }template-haskell { {-# INLINE [1] foo #-} }template-haskell { data family T a b c :: * }template-haskell f{ data instance Cxt x => T [x] = A x | B (T x) deriving (Z,W) deriving stock Eq }template-haskell f{ newtype instance Cxt x => T [x] = A (B x) deriving (Z,W) deriving stock Eq }template-haskell { type instance ... }template-haskell -{ type family T a b c = (r :: *) | r -> a b }template-haskell 3{ type family F a b = (r :: *) | r -> a where ... }template-haskell ({ type role T nominal representational }template-haskell 0{ deriving stock instance Ord a => Ord (Foo a) }template-haskell &{ default size :: Data a => a -> Int }template-haskell{ pattern P v1 v2 .. vn <- p }! unidirectional or { pattern P v1 v2 .. vn = p }! implicit bidirectional or ?{ pattern P v1 v2 .. vn <- p where P v1 v2 .. vn = e } explicit bidirectionalbalso, besides prefix pattern synonyms, both infix and record pattern synonyms are supported. See  for detailstemplate-haskell#A pattern synonym's type signature. template-haskell  { ?x = expr }Implicit parameter binding declaration. Can only be used in let and where clauses which consist entirely of implicit bindings.template-haskell p <- etemplate-haskell { let { x=e1; y=e2 } }template-haskell etemplate-haskellx <- e1 | s2, s3 | s4 (in .)template-haskell rec { s1; s2 }template-haskell f x { | odd x } = xtemplate-haskell &f x { | Just y <- x, Just z <- y } = ztemplate-haskell +f p { | e1 = e2 | e3 = e4 } where dstemplate-haskell f p { = e } where dstemplate-haskell { x }template-haskell "data T1 = C1 t1 t2; p = {C1} e1 e2template-haskell  { 5 or 'c'}template-haskell { f x }template-haskell  { f @Int } template-haskell %{x + y} or {(x+)} or {(+ x)} or {(+)}!template-haskell {x + y}See  Language.Haskell.TH.Syntax#infix"template-haskell { (e) }See  Language.Haskell.TH.Syntax#infix#template-haskell { \ p1 p2 -> e }$template-haskell { \case m1; m2 }%template-haskell  { (e1,e2) }&template-haskell { (# e1,e2 #) }'template-haskell  { (#|e|#) }(template-haskell { if e1 then e2 else e3 })template-haskell { if | g1 -> e1 | g2 -> e2 }*template-haskell { let { x=e1; y=e2 } in e3 }+template-haskell { case e of m1; m2 },template-haskell { do { p <- e1; e2 } }-template-haskell !{ mdo { x <- e1 y; y <- e2 x; } }.template-haskell  { [ (x,y) | x <- xs, y <- ys ] }3The result expression of the comprehension is the last of the s, and should be a .E.g. translation: [ f x | x <- xs ] BCompE [BindS (VarP x) (VarE xs), NoBindS (AppE (VarE f) (VarE x))]/template-haskell { [ 1 ,2 .. 10 ] }0template-haskell  { [1,2,3] }1template-haskell  { e :: t }2template-haskell { T { x = y, z = w } }3template-haskell { (f x) { z = w } }4template-haskell  { static e }5template-haskell { _x }This is used for holes or unresolved identifiers in AST quotes. Note that it could either have a variable name or constructor name.6template-haskell{ #x } ( Overloaded label )7template-haskell{ ?x } ( Implicit parameter )8template-haskell f { p1 p2 = body where decs }9template-haskell $case e of { pat -> body where decs }:template-haskell  { 5 or 'c' };template-haskell { x }<template-haskell  { (p1,p2) }=template-haskell { (# p1,p2 #) }>template-haskell  { (#|p|#) }?template-haskell "data T1 = C1 t1 t2; {C1 p1 p1} = e@template-haskell foo ({x :+ y}) = eAtemplate-haskell foo ({x :+ y}) = eSee  Language.Haskell.TH.Syntax#infixBtemplate-haskell {(p)}See  Language.Haskell.TH.Syntax#infixCtemplate-haskell { ~p }Dtemplate-haskell { !p }Etemplate-haskell  { x @ p }Ftemplate-haskell { _ }Gtemplate-haskell f (Pt { pointx = x }) = g xHtemplate-haskell  { [1,2,3] }Itemplate-haskell  { p :: t }Jtemplate-haskell  { e -> p }Ntemplate-haskellUsed for overloaded and non-overloaded literals. We don't have a good way to represent non-overloaded literals at the moment. Maybe that doesn't matter?Ttemplate-haskell&A primitive C-style string, type Addr#\template-haskell\G desribes a single instance of a class or type function. It is just a ,, but guaranteed to be one of the following: (with empty []) or  (with empty derived [])]template-haskellIn i#, is the type constructor unlifted?^template-haskellIn i, arity of the type constructor_template-haskellIn ', , and >, the total number of `s. For example, (#|#) has a _ of 2.`template-haskellIn ' and >=, the number associated with a particular data constructor. `Js are one-indexed and should never exceed the value of its corresponding _. For example:(#_|#) has ` 1 (out of a total _ of 2)(#|_#) has ` 2 (out of a total _ of 2)atemplate-haskellIn f and j", name of the parent class or typebtemplate-haskellObtained from  in the  Monad.ctemplate-haskell'Contains the import list of the module.dtemplate-haskellObtained from  in the  Monad.etemplate-haskell-A class, with a list of its visible instancesftemplate-haskellA class methodgtemplate-haskellLA "plain" type constructor. "Fancier" type constructors are returned using i or h as appropriate. At present, this reified declaration will never have derived instances attached to it (if you wish to check for an instance, see ).htemplate-haskellpA type or data family, with a list of its visible instances. A closed type family is returned with 0 instances.itemplate-haskell@A "primitive" type constructor, which can't be expressed with a  . Examples: (->), Int#.jtemplate-haskellA data constructorktemplate-haskellA pattern synonymltemplate-haskell7A "value" variable (as opposed to a type variable, see m).The  Maybe Dec field contains Justa the declaration which defined the variable - including the RHS of the declaration - or else NothingX, in the case where the RHS is unavailable to the compiler. At present, this value is always NothingQ: returning the RHS has not yet been implemented because of lack of interest.mtemplate-haskellA type variable.The TypeT field contains the type which underlies the variable. At present, this is always  theName5, but future changes may permit refinement of this.|template-haskell Variables}template-haskellData constructors~template-haskellPType constructors and classes; Haskell has them in the same name space for now.template-haskell&An unqualified name; dynamically boundtemplate-haskell#A qualified name; dynamically boundtemplate-haskellA unique local nametemplate-haskell&Local name bound outside of the TH ASTtemplate-haskellGlobal name bound outside of the TH AST: An original name (occurrences only, not binders) Need the namespace too to be sure which thing we are namingtemplate-haskellObtained from  and  .template-haskell>Report an error (True) or warning (False), but carry on; use  to stop.template-haskellsReport an error to the user, but allow the current splice's computation to carry on. To abort the computation, use .template-haskell+Report a warning to the user, and carry on.template-haskellRecover from errors raised by  or .template-haskellRLook up the given name in the (type namespace of the) current splice's scope. See %Language.Haskell.TH.Syntax#namelookup for more details.template-haskellSLook up the given name in the (value namespace of the) current splice's scope. See %Language.Haskell.TH.Syntax#namelookup for more details.template-haskell looks up information about the .<It is sometimes useful to construct the argument name using  or X to ensure that we are reifying from the right namespace. For instance, in this context:  data D = Dwhich D does reify (mkName "D")$ return information about? (Answer: DE-the-type, but don't rely on it.) To ensure we get information about D-the-value, use : .do Just nm <- lookupValueName "D" reify nmand to get information about D-the-type, use .template-haskellreifyFixity nm+ attempts to find a fixity declaration for nm. For example, if the function foo has the fixity declaration  infixr 7 foo, then reifyFixity 'foo would return  (Z 7 X). If the function bar* does not have a fixity declaration, then reifyFixity 'bar returns , so you may assume bar has .template-haskellreifyInstances nm tys( returns a list of visible instances of nm tys. That is, if nmL is the name of a type class, then all instances of this class at the types tys! are returned. Alternatively, if nmX is the name of a data family or type family, all instances of this family at the types tys are returned.jNote that this is a "shallow" test; the declarations returned merely have instance heads which unify with nm tys(, they need not actually be satisfiable.reifyInstances ''Eq [  2 ``  ''A ``  ''B ] contains the "instance (Eq a, Eq b) => Eq (a, b) regardless of whether A and B themselves implement reifyInstances ''Show [  ( "a") ]* produces every available instance of There is one edge case: reifyInstances ''Typeable tys9 currently always produces an empty list (no matter what tys are given).template-haskell reifyRoles nmG returns the list of roles associated with the parameters of the tycon nm . Fails if nmK cannot be found or is not a tycon. The returned list should never contain .template-haskellreifyAnnotations target2 returns the list of annotations associated with targetS. Only the annotations that are appropriately typed is returned. So if you have Int and StringH annotations for the same target, you have to call this function twice.template-haskellreifyModule mod# looks up information about module modP. To look up the current module, call this function with the return value of  .template-haskellreifyConStrictness nmV looks up the strictness information for the fields of the constructor with the name nm-. Note that the strictness information that s returns may not correspond to what is written in the source code. For example, in the following data declaration: data Pair a = Pair a a  would return [, DecidedLazy]0 under most circumstances, but it would return [, DecidedStrict] if the  -XStrictData language extension was enabled.template-haskell%Is the list of instances returned by  nonempty?template-haskell2The location at which this computation is spliced.template-haskellThe 1 function lets you run an I/O computation in the @ monad. Take care: you are guaranteed the ordering of calls to  within a single ? computation, but not about the order in which splices are run.Note: for various murky reasons, stdout and stderr handles are not necessarily flushed when the compiler finishes running, so you should flush them yourself.template-haskellRecord external files that runIO is using (dependent upon). The compiler can then recognize that it should re-compile the Haskell file when an external file changes.Expects an absolute file path.Notes:Gghc -M does not know about these dependencies - it does not execute TH.@The dependency is based on file content, not a modification timetemplate-haskelljObtain a temporary file path with the given suffix. The compiler will delete this file after compilation.template-haskell}Add additional top-level declarations. The added declarations will be type checked along with the current declaration group.template-haskelltemplate-haskellEmit a foreign file which will be compiled and linked to the object for the current module. Currently only languages that can be compiled with the C compiler are supported, and the flags passed as part of -optc will be also applied to the C compiler invocation that will compile them.0Note that for non-C languages (for example C++) extern CI directives must be used to get symbols that we can access from Haskell.YTo get better errors, it is recommended to use #line pragmas when emitting C files, e.g. {-# LANGUAGE CPP #-} ... addForeignSource LangC $ unlines [ "#line " ++ show (500 + 1) ++ " " ++ show "Language/Haskell/TH/Syntax.hs" , ... ]template-haskellSame as K, but expects to receive a path pointing to the foreign file instead of a ; of its contents. Consider using this in conjunction with .This is a good alternative to 9 when you are trying to directly link in an object file.template-haskellAdd a finalizer that will run in the Q monad after the current module has been type checked. This only makes sense when run within a top-level splice.MThe finalizer is given the local type environment at the splice point. Thus K is able to find the local definitions when executed inside the finalizer.template-haskell/Adds a core plugin to the compilation pipeline.addCorePlugin m' has almost the same effect as passing  -fplugin=mM to ghc in the command line. The major difference is that the plugin module m must not belong to the current package. When TH executes, it is too late to tell the compiler that we needed to compile first a plugin module in the current package.template-haskellGet state from the q monad. Note that the state is local to the Haskell module in which the Template Haskell expression is executed.template-haskellReplace the state in the q monad. Note that the state is local to the Haskell module in which the Template Haskell expression is executed.template-haskellADetermine whether the given language extension is enabled in the  monad.template-haskell%List all enabled language extensions.template-haskell` is an internal utility function for constructing generic conversion functions from types with I instances to various quasi-quoting representations. See the source of  and  for two example usages: mkCon, mkLit and appQQ are overloadable to account for different syntax for expressions and patterns; antiQE allows you to override type-specific cases, a common usage is just  const Nothing#, which results in no overloading.template-haskell converts a value to a 'Q Exp' representation of the same value, in the SYB style. It is generalized to take a function override type-specific cases; see # for a more commonly used variant.template-haskell is a variant of  in the - type class which works for any type with a  instance.template-haskell converts a value to a 'Q Pat' representation of the same value, in the SYB style. It takes a function to handle type-specific cases, alternatively, pass  const Nothing to get default behavior.template-haskell#The name without its module prefix.ExamplesnameBase ''Data.Either.Either"Either"nameBase (mkName "foo")"foo"nameBase (mkName "Module.foo")"foo"template-haskell&Module prefix of a name, if it exists.ExamplesnameModule ''Data.Either.EitherJust "Data.Either"nameModule (mkName "foo")Nothing nameModule (mkName "Module.foo") Just "Module"template-haskellA name's package, if it exists.Examples namePackage ''Data.Either.Either Just "base"namePackage (mkName "foo")Nothing!namePackage (mkName "Module.foo")Nothingtemplate-haskellJReturns whether a name represents an occurrence of a top-level variable (|), data constructor (}%), type constructor, or type class (~#). If we can't be sure, it returns .ExamplesnameSpace 'Prelude.id Just VarNamenameSpace (mkName "id")2Nothing -- only works for top-level variable namesnameSpace 'Data.Maybe.Just Just DataNamenameSpace ''Data.Maybe.MaybeJust TcClsNamenameSpace ''Data.Ord.OrdJust TcClsNametemplate-haskellOnly used internallytemplate-haskell4Used for 'x etc, but not available to the programmertemplate-haskellTuple data constructortemplate-haskellTuple type constructortemplate-haskellUnboxed tuple data constructortemplate-haskellUnboxed tuple type constructortemplate-haskellUnboxed sum data constructortemplate-haskellUnboxed sum type constructortemplate-haskell(Highest allowed operator precedence for Z constructor (answer: 9)template-haskellDefault fixity: infixl 9template-haskelltemplate-haskelltemplate-haskell  (Eq a, Ord b)ntemplate-haskellLine and character positiontemplate-haskell Fresh namestemplate-haskell@Report an error (True) or warning (False) ...but carry on; use  to stoptemplate-haskellthe error handlertemplate-haskellaction which may failtemplate-haskellRecover from the monadic template-haskellhandler to invoke on failuretemplate-haskellcomputation to run 0 %!"#$&'()*+,-./123456798:?;<=>@ABCDEFGHIJ  ponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"!      wvutsrqxyz{|}~    KNOLMPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvywxz{}|~ 0 %!"#$&'()*+,-./123456798:?;<=>@ABCDEFGHIJ  xyz{|}~    KNOLMPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvywxz{}|~wvutsrq*Quasi-quoting support for Template HaskellSafeSXtemplate-haskell5Quasi-quoter for expressions, invoked by quotes like lhs = $[q|...]template-haskell2Quasi-quoter for patterns, invoked by quotes like f $[q|...] = rhstemplate-haskell:Quasi-quoter for declarations, invoked by top-level quotestemplate-haskell/Quasi-quoter for types, invoked by quotes like  f :: $[q|...]template-haskellThe  type, a value q) of this type can be used in the syntax [q| ... string to parse ...|] . In fact, for convenience, a  actually defines multiple quasiquoters to be used in different splice contexts; if you are only interested in defining a quasiquoter to be used for expressions, you would define a  with only 6, and leave the other fields stubbed out with errors.template-haskell takes a P and lifts it into one that read the data out of a file. For example, suppose asmqr is an assembly-language quoter, so that you can write [asmq| ld r1, r2 |] as an expression. Then if you define asmq_f = quoteFile asmq<, then the quote [asmq_f|foo.s|] will take input from file "foo.s" instead of the inline text  Safe=?,b!template-haskellReturns  if the document is emptytemplate-haskellAn empty documenttemplate-haskellA ';' charactertemplate-haskellA ',' charactertemplate-haskellA : charactertemplate-haskell A "::" stringtemplate-haskellA space charactertemplate-haskellA '=' character template-haskell A "->" string!template-haskellA '(' character"template-haskellA ')' character#template-haskellA '[' character$template-haskellA ']' character%template-haskellA '{' character&template-haskellA '}' character/template-haskellWrap document in (...)0template-haskellWrap document in [...]1template-haskellWrap document in {...}2template-haskellWrap document in '...'3template-haskellWrap document in "..."4template-haskellBeside5template-haskellList version of 46template-haskellBeside, separated by space7template-haskellList version of 68template-haskell5Above; if there is no overlap it "dovetails" the two9template-haskellAbove, without dovetailing.:template-haskellList version of 8;template-haskellEither hcat or vcat<template-haskellEither hsep or vcat=template-haskell"Paragraph fill" version of cat>template-haskell"Paragraph fill" version of sep?template-haskellNested@template-haskell "hang d1 n d2 = sep [d1, nest n d2]Atemplate-haskell @punctuate p [d1, ... dn] = [d1 <> p, d2 <> p, ... dn-1 <> p, dn]/ !"#$%&'()*+,-./0123456789:;<=>?@A/ !"#$%&')(*+,-./0123465789:<;>=?@A46668595Safe3VWtemplate-haskell.Pretty prints a pattern synonym type signatureXtemplate-haskellPretty prints a pattern synonym's type; follows the usual conventions to print a pattern synonym type compactly, yet unambiguously. See the note on S and the section on pattern synonyms in the GHC user's guide for more information.CFHGIKJLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~CMLNOPQRSTIKJUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{FHG|}~Safe= )template-haskell Use with <*template-haskell Use with VGtemplate-haskell staticE x = [| static x |]qtemplate-haskellPattern synonym declarationrtemplate-haskellPattern synonym type signaturettemplate-haskellImplicit parameter binding declaration. Can only be used in let and where clauses which consist entirely of implicit bindings.template-haskell*Dynamically binding a variable (unhygenic)template-haskellSingle-arg lambdatemplate-haskellJReturn the Module at the place of splicing. Can be used as an input for . !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#$%&'(QRSTUNMOP)*+,-./0123456789:;<=K>CDEFLGHIJ?@ABWVZXY[\]^klm_`abcdsghiefjnopqrtu|}~vwxyz{SafeE !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVW\]^_`abdiklmnpqrstuvwxyz{|}~ !"#$%&'(NMOP)*+HIJ,-G./0123456789:;<CDEFL?@AB=K>QRSTUvwxyz{u|}~WV\]pniklm^_`abdsqrt SafeNR !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVW\]^_`abdiklmnpqrstuvwxyz{|}~0 %!"#$&'()*+,-./123456798:?;<=>@ABCDEFGHIJ  ponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"!      xyz{|}~    KNOLMPQRSTUVWXYZ[\]^_`abcdefghijklmopqrstu{IJKT\bewopqrstudefghijklmbc\a`_^]ponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"!      yz{ { 8Z[VWXY0 %!"#$&'()*+,-./12345679    KNOLMPQRSTU:?;<=>@ABCDEFGHIJx|}~IJKT\bew  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                  !  "  #  $  %  &  '  (  )  *  +  ,  -  .  /  0  1  2  3  4  5  6  7  8  9  :  ;  <  =  >  ?  @  A  B  C  D  E  F  G  H  I  J  K  L  M  N  O  P  Q  R  S  T  U  V  W  X  Y  Z  [  \  ]  ^  _  `  a  b  c  d  e  f  g  h  i  j  k  l  m  n  o  p  q  r  s  t  u  v  w  x  y  z  {  |  }  ~             !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^^_`abcdeefghijklmnopqqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQ RSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  gefhptursw|template-haskellLanguage.Haskell.TH.Syntax Language.Haskell.TH.Lib.InternalLanguage.Haskell.TH.Quote&Language.Haskell.TH.LanguageExtensionsLanguage.Haskell.TH.PprLibLanguage.Haskell.TH.PprLanguage.Haskell.TH.LibLanguage.Haskell.TH.Lib.Mapdyn pprPatSynType thisModuleLanguage.Haskell.THreturnQbindQ sequenceQliftnewNamemkName mkNameG_v mkNameG_d mkNameG_tcmkNameLmkNameSunTypeunTypeQunsafeTExpCoercecharLstringLintegerLintPrimL wordPrimL floatPrimL doublePrimL rationalL stringPrimL charPrimL liftStringlitPvarPtupP unboxedTupP unboxedSumPconPinfixPtildePbangPasPwildPrecPlistPsigPviewPfieldPatmatchclausevarEconElitEappEappTypeEinfixEinfixAppsectionLsectionRlamElamCaseEtupE unboxedTupE unboxedSumEcondEmultiIfEletEcaseEdoEcompEfromE fromThenEfromToE fromThenToElistEsigErecConErecUpdEstaticE unboundVarElabelEimplicitParamVarEmdoEfieldExpguardedBnormalBnormalGEpatGEbindSletSnoBindSparSrecSfunDvalDdataDnewtypeDtySynDclassDinstanceWithOverlapDsigDforImpDpragInlD pragSpecD pragSpecInlD pragSpecInstD pragRuleDpragAnnD dataFamilyDopenTypeFamilyD dataInstD newtypeInstD tySynInstDclosedTypeFamilyDinfixLDinfixRDinfixND roleAnnotDstandaloneDerivWithStrategyD defaultSigDpatSynD patSynSigD pragCompleteDimplicitParamBindDcxtnoSourceUnpackednesssourceNoUnpack sourceUnpacknoSourceStrictness sourceLazy sourceStrictnormalCrecCinfixCforallCgadtCrecGadtCbangbangType varBangTypeunidir implBidir explBidir prefixPatSyn infixPatSyn recordPatSynforallTvarTconTtupleT unboxedTupleT unboxedSumTarrowTlistTappTappKindTsigT equalityTlitT promotedTpromotedTupleT promotedNilT promotedConsT wildCardTimplicitParamTinfixTnumTyLitstrTyLitplainTVkindedTVnominalRrepresentationalRphantomRinferRvarKconKtupleKarrowKlistKappKstarK constraintKnoSigkindSigtyVarSiginjectivityAnncCallstdCallcApiprim javaScriptunsafesafe interruptiblefunDeptySynEqnquoteExpquotePatquoteDec quoteTyperuleVar typedRuleVarvalueAnnotationtypeAnnotationmoduleAnnotation derivClauseLiftExpMatchClauseQExpQDecQPatMatchQClauseQStmtQConQTypeQTypeDec BangTypeQ VarBangTypeQFieldExpFieldPatNamePatQ FieldPatQ FieldExpQFunDepPredPredQ TyVarBndrQDecsQ RuleBndrQ TySynEqnQRoleTExpInjectivityAnnKindQOverlap DerivClauseQDerivStrategyQNoInlineInline InlinableConLikeFunLike AllPhases FromPhase BeforePhase Overlappable OverlappingOverlaps Incoherent stockStrategyanyclassStrategynewtypeStrategy viaStrategyghc-boot-th-8.8.1GHC.LanguageExtensions.Type StarIsTypeQuantifiedConstraintsNumericUnderscoresEmptyDataDerivingMonadFailDesugaring StrictDataStrictTypeApplicationsStaticPointersNamedWildCardsPartialTypeSignaturesPatternSynonyms EmptyCaseOverloadedLabelsDuplicateRecordFieldsHexFloatLiteralsNegativeLiteralsBinaryLiterals MultiWayIf LambdaCaseTraditionalRecordSyntax RelaxedLayoutNondecreasingIndentationDatatypeContexts!AlternativeLayoutRuleTransitionalAlternativeLayoutRuleExplicitForAllPackageImportsExplicitNamespaces TypeOperatorsImpredicativeTypes RankNTypesLiberalTypeSynonyms PatternGuards TupleSectionsPostfixOperators RecursiveDoGeneralizedNewtypeDerivingMonadComprehensionsTransformListCompParallelListCompRoleAnnotationsKindSignaturesEmptyDataDecls MagicHashExistentialQuantification UnicodeSyntaxFunctionalDependenciesNullaryTypeClassesMultiParamTypeClassesConstrainedClassMethodsFlexibleInstancesFlexibleContextsTypeSynonymInstances DerivingViaDerivingStrategies DeriveLiftDeriveAnyClassDefaultSignatures DeriveGenericDeriveFoldableDeriveTraversable DeriveFunctorAutoDeriveTypeableDeriveDataTypeableStandaloneDeriving ApplicativeDo InstanceSigs DataKinds PolyKindsConstraintKindsRebindableSyntaxBlockArgumentsDoAndIfThenElseNPlusKPatterns GADTSyntaxGADTs ViewPatterns RecordPunsRecordWildCardsDisambiguateRecordFields NumDecimalsOverloadedListsOverloadedStrings TypeInTypeTypeFamilyDependencies TypeFamilies BangPatterns UnboxedSums UnboxedTuplesAllowAmbiguousTypesScopedTypeVariablesImplicitPreludeImplicitParams QuasiQuotesTemplateHaskellQuotesTemplateHaskellArrowsParallelArrays JavaScriptFFIGHCForeignImportPrimCApiFFIInterruptibleFFIUnliftedFFITypesForeignFunctionInterfaceExtendedDefaultRulesRelaxedPolyRecMonoLocalBinds MonoPatBindsMonomorphismRestrictionUndecidableSuperClassesIncoherentInstancesUndecidableInstancesOverlappingInstancesCpp ExtensionGHC.ForeignSrcLang.Type RawObjectLangAsm LangObjcxxLangObjcLangCxxLangCForeignSrcLangKind AnnLookupAnnLookupModule AnnLookupNameNominalRRepresentationalRPhantomRInferRTyLitNumTyLitStrTyLitFamilyResultSigNoSigKindSigTyVarSig TyVarBndrPlainTVKindedTVForallTAppTAppKindTSigTVarTConT PromotedTInfixTUInfixTParensTTupleT UnboxedTupleT UnboxedSumTArrowT EqualityTListTPromotedTupleT PromotedNilT PromotedConsTStarT ConstraintTLitT WildCardTImplicitParamT PatSynArgs PrefixPatSyn InfixPatSyn RecordPatSyn PatSynDirUnidir ImplBidir ExplBidir VarStrictType StrictType VarBangTypeBangTypeBangConNormalCRecCInfixCForallCGadtCRecGadtCDecidedStrictness DecidedLazy DecidedStrict DecidedUnpackSourceStrictnessNoSourceStrictness SourceLazy SourceStrictSourceUnpackednessNoSourceUnpackednessSourceNoUnpack SourceUnpackCxt AnnTargetModuleAnnotationTypeAnnotationValueAnnotationRuleBndrRuleVar TypedRuleVarPhases RuleMatchPragmaInlineP SpecialisePSpecialiseInstPRulePAnnPLineP CompletePSafetyUnsafeSafe InterruptibleCallconvCCallStdCallCApiPrim JavaScriptForeignImportFExportFTySynEqnTypeFamilyHead PatSynType DerivStrategy StockStrategyAnyclassStrategyNewtypeStrategy ViaStrategy DerivClauseFunDValDDataDNewtypeDTySynDClassD InstanceDSigDForeignDInfixDPragmaD DataFamilyD DataInstD NewtypeInstD TySynInstDOpenTypeFamilyDClosedTypeFamilyD RoleAnnotDStandaloneDerivD DefaultSigDPatSynD PatSynSigDImplicitParamBindDRangeFromR FromThenRFromToR FromThenToRStmtBindSLetSNoBindSParSRecSGuardNormalGPatGBodyGuardedBNormalBVarEConELitEAppEAppTypeEInfixEUInfixEParensELamELamCaseETupE UnboxedTupE UnboxedSumECondEMultiIfELetECaseEDoEMDoECompE ArithSeqEListESigERecConERecUpdEStaticE UnboundVarELabelEImplicitParamVarELitPVarPTupP UnboxedTupP UnboxedSumPConPInfixPUInfixPParensPTildePBangPAsPWildPRecPListPSigPViewPLitCharLStringLIntegerL RationalLIntPrimL WordPrimL FloatPrimL DoublePrimL StringPrimL CharPrimLFixityDirectionInfixLInfixRInfixNFixity InstanceDecUnliftedAritySumAritySumAlt ParentName ModuleInfoInfoClassIClassOpITyConIFamilyI PrimTyConIDataConIPatSynIVarITyVarICharPosLoc loc_filename loc_package loc_module loc_startloc_endNameIsAloneAppliedInfixUniq NameSpaceVarNameDataName TcClsName NameFlavourNameSNameQNameUNameLNameGOccNameModulePkgNameModNameunQQuasiqNewNameqReportqRecover qLookupNameqReify qReifyFixityqReifyInstances qReifyRolesqReifyAnnotations qReifyModuleqReifyConStrictness qLocationqRunIOqAddDependentFile qAddTempFile qAddTopDeclsqAddForeignFilePathqAddModFinalizerqAddCorePluginqGetQqPutQ qIsExtEnabled qExtsEnabledbadIOcounterrunQreport reportError reportWarningrecover lookupNamelookupTypeNamelookupValueNamereify reifyFixityreifyInstances reifyRolesreifyAnnotations reifyModulereifyConStrictness isInstancelocationrunIOaddDependentFile addTempFile addTopDeclsaddForeignFileaddForeignSourceaddForeignFilePathaddModFinalizer addCorePlugingetQputQ isExtEnabled extsEnabledtrueName falseName nothingNamejustNameleftName rightName nonemptyNamedataToQa dataToExpQliftData dataToPatQ mkModName modString mkPkgName pkgString mkOccName occStringnameBase nameModule namePackage nameSpacemkNameUmkNameGshowName showName' tupleDataName tupleTypeName mk_tup_nameunboxedTupleDataNameunboxedTupleTypeNamemk_unboxed_tup_nameunboxedSumDataNameunboxedSumTypeName maxPrecedence defaultFixitycmpEqthenCmp $fShowName $fOrdName$fQuasiQ $fMonadIOQ$fApplicativeQ $fFunctorQ $fMonadFailQ$fMonadQ $fQuasiIO$fLift(,,,,,,) $fLift(,,,,,) $fLift(,,,,) $fLift(,,,) $fLift(,,) $fLift(,)$fLift() $fLiftVoid$fLiftNonEmpty$fLift[] $fLiftEither $fLiftMaybe $fLiftBool $fLiftChar $fLiftDouble $fLiftFloat $fLiftRatio $fLiftNatural $fLiftWord64 $fLiftWord32 $fLiftWord16 $fLiftWord8 $fLiftWord $fLiftInt64 $fLiftInt32 $fLiftInt16 $fLiftInt8 $fLiftInt $fLiftInteger $fShowModName $fEqModName $fOrdModName $fDataModName$fGenericModName $fShowPkgName $fEqPkgName $fOrdPkgName $fDataPkgName$fGenericPkgName $fShowModule $fEqModule $fOrdModule $fDataModule$fGenericModule $fShowOccName $fEqOccName $fOrdOccName $fDataOccName$fGenericOccName $fEqNameSpace$fOrdNameSpace$fShowNameSpace$fDataNameSpace$fGenericNameSpace$fDataNameFlavour$fEqNameFlavour$fOrdNameFlavour$fShowNameFlavour$fGenericNameFlavour $fDataName$fEqName $fGenericName $fShowLoc$fEqLoc$fOrdLoc $fDataLoc $fGenericLoc$fShowModuleInfo$fEqModuleInfo$fOrdModuleInfo$fDataModuleInfo$fGenericModuleInfo$fEqFixityDirection$fOrdFixityDirection$fShowFixityDirection$fDataFixityDirection$fGenericFixityDirection $fEqFixity $fOrdFixity $fShowFixity $fDataFixity$fGenericFixity $fShowLit$fEqLit$fOrdLit $fDataLit $fGenericLit $fShowOverlap $fEqOverlap $fOrdOverlap $fDataOverlap$fGenericOverlap $fShowFunDep $fEqFunDep $fOrdFunDep $fDataFunDep$fGenericFunDep$fShowCallconv $fEqCallconv $fOrdCallconv$fDataCallconv$fGenericCallconv $fShowSafety $fEqSafety $fOrdSafety $fDataSafety$fGenericSafety $fShowInline $fEqInline $fOrdInline $fDataInline$fGenericInline$fShowRuleMatch $fEqRuleMatch$fOrdRuleMatch$fDataRuleMatch$fGenericRuleMatch $fShowPhases $fEqPhases $fOrdPhases $fDataPhases$fGenericPhases$fShowAnnTarget $fEqAnnTarget$fOrdAnnTarget$fDataAnnTarget$fGenericAnnTarget$fShowSourceUnpackedness$fEqSourceUnpackedness$fOrdSourceUnpackedness$fDataSourceUnpackedness$fGenericSourceUnpackedness$fShowSourceStrictness$fEqSourceStrictness$fOrdSourceStrictness$fDataSourceStrictness$fGenericSourceStrictness$fShowDecidedStrictness$fEqDecidedStrictness$fOrdDecidedStrictness$fDataDecidedStrictness$fGenericDecidedStrictness $fShowBang$fEqBang $fOrdBang $fDataBang $fGenericBang$fShowPatSynArgs$fEqPatSynArgs$fOrdPatSynArgs$fDataPatSynArgs$fGenericPatSynArgs$fShowInjectivityAnn$fEqInjectivityAnn$fOrdInjectivityAnn$fDataInjectivityAnn$fGenericInjectivityAnn $fShowTyLit $fEqTyLit $fOrdTyLit $fDataTyLit$fGenericTyLit $fShowRole$fEqRole $fOrdRole $fDataRole $fGenericRole$fShowAnnLookup $fEqAnnLookup$fOrdAnnLookup$fDataAnnLookup$fGenericAnnLookup $fShowType$fEqType $fOrdType $fDataType $fGenericType$fShowTyVarBndr $fEqTyVarBndr$fOrdTyVarBndr$fDataTyVarBndr$fGenericTyVarBndr$fShowFamilyResultSig$fEqFamilyResultSig$fOrdFamilyResultSig$fDataFamilyResultSig$fGenericFamilyResultSig$fShowTypeFamilyHead$fEqTypeFamilyHead$fOrdTypeFamilyHead$fDataTypeFamilyHead$fGenericTypeFamilyHead $fShowCon$fEqCon$fOrdCon $fDataCon $fGenericCon$fShowRuleBndr $fEqRuleBndr $fOrdRuleBndr$fDataRuleBndr$fGenericRuleBndr $fShowForeign $fEqForeign $fOrdForeign $fDataForeign$fGenericForeign$fShowTySynEqn $fEqTySynEqn $fOrdTySynEqn$fDataTySynEqn$fGenericTySynEqn$fShowDerivStrategy$fEqDerivStrategy$fOrdDerivStrategy$fDataDerivStrategy$fGenericDerivStrategy$fShowDerivClause$fEqDerivClause$fOrdDerivClause$fDataDerivClause$fGenericDerivClause $fShowDec$fEqDec$fOrdDec $fDataDec $fGenericDec$fShowPatSynDir $fEqPatSynDir$fOrdPatSynDir$fDataPatSynDir$fGenericPatSynDir $fShowClause $fEqClause $fOrdClause $fDataClause$fGenericClause $fShowBody$fEqBody $fOrdBody $fDataBody $fGenericBody $fShowGuard $fEqGuard $fOrdGuard $fDataGuard$fGenericGuard $fShowStmt$fEqStmt $fOrdStmt $fDataStmt $fGenericStmt $fShowExp$fEqExp$fOrdExp $fDataExp $fGenericExp $fShowRange $fEqRange $fOrdRange $fDataRange$fGenericRange $fShowMatch $fEqMatch $fOrdMatch $fDataMatch$fGenericMatch $fShowPat$fEqPat$fOrdPat $fDataPat $fGenericPat $fShowPragma $fEqPragma $fOrdPragma $fDataPragma$fGenericPragma $fShowInfo$fEqInfo $fOrdInfo $fDataInfo $fGenericInfo QuasiQuoter quoteFileDocPprMpprNamepprName' to_HPJ_DocisEmptyemptysemicommacolondcolonspaceequalsarrowlparenrparenlbrackrbracklbracerbracetextptextcharintintegerfloatdoublerationalparensbracketsbracesquotes doubleQuotes<>hcat<+>hsep$$$+$vcatcatsepfcatfsepnesthang punctuate $fMonadPprM$fApplicativePprM $fFunctorPprM $fShowPprMTypeArgTANormalTyArgPprpprppr_list Precedence nestDepthappPrecopPrecunopPrecsigPrecnoPrecparensIfpprintppr_sig pprFixity pprPatSynSig pprPrefixOccisSymOcc pprInfixExppprExp pprFields pprMaybeExp pprMatchPat pprGuardedpprBodypprLit bytesToString pprStringpprPatppr_decppr_deriv_strategy ppr_overlapppr_data ppr_newtypeppr_deriv_clause ppr_tySyn ppr_tf_head ppr_bndrscommaSepApplied pprForall pprRecFields pprGadtRHSpprVarBangType pprBangTypepprVarStrictType pprStrictType pprParendType pprUInfixTpprParendTypeArgpprTyApp pprFunArgTypesplitpprTyLitpprCxt ppr_cxt_preds where_clause showtextl hashParens quoteParenscommaSep commaSepWithsemiSepunboxedSumBarsbar$fPprLoc $fPprRange $fPprRole$fPprTyVarBndr $fPprTyLit $fPprType$fPprDecidedStrictness$fPprSourceStrictness$fPprSourceUnpackedness $fPprBang$fPprPatSynArgs$fPprPatSynDir$fPprCon $fPprClause $fPprRuleBndr $fPprPhases$fPprRuleMatch $fPprInline $fPprPragma $fPprForeign$fPprInjectivityAnn$fPprFamilyResultSig $fPprFunDep$fPprDec$fPprPat$fPprLit $fPprMatch $fPprStmt$fPprExp$fPprModuleInfo $fPprModule $fPprInfo $fPprName$fPpr[] $fPprTypeArgFamilyResultSigQ PatSynArgsQ PatSynDirQVarStrictTypeQ StrictTypeQBangQSourceUnpackednessQSourceStrictnessQRangeQGuardQBodyQCxtQTyLitQTExpQInfoQuInfixPparensPfromR fromThenRfromToR fromThenToRnormalGpatGparensEuInfixElam1E arithSeqEstringE instanceD pragLineDstandaloneDerivDuInfixTparensTclassPequalPisStrict notStrictunpacked strictType varStrictTypeappsEMaplookupinsertbase GHC.MaybeJustControl.Monad.FailfailNothingghc-prim GHC.ClassesEqGHC.BaseString Data.DataData GHC.TypesTrue