Ӹd      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcSafe defghijklmnopehkl defghijklmnop"(c) The University of Glasgow 2015/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalportableSafekMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"!      kMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"!      "(c) The University of Glasgow 2003/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.org experimentalportableNone 0569;EOTOTurn a value into a Template Haskell expression, suitable for use in a splice.0Generate 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.Generate 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 dyn as f = [| pi + $(dyn "pi") |] Only used internallyA  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 .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 LiftPattern in Haskell given in {}7An 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.d and c 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.Since the advent of ConstraintKindsC, constraints are really just types. Equality constraints use the lC constructor. Constraints may also be tuples of other constraints.Injectivity annotation{To avoid duplication between kinds and types, they are defined to be the same. Naturally, you would never have a type be q% and you would never have a kind be bE, but many of the other constructors are shared. Note that the kind Bool is denoted with d, not e'. Similarly, tuple kinds are made with i, not n.&Varieties of allowed instance overlap.,May be overlapped by more specific instances#May overlap a more general instanceBoth  and Both  and @, and pick an arbitrary one if multiple choices are available.N&Annotation target for reifyAnnotationsQRole annotationsR nominalS representationalT phantomU _W 2X HelloZType family result signature[ no signature\ k] = r, = (r :: k)^ a_ (a :: k)` forall <vars>. <ctxt> -> <type>a T a bb t :: kc ad Te 'Tf T + Tg T + TSee  Language.Haskell.TH.Syntax#infixh (T)i (,), (,,), etc.j (#,#), (#,,#), etc.k ->l ~m []n '(), '(,), '(,,), etc.o '[]p (':)q *r  Constraints  0,1,2, etc.t@_,uAs of template-haskell-2.11.0.0, u has been replaced by x.vAs of template-haskell-2.11.0.0, v has been replaced by y.wAs of template-haskell-2.11.0.0, w has been replaced by z.{ C { {-# UNPACK #-} !}a} C Int a~ C { v :: Int, w :: a } Int :+ a forall a. Eq a => C [a] C :: a -> b -> T b Int C :: { v :: Int } -> T b IntUnlike  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 k for more information. C a C {~}a C {!}a C a C { {-# NOUNPACK #-} } a C { {-# UNPACK #-} } aOne equation of a type family instance or closed type family. The arguments are the left-hand-side type patterns and the right-hand-side result.Common elements of  and X. By analogy with 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. { f p1 p2 = b where decs } { p = b where decs } :{ data Cxt x => T x = A x | B (T x) deriving (Z,W)} 9{ newtype Cxt x => T x = A (B x) deriving (Z,W Q)} { type T x = (x,x) }  { class Eq a => Ord a where ds } A{ instance {-# OVERLAPS #-} Show w => Show [w] where ds } { length :: [a] -> Int } -{ foreign import ... } { foreign export ... } { infix 3 foo } { {-# INLINE [1] foo #-} } { data family T a b c :: * } E{ data instance Cxt x => T [x] = A x | B (T x) deriving (Z,W)} C{ newtype instance Cxt x => T [x] = A (B x) deriving (Z,W)} { type instance ... } -{ type family T a b c = (r :: *) | r -> a b } 3{ type family F a b = (r :: *) | r -> a where ... } ({ type role T nominal representational } *{ deriving instance Ord a => Ord (Foo a) } &{ default size :: Data a => a -> Int } f x { | odd x } = x &f x { | Just y <- x, Just z <- y } = z +f p { | e1 = e2 | e3 = e4 } where ds f p { = e } where ds { x } "data T1 = C1 t1 t2; p = {C1} e1 e2  { 5 or 'c'} { f x } %{x + y} or {(x+)} or {(+ x)} or {(+)} {x + y}See  Language.Haskell.TH.Syntax#infix { (e) }See  Language.Haskell.TH.Syntax#infix { \ p1 p2 -> e } { \case m1; m2 }  { (e1,e2) } { (# e1,e2 #) } { if e1 then e2 else e3 } { if | g1 -> e1 | g2 -> e2 } { let x=e1; y=e2 in e3 } { case e of m1; m2 } { do { p <- e1; e2 } }  { [ (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))] { [ 1 ,2 .. 10 ] }  { [1,2,3] }  { e :: t } { T { x = y, z = w } } { (f x) { z = w } }  { static e }{ _x } (hole) f { p1 p2 = body where decs } $case e of { pat -> body where decs }  { 5 or 'c' } { x }  { (p1,p2) } { (# p1,p2 #) } "data T1 = C1 t1 t2; {C1 p1 p1} = e foo ({x :+ y}) = e foo ({x :+ y}) = eSee  Language.Haskell.TH.Syntax#infix {(p)}See  Language.Haskell.TH.Syntax#infix { ~p } { !p }  { x @ p } { _ } f (Pt { pointx = x }) = g x  { [1,2,3] }  { p :: t }  { e -> p }Used 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? &A primitive C-style string, type Addr#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 [])In  #, is the type constructor unlifted?In  , arity of the type constructorIn  and !", name of the parent class or typeObtained from j in the  Monad.'Contains the import list of the module.Obtained from e in the  Monad.-A class, with a list of its visible instancesA class methodKA "plain" type constructor. "Fancier" type constructors are returned using   or  as appropriatepA type or data family, with a list of its visible instances. A closed type family is returned with 0 instances. @A "primitive" type constructor, which can't be expressed with a  . Examples: (->), Int#.!A data constructor"7A "value" variable (as opposed to a type variable, see #).The  Maybe Dec field contains Justc the declaration which defined the variable -- including the RHS of the declaration -- or else Nothinga, 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.#A type variable.The TypeT field contains the type which underlies the variable. At present, this is always c theName5, but future changes may permit refinement of this.2 Variables3Data constructors4PType constructors and classes; Haskell has them in the same name space for now.6&An unqualified name; dynamically bound7#A qualified name; dynamically bound8A unique local name9&Local name bound outside of the TH AST:Global 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 naming>Obtained from j and  thisModule.SInput/output (dangerous)^>Report an error (True) or warning (False), but carry on; use q to stop._sReport an error to the user, but allow the current splice's computation to carry on. To abort the computation, use q.`+Report a warning to the user, and carry on.aRecover from errors raised by _ or q.cRLook up the given name in the (type namespace of the) current splice's scope. See %Language.Haskell.TH.Syntax#namelookup for more details.dSLook up the given name in the (value namespace of the) current splice's scope. See %Language.Haskell.TH.Syntax#namelookup for more details.ee looks up information about the .<It is sometimes useful to construct the argument name using c or dX 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 d: .do Just nm <- lookupValueName "D" reify nmand to get information about D-the-type, use c.freifyFixity 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 r ( 7 ). If the function bar* does not have a fixity declaration, then reifyFixity 'bar returns s, so you may assume bar has .greifyInstances 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.h 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 U.ireifyAnnotations 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.jreifyModule mod# looks up information about module modP. To look up the current module, call this function with the return value of  thisModule.kreifyConStrictness nmV looks up the strictness information for the fields of the constructor with the name nm-. Note that the strictness information that ks 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 k would return [, DecidedLazy]0 under most circumstances, but it would return [, DecidedStrict] if the  -XStrictData language extension was enabled.l%Is the list of instances returned by g nonempty?m2The location at which this computation is spliced.nThe n1 function lets you run an I/O computation in the @ monad. Take care: you are guaranteed the ordering of calls to n 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.oRecord 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 timep}Add additional top-level declarations. The added declarations will be type checked along with the current declaration group.qAdd 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.rGet state from the  monad.sReplace the state in the  monad.tADetermine whether the given language extension is enabled in the  monad.u%List all enabled language extensions.||` is an internal utility function for constructing generic conversion functions from types with tI 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.}} 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.~~ is a variant of  in the - type class which works for any type with a t instance. 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.#The name without its module prefix.ExamplesnameBase ''Data.Either.Either"Either"nameBase (mkName "foo")"foo"nameBase (mkName "Module.foo")"foo"&Module prefix of a name, if it exists.ExamplesnameModule ''Data.Either.EitherJust "Data.Either"nameModule (mkName "foo")Nothing nameModule (mkName "Module.foo") Just "Module"A name's package, if it exists.Examples namePackage ''Data.Either.Either Just "base"namePackage (mkName "foo")Nothing!namePackage (mkName "Module.foo")NothingJReturns whether a name represents an occurrence of a top-level variable (2), data constructor (3%), type constructor, or type class (4#). If we can't be sure, it returns s.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 TcClsNameOnly used internally4Used for 'x etc, but not available to the programmerTuple data constructorTuple type constructorUnboxed tuple data constructorUnboxed tuple type constructor(Highest allowed operator precedence for  constructor (answer: 9)Default fixity: infixl 9 NOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  (Eq a, Ord b)      !"#$Line and character position%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ahandler to invoke on failurecomputation to runbcdefghijklmnopqrstuvwxyz{|}~ DE`abcdefghijklmnopqrst;^_ YMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"!      NOPQRSTUVWXZ[\]uvwxyz{|}~      !"#$%&'()*+,/-.013245:6789<=>?@ABCFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~FGHIJKLMNOPQRSTUVWXYZ[\DE] ^_`abcdefghijklmnopqrstuvwxyz{|}~BC@A>?<=;56789:12340  ,-./%&'()*+$ !"#     |}~z{yxwvu`abcdefghijklmnopqrst^_Z[\]YVWXQRSTUNOP DE`abcdefghijklmnopqrst;^_ YNOPQRSTUVWXZ[\]uvwxyz{|}~       !"#$%&'()*+,-./0123456789:<=>?@ABCFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~*Quasi-quoting support for Template HaskellNoneOT5Quasi-quoter for expressions, invoked by quotes like lhs = $[q|...]2Quasi-quoter for patterns, invoked by quotes like f $[q|...] = rhs:Quasi-quoter for declarations, invoked by top-level quotes/Quasi-quoter for types, invoked by quotes like  f :: $[q|...]The  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. takes a P and lifts it into one that read the data out of a file. For example, suppose asmqs 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 |} |}None9;!Returns u if the document is emptyAn empty documentA ';' characterA ',' characterA : character A "::" stringA space characterA '=' character A "->" stringA '(' characterA ')' characterA '[' characterA ']' characterA '{' characterA '}' characterWrap document in (...)Wrap document in [...]Wrap document in {...}Wrap document in '...'Wrap document in "..."BesideList version of Beside, separated by spaceList version of 5Above; if there is no overlap it "dovetails" the twoAbove, without dovetailing.List version of Either hcat or vcatEither hsep or vcat"Paragraph fill" version of cat"Paragraph fill" version of sepNested "hang d1 n d2 = sep [d1, nest n d2]6vwx @punctuate p [d1, ... dn] = [d1 <> p, d2 <> p, ... dn-1 <> p, dn]//4vwx6655NoneX      !"#$%&'()*+,-./01234567     X6543210/.-,+*)('&%$#"!      V      !"#$%&'()*+,-./0123456None( Use with 9) Use with OD staticE x = [| static x |]L*Dynamically binding a variable (unhygenic)OSingle-arg lambdacJReturn the Module at the place of splicing. Can be used as an input for j. !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abc !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcCBA@?>=<;:987DE !"#$%&'KLMNFGHIHGJIKJ()L*+,-MN./012O3456789:;P@ABCQFDE<=>?POSQRTRUVWdefXYZ[\]S`ab^_cTUVWghijqrstuvz{|XYZ}~[\klmnop]^_wxy`abc !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abc NoneT !"#$%&'()*+,-./012346789:;<=>?@ABCDFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcghijklmnopqrstuvwxyz{|}`abcdefghijklmnopqrst^_ YMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"!      NOPQRSTUVWXZ[\]wz{|}~      !"#%&'()*+1]^_`acdefghijklmntu89;<=>?@ACDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcU]_`^am%&'()*+nejc !"#MLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"!      utcdfglhiNOPk 1|}~z{w     `abcdefghijklmnopqrst^_VWXQRSTUZ[\]YCA@?>=<;98DE !"#$%&'HGJIKJ()L*+,-NMD./012O346789b@ABCQF<=>?PFGHI:;KLMNz{|XYZ}klmnop]^_wxy`aj[\qrstuvPOSQRTRUVhig^_c`TUVWabWXYZ[\]Sy     !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$$%&'()*+,-./01234567899::;;<<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgefhefiejklmnopqtemplate-haskellLanguage.Haskell.TH.SyntaxLanguage.Haskell.TH.LibLanguage.Haskell.TH.Quote&Language.Haskell.TH.LanguageExtensionsLanguage.Haskell.TH.PprLibLanguage.Haskell.TH.PprLanguage.Haskell.TH.Lib.MapdynLanguage.Haskell.THreturnQbindQ sequenceQliftnewNamemkName mkNameG_v mkNameG_d mkNameG_tcmkNameLmkNameSunTypeunTypeQunsafeTExpCoercecharLstringLintegerLintPrimL wordPrimL floatPrimL doublePrimL rationalL stringPrimL charPrimL liftStringlitPvarPtupP unboxedTupPconPinfixPtildePbangPasPwildPrecPlistPsigPviewPfieldPatmatchclausevarEconElitEappEinfixEinfixAppsectionLsectionRlamElamCaseEtupE unboxedTupEcondEmultiIfEletEcaseEdoEcompEfromE fromThenEfromToE fromThenToElistEsigErecConErecUpdEstaticE unboundVarEfieldExpguardedBnormalBnormalGEpatGEbindSletSnoBindSparSfunDvalDdataDnewtypeDtySynDclassDinstanceWithOverlapDsigDforImpDpragInlD pragSpecD pragSpecInlD pragSpecInstD pragRuleDpragAnnD dataFamilyDopenTypeFamilyD dataInstD newtypeInstD tySynInstDclosedTypeFamilyDinfixLDinfixRDinfixND roleAnnotDstandaloneDerivD defaultSigDcxtnoSourceUnpackednesssourceNoUnpack sourceUnpacknoSourceStrictness sourceLazy sourceStrictnormalCrecCinfixCforallCgadtCrecGadtCbangbangType varBangTypeforallTvarTconTtupleT unboxedTupleTarrowTlistTappTsigT equalityTlitT promotedTpromotedTupleT promotedNilT promotedConsT wildCardTnumTyLitstrTyLitplainTVkindedTVnominalRrepresentationalRphantomRinferRvarKconKtupleKarrowKlistKappKstarK constraintKnoSigkindSigtyVarSiginjectivityAnncCallstdCallcApiprim javaScriptunsafesafe interruptiblefunDeptypeFamdataFamtySynEqnquoteExpquotePatquoteDec quoteTyperuleVar typedRuleVarvalueAnnotationtypeAnnotationmoduleAnnotationLiftExpMatchClauseQExpQDecQPatMatchQClauseQStmtQConQTypeQTypeDec BangTypeQ VarBangTypeQFieldExpFieldPatNamePatQ FieldPatQ FieldExpQFunDepPredPredQ TyVarBndrDecsQ RuleBndrQ TySynEqnQRoleTExpInjectivityAnnKindOverlapNoInlineInline InlinableConLikeFunLike AllPhases FromPhase BeforePhase Overlappable OverlappingOverlaps Incoherentghc-boot-th-8.0.1GHC.LanguageExtensions.TypeMonadFailDesugaring StrictDataStrictTypeApplicationsStaticPointersNamedWildCardsPartialTypeSignaturesPatternSynonyms EmptyCaseOverloadedLabelsDuplicateRecordFieldsNegativeLiteralsBinaryLiterals MultiWayIf LambdaCaseTraditionalRecordSyntax RelaxedLayoutNondecreasingIndentationDatatypeContexts!AlternativeLayoutRuleTransitionalAlternativeLayoutRuleExplicitForAllPackageImportsExplicitNamespaces TypeOperatorsImpredicativeTypes RankNTypesLiberalTypeSynonyms PatternGuards TupleSectionsPostfixOperators RecursiveDoGeneralizedNewtypeDerivingMonadComprehensionsTransformListCompParallelListCompRoleAnnotationsKindSignaturesEmptyDataDecls MagicHashExistentialQuantification UnicodeSyntaxFunctionalDependenciesNullaryTypeClassesMultiParamTypeClassesConstrainedClassMethodsFlexibleInstancesFlexibleContextsTypeSynonymInstances DeriveLiftDeriveAnyClassDefaultSignatures DeriveGenericDeriveFoldableDeriveTraversable DeriveFunctorAutoDeriveTypeableDeriveDataTypeableStandaloneDeriving ApplicativeDo InstanceSigs DataKinds PolyKindsConstraintKindsRebindableSyntaxDoAndIfThenElseNPlusKPatterns GADTSyntaxGADTs ViewPatterns RecordPunsRecordWildCardsDisambiguateRecordFields NumDecimalsOverloadedListsOverloadedStrings TypeInTypeTypeFamilyDependencies TypeFamilies BangPatterns UnboxedTuplesAllowAmbiguousTypesScopedTypeVariablesImplicitPreludeImplicitParams QuasiQuotesTemplateHaskellQuotesTemplateHaskellArrowsParallelArrays JavaScriptFFIGHCForeignImportPrimCApiFFIInterruptibleFFIUnliftedFFITypesForeignFunctionInterfaceExtendedDefaultRulesRelaxedPolyRecMonoLocalBinds MonoPatBindsMonomorphismRestrictionUndecidableSuperClassesIncoherentInstancesUndecidableInstancesOverlappingInstancesCpp Extension AnnLookupAnnLookupModule AnnLookupNameNominalRRepresentationalRPhantomRInferRTyLitNumTyLitStrTyLitFamilyResultSigNoSigKindSigTyVarSigPlainTVKindedTVForallTAppTSigTVarTConT PromotedTInfixTUInfixTParensTTupleT UnboxedTupleTArrowT EqualityTListTPromotedTupleT PromotedNilT PromotedConsTStarT ConstraintTLitT WildCardT VarStrictType StrictType VarBangTypeBangTypeBangConNormalCRecCInfixCForallCGadtCRecGadtCDecidedStrictness DecidedLazy DecidedStrict DecidedUnpackSourceStrictnessNoSourceStrictness SourceLazy SourceStrictSourceUnpackednessNoSourceUnpackednessSourceNoUnpack SourceUnpackCxt AnnTargetModuleAnnotationTypeAnnotationValueAnnotationRuleBndrRuleVar TypedRuleVarPhases RuleMatchPragmaInlineP SpecialisePSpecialiseInstPRulePAnnPLinePSafetyUnsafeSafe InterruptibleCallconvCCallStdCallCApiPrim JavaScriptForeignImportFExportF FamFlavourTypeFamDataFamTySynEqnTypeFamilyHeadFunDValDDataDNewtypeDTySynDClassD InstanceDSigDForeignDInfixDPragmaD DataFamilyD DataInstD NewtypeInstD TySynInstDOpenTypeFamilyDClosedTypeFamilyD RoleAnnotDStandaloneDerivD DefaultSigDRangeFromR FromThenRFromToR FromThenToRStmtBindSLetSNoBindSParSGuardNormalGPatGBodyGuardedBNormalBVarEConELitEAppEInfixEUInfixEParensELamELamCaseETupE UnboxedTupECondEMultiIfELetECaseEDoECompE ArithSeqEListESigERecConERecUpdEStaticE UnboundVarELitPVarPTupP UnboxedTupPConPInfixPUInfixPParensPTildePBangPAsPWildPRecPListPSigPViewPLitCharLStringLIntegerL RationalLIntPrimL WordPrimL FloatPrimL DoublePrimL StringPrimL CharPrimLFixityDirectionInfixLInfixRInfixNFixity InstanceDecUnliftedArity ParentName ModuleInfoInfoClassIClassOpITyConIFamilyI PrimTyConIDataConIVarITyVarICharPosLoc loc_filename loc_package loc_module loc_startloc_endNameIsAloneAppliedInfixUniq NameSpaceVarNameDataName TcClsName NameFlavourNameSNameQNameUNameLNameGOccNameModulePkgNameModNameunQQuasiqNewNameqReportqRecover qLookupNameqReify qReifyFixityqReifyInstances qReifyRolesqReifyAnnotations qReifyModuleqReifyConStrictness qLocationqRunIOqAddDependentFile qAddTopDeclsqAddModFinalizerqGetQqPutQ qIsExtEnabled qExtsEnabledbadIOcounterrunQreport reportError reportWarningrecover lookupNamelookupTypeNamelookupValueNamereify reifyFixityreifyInstances reifyRolesreifyAnnotations reifyModulereifyConStrictness isInstancelocationrunIOaddDependentFile addTopDeclsaddModFinalizergetQputQ isExtEnabled extsEnabledtrueName falseName nothingNamejustNameleftName rightNamedataToQa dataToExpQliftData dataToPatQ mkModName modString mkPkgName pkgString mkOccName occStringnameBase nameModule namePackage nameSpacemkNameUmkNameGshowName showName' tupleDataName tupleTypeName mk_tup_nameunboxedTupleDataNameunboxedTupleTypeNamemk_unboxed_tup_name maxPrecedence defaultFixitycmpEqthenCmp $fShowName $fOrdName$fLift(,,,,,,) $fLift(,,,,,) $fLift(,,,,) $fLift(,,,) $fLift(,,) $fLift(,)$fLift()$fLift[] $fLiftEither $fLiftMaybe $fLiftBool $fLiftChar $fLiftDouble $fLiftFloat $fLiftRatio $fLiftNatural $fLiftWord64 $fLiftWord32 $fLiftWord16 $fLiftWord8 $fLiftWord $fLiftInt64 $fLiftInt32 $fLiftInt16 $fLiftInt8 $fLiftInt $fLiftInteger$fQuasiQ$fApplicativeQ $fFunctorQ $fMonadFailQ$fMonadQ $fQuasiIO $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$fShowFamFlavour$fEqFamFlavour$fOrdFamFlavour$fDataFamFlavour$fGenericFamFlavour$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$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 $fShowDec$fEqDec$fOrdDec $fDataDec $fGenericDec $fShowPragma $fEqPragma $fOrdPragma $fDataPragma$fGenericPragma $fShowExp$fEqExp$fOrdExp $fDataExp $fGenericExp $fShowRange $fEqRange $fOrdRange $fDataRange$fGenericRange $fShowStmt$fEqStmt $fOrdStmt $fDataStmt $fGenericStmt $fShowPat$fEqPat$fOrdPat $fDataPat $fGenericPat $fShowGuard $fEqGuard $fOrdGuard $fDataGuard$fGenericGuard $fShowMatch $fEqMatch $fOrdMatch $fDataMatch$fGenericMatch $fShowBody$fEqBody $fOrdBody $fDataBody $fGenericBody $fShowClause $fEqClause $fOrdClause $fDataClause$fGenericClause $fShowInfo$fEqInfo $fOrdInfo $fDataInfo $fGenericInfo QuasiQuoter quoteFileDocPprMpprNamepprName' to_HPJ_DocisEmptyemptysemicommacolondcolonspaceequalsarrowlparenrparenlbrackrbracklbracerbracetextptextcharintintegerfloatdoublerationalparensbracketsbracesquotes doubleQuotes<>hcat<+>hsep$$$+$vcatcatsepfcatfsepnesthang punctuate $fMonadPprM$fApplicativePprM $fFunctorPprM $fShowPprMPprpprppr_list Precedence nestDepthappPrecopPrecunopPrecnoPrecparensIfpprintppr_sig pprFixity pprPrefixOccisSymOcc isSymbolASCII pprInfixExppprExp pprFields pprMaybeExp pprGuardedpprBodypprLit bytesToString pprStringpprPatppr_dec ppr_overlapppr_data ppr_newtype ppr_tySyn ppr_tf_headcommaSepApplied pprForall pprRecFields pprGadtRHSpprVarBangType pprBangTypepprVarStrictType pprStrictType pprParendType pprUInfixTpprTyApp pprFunArgTypesplitpprTyLitpprCxt ppr_cxt_preds where_clause showtextl hashParens quoteParenscommaSep commaSepWithsemiSep$fPprLoc $fPprRange $fPprRole$fPprTyVarBndr $fPprTyLit $fPprType$fPprDecidedStrictness$fPprSourceStrictness$fPprSourceUnpackedness $fPprBang$fPprCon $fPprClause $fPprRuleBndr $fPprPhases$fPprRuleMatch $fPprInline $fPprPragma $fPprForeign$fPprInjectivityAnn$fPprFamilyResultSig$fPprFamFlavour $fPprFunDep$fPprDec$fPprPat$fPprLit $fPprMatch $fPprStmt$fPprExp$fPprModuleInfo $fPprModule $fPprInfo $fPprName$fPpr[]VarStrictTypeQ StrictTypeQBangQSourceUnpackednessQSourceStrictnessQRangeQGuardQBodyQCxtQTyLitQTExpQInfoQuInfixPparensPfromR fromThenRfromToR fromThenToRnormalGpatGparensEuInfixElam1E arithSeqEstringE instanceD pragLineD familyNoKindD familyKindDclosedTypeFamilyNoKindDclosedTypeFamilyKindDinfixTuInfixTparensTclassPequalPisStrict notStrictunpacked strictType varStrictTypeappsE thisModuleSizeMapBinTip singletonsizelookupinsertbalanceLbalanceRdeltaratiobaseGHC.BasefailJustNothing Data.DataDataghc-prim GHC.TypesTruerunPprMState