нУЁh& 6К┐У !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─ │ ┌ ┐ └ ┘ ├ ┤ ┬ ┴ ┼ ▀ ▄ █ ▌ ▐ ░ ▒ ▓ ⌠ ■ ∙ √ ≈ ≤ ≥ ⌡ ° ² · ÷ ═ ║ ╒ ё є ╔ і ї ╗ ╘ ╙ ╚ ╛ ґ ў ╞ ╟ ╠ ╡ Ё Є ╣ І Ї ╦ ╧ ╨ ╩ ╪ Ґ Ў © ю а б ц д е ф г х и й к л м н о п я р с т у ж в ь ы з ш э щ ч ъ Ю А Б Ц Д Е Ф Г Х И Й К Л М Н О П Я Р С Т У Ж В Ь Ы З Ш Э Щ Ч Ъ ─ │ ┌ ┐ └ ┘ ├ ┤ ┬ ┴ ┼ ▀ ▄ █ ▌ ▐ ░ ▒ ▓ ⌠ ■ ∙ √ ≈ ≤ ≥ ⌡ ° ² · ÷ ═ ║ ╒ ё є ╔ і ї ╗ ╘ ╙ ╚ ╛ ґ ў ╞ ╟ ╠ ╡ Ё Є ╣ І Ї ╦ ╧ ╨ ╩ ╪ Ґ Ў © ю а б ц д е ф г х и й к л м н о п я р с т у ж в ь ы з ш э щ ч ъ Ю А Б Ц Д Е Ф Г Х И Й К Л М Н О П Я Р С Т "(c) The University of Glasgow 2015/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgexperimentalportableSafeqЩЗЫЬВЖУТСРЯПОНМЛКЙИХГФЕДЦБАЮъчщэшзыьвжутсряпонмлкйихгфедцбаю©ЎҐ╪╩╨╧╦ЇІ╣ЄЁ╡╠╟╞ўґ╛╚╙╘╗їі╔єё╒║═÷·²°⌡ ≥≤≈√∙■⌠▓▒░▐▌█▄▀┼┴┬┤├┘└┐┌│─ЪЧЩЗЫЬВЖУТСРЯПОНМЛКЙИХГФЕДЦБАЮъчщэшзыьвжутсряпонмлкйихгфедцбаю©ЎҐ╪╩╨╧╦ЇІ╣ЄЁ╡╠╟╞ўґ╛╚╙╘╗їі╔єё╒║═÷·²°⌡ ≥≤≈√∙■⌠▓▒░▐▌█▄▀┼┴┬┤├┘└┐┌│─ЪЧ Safe┘У Ж В Ь "(c) The University of Glasgow 2003/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgexperimentalportableTrustworthy ()/057:;юбиклжшНЇr╡template-haskellоTurn 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 splicef = \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:Оg = $(do nm1 <- newName "x" let nm2 = mkName "x" return (LamE [VarP nm2] (LamE [VarP nm1] (VarE nm2))) )will produce the spliceg = \x -> \x0 -> x0since the occurrence VarE nm2+ is captured by the innermost binding of x , namely VarP nm1.template-haskell┘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 tog = Prelude.pi + 3 Note that mkName" may be used with qualified names:mkName "Prelude.pi" See also е for a useful combinator. The above example could be rewritten using asf = [| pi + $(dyn "pi") |]template-haskellOnly used internally template-haskell.Underlying untyped Template Haskell expression template-haskellюExtract the untyped representation from the typed representationtemplate-haskellшTurn a value into a Template Haskell typed expression, suitable for use in a typed splice. template-haskellрUnsafely convert an untyped code representation into a typed code representation.кtemplate-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 ( [| ... |] or [|| ... ||]*) but not at the top level. As an example:2add1 :: Int -> Q (TExp Int) 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) АD x and $$(liftTyped x) АD x for all x, where $(...) and $$(...)а are Template Haskell splices. It is additionally expected that x АD о ( x).к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 LiftLevity-polymorphic since template-haskell-2.16.0.0.лtemplate-haskellThe лж class implements the minimal interface which is necessary for desugaring quotations.The Monad mф superclass is needed to stitch together the different AST fragments.у is used when desugaring binding structures such as lambdas to generate fresh names.гTherefore the type of an untyped quotation in GHC is `Quote m => m Exp`├For many years the type of a quotation was fixed to be `Q Exp` but by more precisely specifying the minimal interface it enables the ме to be extracted purely from the quotation without interacting with п.рtemplate-haskellPattern in Haskell given in {}тtemplate-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-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 NameПs are looked up at the point where the current splice is being run. These names can never be captured.д 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 ConstraintKindsц, constraints are really just types. Equality constraints use the Эц constructor. Constraints may also be tuples of other constraints.Цtemplate-haskell┬One 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:фtype 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-haskellInjectivity annotationФtemplate-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 ┴е, but many of the other constructors are shared. Note that the kind Bool is denoted with З, not ┤'. Similarly, tuple kinds are made with ▀, not ┬.Гtemplate-haskell&Varieties of allowed instance overlap.Хtemplate-haskell A single deriving! clause at the end of a datatype.Иtemplate-haskell>=) which allows effectful computations to be injected into code generation.▄template-haskellыVariant of (>>) which allows effectful computations to be injected into code generation.░template-haskell░ converts a value to a мЧ 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▒ converts a value to a рЧ 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▓Ю is an internal utility function for constructing generic conversion functions from types with Ш и instances to various quasi-quoting representations. See the source of ░ and ▒ for two example usages: mkCon, mkLit and appQя are overloadable to account for different syntax for expressions and patterns; antiQе allows you to override type-specific cases, a common usage is just const Nothing#, which results in no overloading.⌠template-haskellDefault fixity: infixl 9∙template-haskell%List all enabled language extensions.≈template-haskellзRetreives the Haddock documentation at the specified location, if one exists. It can be used to read documentation on things defined outside of the current module, provided that those modules were compiled with the -haddock flag.≤template-haskellGet state from the пЯ monad. Note that the state is local to the Haskell module in which the Template Haskell expression is executed.≥template-haskellпModify the ambient monad used during code generation. For example, you can use ≥ to handle a state effect: А handleState :: Code (StateT Int Q) a -> Code Q a handleState = hoistCode (flip runState 0) template-haskellаDetermine whether the given language extension is enabled in the п monad.⌡template-haskell%Is the list of instances returned by © nonempty?°template-haskell7A useful combinator for embedding monadic actions into Л Г myCode :: ... => Code m a myCode = joinCode $ do x <- someSideEffect return (makeCodeWith x) ÷template-haskell4Lift a monadic action producing code into the typed Л representation═template-haskell═ is a variant of in the к- type class which works for any type with a Ш instance.║template-haskell2The location at which this computation is spliced.ёtemplate-haskellрLook up the given name in the (type namespace of the) current splice's scope. See %Language.Haskell.TH.Syntax#namelookup for more details.єtemplate-haskellсLook 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(Highest allowed operator precedence for а constructor (answer: 9)╗template-haskell4Used for 'x etc, but not available to the programmer╘template-haskellOnly used internallyў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.EitherJust "base"namePackage (mkName "foo")Nothing!namePackage (mkName "Module.foo")Nothing╠template-haskellйReturns 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.idJust VarNamenameSpace (mkName "id")2Nothing -- only works for top-level variable namesnameSpace 'Data.Maybe.Just Just DataNamenameSpace ''Data.Maybe.MaybeJust TcClsNamenameSpace ''Data.Ord.OrdJust TcClsName╦template-haskellґAdd Haddock documentation to the specified location. This will overwrite any documentation at the location if it already exists. This will reify the specified name, so it must be in scope when you call it. If you want to add documentation to something that you are currently splicing, you can use ┤ e.g.Аdo let nm = mkName "x" addModFinalizer $ putDoc (DeclDoc nm) "Hello" [d| $(varP nm) = 42 |]The helper functions withDecDoc and withDecsDoc$ will do this for you, as will the funD_doc and other _doc0 combinators. You most likely want to have the -haddockЖ flag turned on when using this. Adding documentation to anything outside of the current module will cause an error.╧template-haskellReplace the state in the пЯ monad. Note that the state is local to the Haskell module in which the Template Haskell expression is executed.╨template-haskellRecover from errors raised by д or Щ .╩template-haskell╩ looks up information about the э. 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-haskellreifyModule mod# looks up information about module modп. To look up the current module, call this function with the return value of .аtemplate-haskell reifyRoles nmг returns the list of roles associated with the parameters of the tycon nm. Fails if nmк cannot be found or is not a tycon. The returned list should never contain н.бtemplate-haskellreifyType nm& attempts to find the type or kind of nm. For example, reifyType 'not returns Bool -> Bool, and reifyType ''Bool returns Typeт. This works even if there's no explicit signature and the type or kind is inferred.цtemplate-haskell>Report an error (True) or warning (False), but carry on; use Щ to stop.дtemplate-haskellСReport 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-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-haskellTuple data constructorнtemplate-haskellTuple type constructorоtemplate-haskellлDiscard the type annotation and produce a plain Template Haskell expressionLevity-polymorphic since template-haskell-2.16.0.0.пtemplate-haskellUnboxed sum data constructorяtemplate-haskellUnboxed sum type constructorрtemplate-haskellUnboxed tuple data constructorсtemplate-haskellUnboxed tuple type constructorтtemplate-haskell4Annotate the Template Haskell expression with a typeПThis is unsafe because GHC cannot check for you that the expression really does have the type you claim it has.Levity-polymorphic since template-haskell-2.16.0.0.уtemplate-haskell&Annotation target for reifyAnnotationsэtemplate-haskellIn т, arity of the type constructorчtemplate-haskellC { {-# UNPACK #-} !}aЮtemplate-haskell+f p { | e1 = e2 | e3 = e4 } where dsАtemplate-haskellf p { = e } where dsБtemplate-haskell#Raw bytes embedded into the binary.ЕAvoid using Bytes constructor directly as it is likely to change in the future. Use helpers such as mkBytes$ in Language.Haskell.TH.Lib instead.Дtemplate-haskellOffset from the pointerЕtemplate-haskellPointer to the dataФtemplate-haskellЫNumber of bytes Maybe someday: , bytesAlignement :: Word -- ^ Alignement constraint , bytesReadOnly :: Bool -- ^ Shall we embed into a read-only -- section or not , bytesInitialized :: Bool -- ^ False: only use Фе to allocate -- an uninitialized regionНtemplate-haskellf { p1 p2 = body where decs }Пtemplate-haskellUnderlying monadic valueЯtemplate-haskellforall a. Eq a => C [a]Рtemplate-haskellC :: a -> b -> T b IntСtemplate-haskellInt :+ aТtemplate-haskellC Int aУtemplate-haskellC { v :: Int, w :: a }Жtemplate-haskellC :: { v :: Int } -> T b IntЬtemplate-haskell { class Eq a => Ord a where ds }Ыtemplate-haskell3{ type family F a b = (r :: *) | r -> a where ... }Зtemplate-haskellт{ data Cxt x => T x = A x | B (T x) deriving (Z,W) deriving stock Eq }Шtemplate-haskell+data families (may also appear in [Dec] of Ь and ┌)Эtemplate-haskellФ{ data instance Cxt x => T [x] = A x | B (T x) deriving (Z,W) deriving stock Eq }Щtemplate-haskell&{ default size :: Data a => a -> Int }Чtemplate-haskell-{ foreign import ... } { foreign export ... }Ъtemplate-haskell{ f p1 p2 = b where decs }─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{ infix 3 foo }┌template-haskellа{ instance {-# OVERLAPS #-} Show w => Show [w] where ds }┐template-haskell{ type TypeRep :: k -> Type }└template-haskellс{ newtype Cxt x => T x = A (B x) deriving (Z,W Q) deriving stock Eq }┘template-haskellФ{ newtype instance Cxt x => T [x] = A (B x) deriving (Z,W) deriving stock Eq }├template-haskell0open type families (may also appear in [Dec] of Ь and ┌)┤template-haskellPattern Synonyms┬template-haskell#A pattern synonym's type signature.┴template-haskellpragmas┼template-haskell({ type role T nominal representational }▀template-haskell{ length :: [a] -> Int }▄template-haskell0{ deriving stock instance Ord a => Ord (Foo a) }█template-haskell{ type T x = (x,x) }▌template-haskell{ type instance ... }▐template-haskell{ p = b where decs }░template-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{ deriving stock (Eq, Ord) }∙template-haskell-XDeriveAnyClass√template-haskell-XGeneralizedNewtypeDeriving≈template-haskellA "standard" derived instance≤template-haskell -XDerivingVia≥template-haskellзA location at which to attach Haddock documentation. Note that adding documentation to a э< defined oustide of the current module will cause an error. template-haskell?At a specific argument of a function, indexed by its position.⌡template-haskell,At a declaration, not necessarily top level.°template-haskellAt a class or family instance.²template-haskellAt the current module's header.·template-haskell{ f x }÷template-haskell { f @Int }═template-haskell{ [ 1 ,2 .. 10 ] }║template-haskell{ case e of m1; m2 }╒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 ]бCompE [BindS (VarP x) (VarE xs), NoBindS (AppE (VarE f) (VarE x))]ёtemplate-haskell"data T1 = C1 t1 t2; p = {C1} e1 e2єtemplate-haskell{ if e1 then e2 else e3 }╔template-haskell{ do { p <- e1; e2 } }1 or a qualified do if the module name is presentіtemplate-haskell { exp.field } ( Overloaded Record Dot )їtemplate-haskell{ ?x } ( Implicit parameter )╗template-haskell%{x + y} or {(x+)} or {(+ x)} or {(+)}╘template-haskell{ #x } ( Overloaded label )╙template-haskell{ \case m1; m2 }╚template-haskell{ \ p1 p2 -> e }╛template-haskell{ let { x=e1; y=e2 } in e3 }ґtemplate-haskell{ [1,2,3] }ўtemplate-haskell{ 5 or 'c'}╞template-haskell!{ mdo { x <- e1 y; y <- e2 x; } }2 or a qualified mdo if the module name is present╟template-haskell{ if | g1 -> e1 | g2 -> e2 }╠template-haskell{ (e) }See Language.Haskell.TH.Syntax#infix╡template-haskell(.x) or (.x.y) (Record projections)Ёtemplate-haskell{ T { x = y, z = w } }Єtemplate-haskell{ (f x) { z = w } }╣template-haskell { e :: t }Іtemplate-haskell{ static e }Їtemplate-haskell{ (e1,e2) }The Ъ + is necessary for handling tuple sections.(1,) translates to'TupE [Just (LitE (IntegerL 1)),Nothing]╦template-haskell{x + y}See Language.Haskell.TH.Syntax#infix╧template-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.╨template-haskell{ (#|e|#) }╩template-haskell{ (# e1,e2 #) }The Ъ + is necessary for handling tuple sections. (# 'c', #) translates to-UnboxedTupE [Just (LitE (CharL 'c')),Nothing]╪template-haskell{ x }Ґtemplate-haskellType family result signatureЎtemplate-haskellk©template-haskellno signatureюtemplate-haskell= r, = (r :: k)лtemplate-haskellf x { | odd x } = xмtemplate-haskell&f x { | Just y <- x, Just z <- y } = zнtemplate-haskellObtained from ╩ in the п Monad.оtemplate-haskell-A class, with a list of its visible instancesпtemplate-haskellA class methodяtemplate-haskellA data constructorрtemplate-haskellПA type or data family, with a list of its visible instances. A closed type family is returned with 0 instances.сtemplate-haskellA pattern synonymтtemplate-haskellюA "primitive" type constructor, which can't be expressed with a в . Examples: (->), Int#.уtemplate-haskellлA "plain" type constructor. "Fancier" type constructors are returned using т or р■ as appropriate. At present, this reified declaration will never have derived instances attached to it (if you wish to check for an instance, see ©).жtemplate-haskellA type variable.The Typeт field contains the type which underlies the variable. At present, this is always ▐ theName5, but future changes may permit refinement of this.вtemplate-haskell7A "value" variable (as opposed to a type variable, see ж).The Maybe Dec field contains JustА the declaration which defined the variable - including the RHS of the declaration - or else Nothingь, in the case where the RHS is unavailable to the compiler. At present, this value is always Nothingя: returning the RHS has not yet been implemented because of lack of interest.зtemplate-haskellзх describes 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-haskellSome raw bytes, type ─:Бtemplate-haskell⌡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?Еtemplate-haskell!A primitive C-style string, type ─Нtemplate-haskell$case e of { pat -> body where decs }Пtemplate-haskellObtained from ю and .Рtemplate-haskellObtained from ю in the п Monad.Сtemplate-haskell'Contains the import list of the module.Жtemplate-haskell≤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Вtemplate-haskell&Local name bound outside of the TH ASTЬtemplate-haskell#A qualified name; dynamically boundЫtemplate-haskell&An unqualified name; dynamically boundЗtemplate-haskellA unique local name─template-haskellData constructors│template-haskellпType constructors and classes; Haskell has them in the same name space for now.┌template-haskell Variables┘template-haskellIn п and я", name of the parent class or type├template-haskell { x @ p }┤template-haskell{ !p }┬template-haskell'data T1 = C1 t1 t2; {C1 @ty1 p1 p2} = e┴template-haskellfoo ({x :+ y}) = e┼template-haskell{ [1,2,3] }▀template-haskell{ 5 or 'c' }▄template-haskell{(p)}See Language.Haskell.TH.Syntax#infix█template-haskellf (Pt { pointx = x }) = g x▌template-haskell { p :: t }▐template-haskell{ ~p }░template-haskell{ (p1,p2) }▒template-haskellfoo ({x :+ y}) = eSee Language.Haskell.TH.Syntax#infix▓template-haskell{ (#|p|#) }⌠template-haskell{ (# p1,p2 #) }■template-haskell{ x }∙template-haskell { e -> p }√template-haskell{ _ }≈template-haskell"A pattern synonym's argument type.≤template-haskellpattern {x P y} = p≥template-haskellpattern P {x y z} = p template-haskellpattern P { {x,y,z} } = p⌡template-haskell#A pattern synonym's directionality.°template-haskell pattern P x {<-} p where P x = e²template-haskellpattern P x {=} p·template-haskellpattern P x {<-} p÷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 = *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: Кthe (possibly empty lists of) universally quantified type variables and required constraints on them.Яthe (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 , 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 ┬з either one of the universals, the existentials, or their contexts may be left empty.уSee the GHC user's guide for more information on pattern synonyms and their types: Бhttps://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#pattern-synonyms.╔template-haskell+{ {-# COMPLETE C_1, ..., C_i [ :: T ] #-} }мtemplate-haskellRole annotationsнtemplate-haskell_оtemplate-haskellnominalпtemplate-haskellphantomяtemplate-haskellrepresentationalзtemplate-haskellC aшtemplate-haskellC {~}aэtemplate-haskellC {!}aчtemplate-haskellC aъtemplate-haskellC { {-# NOUNPACK #-} } aЮtemplate-haskellC { {-# UNPACK #-} } aБtemplate-haskell{a}Цtemplate-haskellaДtemplate-haskellp <- eЕtemplate-haskell{ let { x=e1; y=e2 } }Фtemplate-haskelleГtemplate-haskellx <- e1 | s2, s3 | s4 (in ╒)Хtemplate-haskellrec { s1; s2 }И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-haskellIn ╨ and ▓=, the number associated with a particular data constructor. Кйs 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)Лtemplate-haskellIn ╨, █, and ▓, the total number of Кs. For example, (#|#) has a Л of 2.Мtemplate-haskell(Represents an expression which has type a. Built on top of м6, typed expressions allow for type-safe splicing via:typed quotes, written as [|| ... ||] where ...4 is an expression; if that expression has type a#, then the quotation has type п (М a)1typed splices inside of typed quotes, written as $$(...) where ...) is an arbitrary expression of type п (М a)рTraditional expression quotes and splices let us construct ill-typed expressions:.fmap ppr $ runQ [| True == $( [| "foo" |] ) |]#GHC.Types.True GHC.Classes.== "foo"#GHC.Types.True GHC.Classes.== "foo" error:ц ╒@ Couldn't match expected type ≤@Bool≥@ with actual type ≤@[Char]≥@6 ╒@ In the second argument of ≤@(==)≥@, namely ≤@"foo"≥@& In the expression: True == "foo"1 In an equation for ≤@it≥@: it = True == "foo"3With typed expressions, the type error occurs when constructing" the Template Haskell expression:3fmap ppr $ runQ [|| True == $$( [|| "foo" ||] ) ||] error:. ╒@ Couldn't match type ≤@[Char]≥@ with ≤@Bool≥@" Expected type: Q (TExp Bool)$ Actual type: Q (TExp [Char])5 ╒@ In the Template Haskell quotation [|| "foo" ||]& In the expression: [|| "foo" ||]6 In the Template Haskell splice $$([|| "foo" ||])Levity-polymorphic since template-haskell-2.16.0.0.Пtemplate-haskell'C', @since 4.16.0.0Яtemplate-haskell2Рtemplate-haskell"Hello"Уtemplate-haskell(a :: k)Жtemplate-haskellaВtemplate-haskellT @k tЬtemplate-haskellT a bЫtemplate-haskell->Зtemplate-haskellTШtemplate-haskell ConstraintЭtemplate-haskell~Щtemplate-haskellforall . => Чtemplate-haskellforall -> Ъtemplate-haskell?x :: t─template-haskellT + T│template-haskell[]┌template-haskell0,1,2, etc.┐template-haskellFUN└template-haskell(T)┘template-haskell(':)├template-haskell'[]┤template-haskell'T┬template-haskell'(), '(,), '(,,), etc.┴template-haskellt :: k┼template-haskell*▀template-haskell(,), (,,), etc.▄template-haskellT + TSee Language.Haskell.TH.Syntax#infix█template-haskell(#|#), (#||#), etc.▌template-haskell(#,#), (#,,#), etc.▐template-haskella░template-haskell_▒template-haskellCommon elements of ├ and Ыс. 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-haskellUniq5 is used by GHC to distinguish names from each other.■template-haskellIn т#, is the type constructor unlifted?∙template-haskellAs of template-haskell-2.11.0.0, ∙ has been replaced by ы.╩template-haskellProduces an ─п literal from the NUL-terminated C-string starting at the given memory address.пtemplate-haskellрtemplate-haskellыtemplate-haskellзtemplate-haskellшtemplate-haskellэtemplate-haskellщtemplate-haskellчtemplate-haskellъtemplate-haskellЮtemplate-haskellАtemplate-haskellБtemplate-haskellЦtemplate-haskellДtemplate-haskellЕtemplate-haskellФtemplate-haskellГtemplate-haskellХtemplate-haskellИtemplate-haskellЙtemplate-haskellКtemplate-haskellНtemplate-haskellIf the function passed to │; inspects its argument, the resulting action will throw a ┌.Пtemplate-haskellЯtemplate-haskell ╨template-haskellhandler to invoke on failuretemplate-haskellcomputation to runМtemplate-haskellLine and character positionВtemplate-haskell (Eq a, Ord b)Шtemplate-haskell{ data family T a b c :: * }├template-haskell-{ type family T a b c = (r :: *) | r -> a b }┤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 bidirectionalБalso, besides prefix pattern synonyms, both infix and record pattern synonyms are supported. See ≈ for details┴template-haskell{ {-# INLINE [1] foo #-} }╨template-haskellFresh namesҐtemplate-haskellthe error handlertemplate-haskellaction which may failtemplate-haskellRecover from the monadic Щ фtemplate-haskellюReport an error (True) or warning (False) ...but carry on; use Щ to stopн клм╡ії╘╧ІЄЁ╣ґ═╒╞╔║╛╟є╨╩Ї╙╚╠╦╗÷·ў╪ёнНоНп╚╛р∙▌┼█√├┤▐▄▒┴┬▓⌠░▀■сХГФДЕтЖРЯСТУжЪ░┌Ш┼┘├┬│Э┐Ы█▌▀└▄─┤З▐┴ВЬЩЧв─┬┤Щ▄┼Ы├▌┘ЭШ┴│Ч┐▀┌Ь█└ЗЪ▐ьызшэТчйъБрсЦСЕьФГЫЬЖВХ■И≤√≈∙ЛОПМОЗЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЫЬ│─ЪЧЩЭШ┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьшызэщчъЮАБФЕЦДГЙХЛКИМВ░⌠▒▓≥° ²⌡Ґю©ЎабцедфгихклмнжвсятруопыПОНзшчэЕъЮФАЦБщДГМЛКЙХИПЯРСУЖВЗЫЬШЩЧЭЪ│┌─┐└┘≈ ≥≤⌡°·²÷═УСТ║╒ё╔їє╗╘і╙ґг╣╩ЄЇ╪Іў╠╟Ё╡╞╦юц©дбеаЎ╧Ґ╨фхклиймнпоятЯРужвьызшэщчЮъАЦБИЙКЛМН ОПЯРТЖУ▒▓⌠■∙я клм╡ії╘╧ІЄЁ╣ґ═╒╞╔║╛╟є╨╩Ї╙╚╠╦╗÷·ў╪ёнНоНп╚╛р∙▌┼█√├┤▐▄▒┴┬▓⌠░▀■сХГФДЕтЖРЯСТУжЪ░┌Ш┼┘├┬│Э┐Ы█▌▀└▄─┤З▐┴ВЬЩЧв─┬┤Щ▄┼Ы├▌┘ЭШ┴│Ч┐▀┌Ь█└ЗЪ▐ьызшэТчйъБрсЦСЕьФГЫЬЖВХ■И≤√≈∙ЛОПМО┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьшызэщчъЮАБФЕЦДГЙХЛКИМВ░⌠▒▓≥° ²⌡Ґю©ЎабцедфгихклмнжвсятруопыПОНзшчэЕъЮФАЦБщДГМЛКЙХИПЯРСУЖВЗЫЬШЩЧЭЪ│┌─┐└┘≈ ≥≤⌡°·²÷═УСТ║╒ё╔їє╗╘і╙ґг╣╩ЄЇ╪Іў╠╟Ё╡╞╦юц©дбеаЎ╧Ґ╨фхклиймнпоятЯРужвьызшэщчЮъАЦБИЙКЛМН ОПЯРТЖУ▒▓⌠■∙│─ЪЧЩЭШ*Quasi-quoting support for Template HaskellSafeжшд└Ґtemplate-haskell5Quasi-quoter for expressions, invoked by quotes like lhs = $[q|...]Ўtemplate-haskell2Quasi-quoter for patterns, invoked by quotes like f $[q|...] = rhs©template-haskell:Quasi-quoter for declarations, invoked by top-level quotesюtemplate-haskell/Quasi-quoter for types, invoked by quotes like f :: $[q|...]Бtemplate-haskellБ takes a Цп and lifts it into one that read the data out of a file. For example, suppose asmqР 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Ц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. ░▒▓БЦД©ҐЎю ЦД©ҐЎюБ▓░▒SafeюбкE"Еtemplate-haskell5Above; if there is no overlap it "dovetails" the twoФtemplate-haskellAbove, without dovetailing.Гtemplate-haskellBeside, separated by spaceХtemplate-haskellBesideИtemplate-haskell A "->" stringЙtemplate-haskellWrap document in {...}Кtemplate-haskellWrap document in [...]Лtemplate-haskellEither hcat or vcatНtemplate-haskellA : characterОtemplate-haskellA ',' characterПtemplate-haskell A "::" stringРtemplate-haskellWrap document in "..."Сtemplate-haskellAn empty documentТtemplate-haskellA '=' characterУtemplate-haskell"Paragraph fill" version of catВtemplate-haskell"Paragraph fill" version of sepЬtemplate-haskell"hang d1 n d2 = sep [d1, nest n d2]Ыtemplate-haskellList version of ХЗtemplate-haskellList version of ГЩtemplate-haskellReturns ┐ if the document is emptyЧtemplate-haskellA '{' characterЪtemplate-haskellA '[' character─ template-haskellA '(' character│ template-haskellNested┌ template-haskellWrap document in (...)├ template-haskellюpunctuate p [d1, ... dn] = [d1 <> p, d2 <> p, ... dn-1 <> p, dn]┤ template-haskellWrap document in '...'┴ template-haskellA '}' character┼ template-haskellA ']' character▀ template-haskellA ')' character▄ template-haskellA ';' character█ template-haskellEither hsep or vcat▌ template-haskellA space character▒ template-haskellList version of Е/ЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─ │ ┌ ┐ └ ┘ ├ ┤ ┬ ┴ ┼ ▀ ▄ █ ▌ ▐ ░ ▒ ▓ ⌠ /▓ ⌠ С▄ ОНП▌ ТИ─ ▀ Ъ┼ Ч┴ ▐ М┘ ШЭЖЯ┬ ┌ КЙ┤ РХГЫЗЕФ▒ █ ЛВУ│ Ь├ Щ░ ┐ └ Е5Ф5Г6Х6Safeм▀╧ template-haskell.Pretty prints a pattern synonym type signature╨ template-haskell√Pretty prints a pattern synonym's type; follows the usual conventions to print a pattern synonym type compactly, yet unambiguously. See the note on ÷с and the section on pattern synonyms in the GHC user's guide for more information.л≤ ≥ ⌡ ° ² · ÷ ═ ║ ╒ ё є ╔ і ї ╗ ╘ ╙ ╚ ╛ ґ ў ╞ ╟ ╠ ╡ Ё Є ╣ І Ї ╦ ╧ ╨ ╩ ╪ Ґ Ў © ю а б ц д е ф г х и й к л м н о п я р с т у ж в ь з ы ш щ э ч ъ Ю А Ц Б л╒ Ю ≤ є ж с ё ╔ о ш щ э л ╚ ╧ ╨ ╩ ║ ╡ ╘ ╙ ╣ Є ╠ ї Ё Ў ╦ г и к ф й х н м д ° ╛ ў ґ ╪ ╟ б і ц Ґ І а Ї ═ © · ╞ ь з ы А Ц Б т ю ч ъ ╗ е в р ÷ п ⌡ ² я у ≥ Trustworthy/кВыт)template-haskell Use with <*template-haskell Use with XGtemplate-haskellstaticE x = [| static x |]stemplate-haskellPattern synonym declarationttemplate-haskellPattern synonym type signaturevtemplate-haskellЪImplicit parameter binding declaration. Can only be used in let and where clauses which consist entirely of implicit bindings.▒ template-haskellVariant of Z% that attaches Haddock documentation.▓ template-haskellVariant of i% that attaches Haddock documentation.⌠ template-haskell7Document a data/newtype constructor with its arguments.■ template-haskell*Dynamically binding a variable (unhygenic) template-haskellVariant of X% that attaches Haddock documentation.² template-haskellSingle-arg lambda÷ template-haskellVariant of [% that attaches Haddock documentation.═ template-haskellVariant of j% that attaches Haddock documentation.ї template-haskellVariant of s% that attaches Haddock documentation.╛ template-haskellхpure the Module at the place of splicing. Can be used as an input for ю.Є template-haskellдAttaches Haddock documentation to the declaration provided. Unlike ╦О, the names do not need to be in scope when calling this function so it can be used for quoted declarations and anything else currently being spliced. Not all declarations can have documentation attached to them. For those that can't, Є 3 will return it unchanged without any side effects.╣ template-haskellVariant of Є К that applies the same documentation to multiple declarations. Useful for documenting quoted declarations.я template-haskellLevity-polymorphic since template-haskell-2.17.0.0.▒ template-haskellщList of constructors, documentation for the constructor, and documentation for the argumentstemplate-haskell/Documentation to attach to the data declaration▓ template-haskellщList of constructors, documentation for the constructor, and documentation for the argumentstemplate-haskell3Documentation to attach to the instance declaration template-haskell#Documentation to attach to functiontemplate-haskell$Documentation to attach to arguments÷ template-haskellьThe constructor, documentation for the constructor, and documentation for the argumentstemplate-haskell2Documentation to attach to the newtype declaration═ template-haskellьThe constructor, documentation for the constructor, and documentation for the argumentstemplate-haskell3Documentation to attach to the instance declarationї template-haskell.Documentation to attach to the pattern synonymtemplate-haskell0Documentation to attach to the pattern arguments░ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪абцдефгхийяущЮАДЙКЗШЭЩ┼ ▀ ▄ █ ▌ ▐ ░ ▒ ▓ ⌠ ■ ∙ √ ≈ ≤ ≥ ⌡ ° ² · ÷ ═ ║ ╒ ё є ╔ і ї ╗ ╘ ╙ ╚ ╛ ґ ў ╞ ╟ ╠ ╡ Ё Є ╣ І Ї ╦ ╧ ╨ ╩ ╪ Ґ Ў © ю а б ц д е ф г х и й к л м н о п я р с т у ░я ╨ д щб яҐ АЙ╩ уф р ╪ й Ў г ╧ ╦ ц о к м н І Ї т п у а л с и х ю © Де ЮК▌ ╞ є !"#$%&'(STUVW√ ≈ ≥ ≤ PO║ Qі R)*■ +,-./ё ў 01234² 56789:;<=K>▄ CDEF╚ NGHIJLM?@ABYX\Z[]⌡ ^_w`mnoabcdef╗ uijkghlp╘ qrstv╪xхЗШЭЩ─│┌┐└▌▐░▒╒╟ ╔ ≈≤∙╩√⌡▓⌠■≥ ═║▐ ∙ °²·÷yz{|}~° ╒ ╠ ┘├┤╙ Ё ёє╔іцїдий╡ ░ ґ █ · ┼ ╛ґў╞╟╠╗╘╙╚╡ЁЄ╣ІЇ╦╧╨абефг┬┴┼▀█▄▀ ╛ Є ╣ ▒ ÷ ▓ ═ ї ⌠ SafeчOД template-haskellъCreate a Bytes datatype representing raw bytes to be embedded into the program/library binary.Д template-haskellPointer to the datatemplate-haskellOffset from the pointertemplate-haskellNumber of bytes≥ !"#$%&'()*+,-./01234589:;<>?@ABCDEFGHIJLMNOPQRSTUVWXY^_`abcdfkmnoprstuvwxyz{|}~─│┐└┘├┤┬┴┼▀▄█▐░▒▓⌠■∙√≈≤ ⌡°²·÷═║╒ёє╔╗╘╙╚╠╡ЁЄ╣ІЇ╦╧╨╩абцдефгийяущЮАГЖВЬЫХ■И≈∙√≤КЗШЭЩ┼ ▀ ▄ █ ▌ ▐ ░ ▒ ▓ ■ ∙ √ ≈ ≤ ≥ ⌡ ° ² · ÷ ═ ║ ╒ ё є ╔ і ї ╗ ╘ ╙ ╚ ╛ ґ ў ╞ ╟ ╠ ╡ Ё Є ╣ І Ї ╦ ╧ ╨ ╩ ╪ Ґ Ў © ю а б ц д ф г х и й к л м н о п я р с т у ж в ь ы з ш э щ ч ъ Ю А Б Ц Д Е Ф Г Х И Й К Л М Н О П Я Р ≥д яя ╨ Ґ А╩ уф р ╪ й Ў г ╧ ╦ ц о к м н І Ї т п у а щб л с и х ю © ЮК▌ Д ь ╞ є !"#$%&'(PO║ Qі R)*■ +HIJ,-G./ў ё 01234² 5Н Р 89:;<▀ CDEF╚ NLM?@AB▄ √ ≈ ≥ ≤ ч Ц >STUVWЮ ▐░▒≈≤∙╒╩╟ ╔ √▓⌠■К ⌡═°²·÷║ёє╔yz{|}~° ╒ ╠ ┘├┤╙ Ё x▐ ∙ ─│ъ ┐└╡ ░ ґ █ · ┼ М ы И Б цдий╗╘╙╚YXО з Е щ Х■ЗШЭЩИ≈∙√≤ж ⌡ ^ГЖВЬЫ_w╘ Л rpш Х в э Ф kП ╠Г А Я mno╡ЁЄ╣ІЇ╦╧`╨абефгabcdЙ f╗ ust┬┴┼▀▄█v╛ Є ╣ ▒ ÷ ▓ ═ ї Safe-InferredБUТ template-haskellModule over monad operator for ЛС Т Т С SafeБzХ !"#$%&'()*+,-./01234589:;<>?@ABCDEFGHIJLMNOPQRSTUVWXY^_`abcdfkmnoprstuvwxyz{|}~─│┐└┘├┤┬┴┼▀▄█▐░▒▓⌠■∙√≈≤ ⌡°²·÷═║╒ёє╔╗╘╙╚╠╡ЁЄ╣ІЇ╦╧╨╩абцдефгийлм╪ёў·÷╗╦╠╚╙Ї╩╨є╟╛║╔╞╒═ґ╣ЁЄІ╧╘їі╡нНоНпяр▀■░⌠▓┬┴▒▄▐┤├√█┼▌∙сДЕФГХтТУСЯРЖужЩЧЬВ┴▐З┤─▄└▀▌█Ы┐Э│┬├┘┼Ш┌░ЪвЪ▐З└█Ь┌▀┐Ч│┴ШЭ┘▌├Ы┼▄Щ┤┬─ьызшэщчйъЮАБрсЦСЕьФГЫЬЖВХ■И≤√≈∙КЛОПЗШЭЩЗЫЬВЖУТСРЯПОНМЛКЙИХГФЕДЦБАЮъчщэшзыьвжутсряпонмлкйихгфедцбаю©ЎҐ╪╩╨╧╦ЇІ╣ЄЁ╡╠╟╞ўґ╛╚╙╘╗їі╔єё╒║═÷·²°⌡ ≥≤≈√∙■⌠▓▒░▐▌█▄▀┼┴┬┤├┘└┐┌│─ЪЧ▀▄⌠∙≈≥ ⌡°÷║ёєіў╞╟╠╦╨╩╪ҐЎ©юабцдегхмнпярсужвьызшэщчъЮАГКИЛХЙВ░▒▓⌠≥²⌡ °Ґ©ЎюабцдфегихклмнопуртясвжыОНПзшщДБЦАФЮъЕэчГХИЙКЛМРСЪ┘≈≥≤ ⌡·²°÷═СТУёі╙╘╗єї╔хийлкмояпнтЯРувьжышэзщЮъчАЦБИКЛМ ОЯРПТЖУ▒▓■╘ Ё І ╦ о ш э щ ┼ ▀ ▄ █ ▌ ▐ ░ ▒ ▓ ■ ∙ √ ≈ ≤ ≥ ⌡ ° ² · ÷ ═ ║ ╒ ё є ╔ і ї ╗ ╘ ╙ ╚ ╛ ґ ў ╞ ╟ ╠ ╡ Ё Є ╣ І Ї ╦ ╧ ╨ ╩ ╪ Ґ Ў © ю а б ц д ф г х и й к л м н о п я р с т у ж в ь ы з ш э щ ч ъ Ю А Б Ц Д Е Ф Г Х И Й К Л М Н О П Я Р опхлдец╨║ГХИЙКЛМг╩юнопуртясвжРСз┘КЛэ■ЗЫЬВЖУТСРЯПОНМЛКЙИХГФЕДЦБАЮъчщэшзыьвжутсряпонмлкйихгфедцбаю©ЎҐ╪╩╨╧╦ЇІ╣ЄЁ╡╠╟╞ўґ╛╚╙╘╗їі╔єё╒║═÷·²°⌡ ≥≤≈√∙■⌠▓▒░▐▌█▄▀┼┴┬┤├┘└┐┌│─ЪЧ∙ ёєЎб©⌡а╪ужвҐМ ЛОП ≥▀▄°÷эЪў╞╟╠нмсряпвЪ▐З└█Ь┌▀┐Ч│┴ШЭ┘▌├Ы┼▄Щ┤┬─тТУСЯРЖоНщЮъчышэз░▒▓⌠щчИгихГКИЛХЙувьжёі╙╘╗єї╔ыОНПтЯР═СТУБрсьызшчйЦС▒▓абцдфе⌠і⌡·²°≈≥≤ м╪ёў·÷╗╦╠╚╙Ї╩╨є╟╛║╔╞╒═ґ╣ЁЄІ╧╘їі╡нНъЮАклмсДЕФГХхийлкшщДБЦАФЮъЕэчр▀■░⌠▓┬┴▒▄▐┤├√█┼▌∙зшжЩЧЬВ┴▐З┤─▄└▀▌█Ы┐Э│┬├┘┼Ш┌░ЪТЖУОЯРПФВъмояпнАЦБҐ©ЎюЕь÷ьы╦≈≥²⌡ °ш э щ о ╘ Ё ╦ І └ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▄█▐▄█░▄█▒▄█▓▄█⌠▄█■▄█∙▄█√▄█≈▄█≤▄█≥▄█ ▄█⌡▄█°▄█²▄█·▄█÷▄█═▄█║▄█╒▄█ё▄█є▄█╔▄█і▄█ї▄█╗▄█╘▄█╙▄█╚▄█╛▄█ґ▄█ў▄█╞▄█╟▄█╠▄█╡▄█Ё▄█Є▄█╣▄█І▄█Ї▄█╦▄█╧▄█╨▄█╩▄█╪▄█Ґ▄█Ў▄█©▄█ю▄█а▄█б▄█ц▄█д▄█е▄█ф▄█г▄█х▄█и▄█й▄█к▄█л▄█м▄█н▄█о▄█п▄█я▄█р▄█с▄█т▄█у▄█ж▄█в▄█ь▄█ы▄█з▄█ш▄█э▄█щ▄█ч▄█ъ▄█Ю▄█А▄█Б▄█Ц▄█Д▄█Е▄█Ф▄█Г▄█Х▄█И▄█Й▄█К▄█Л▄█М▄█Н▄█О▄█П▄█Я▄█Р▄█С▄█Т▄█У▄█Ж▄█В▄█Ь▄█Ы▄█З▄█Ш▄█Э▄█Щ▄█Ч▄█Ъ▄█─▄█│▄█┌▄█┐▄█└▄█┘▄█├▄█┤▄█┬▄█┴▄█┼▄▀▄▄▀█▄▀▌▄▀▐▄▀░▄▀▒▄▀▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМННОПЯРРСТУЖВЬЫЗШЭщЗЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═Ж║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклммнопярстЛужвьызшэщчъЮАСЩБЦДЕФГХИЙКЛМНООПЯРСТэШУУЖЖЙВЬЫЗШЭЩЧЪ─│┌┐└┘┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒╒ёє╔ії╗╘╙ч╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийкРлмнопярстужвьызшэщчъЮАБЦДЕФёГХИЙЙКЛМНЯОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─ │ ┌ ┐ └ ┘ ├ ┤ ┬ ┴ ┼ ▀ ▄ █ ▌ ▐ ░ ▒ ▓ ⌠ ■ ∙ √ ≈ ≤ ≥ ⌡ ° ² · ÷ ═ ║ ╒ ё є ╔ і ї ╗ ╘ ╙ ╚ ╛ ґ ў ╞ ╟ ╠ ╡ Ё Є ╣ І Ї ╦ ╧ ╨ ╩ ╪ Ґ Ў © ю а б ц д е ф г х и й к л м н о п я р с т у ж в ь ы з ш э щ ч ъ Ю А Б Ц Д Е Ф Г Х И Й К Л М Н О П Я Р С Т У Ж В Ь Ы З Ш Э Щ Ч Ъ ─ │ ┌ ┐ └ ┘ ├ ┤ ┬ ┴ ┼ ▀ ▄ █ ▌ ▐ ░ ▒ ▓ ⌠ ■ ∙ √ ≈ ≤ ≥ ⌡ ° ² · ÷ ═ ║ ╒ ё є ╔ і ї ╗ ╘ ╙ ╚ ╛ ґ ў ╞ ╟ ╠ ╡ Ё Є ╣ І Ї ╦ ╧ ╨ С╩ ╪ Ґ Ў © ю а б ц д е ф г х и й kz,╩huwжK░°Ґ╣Yк ix╪vЄsї╨DjйЎEл м Л н о п я р с я т у я ж в я р ь я ы з ш э щ я р ч ш ъ Ю я А Б я Ц Д ш Е Ф Г 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.CodeDoLanguage.Haskell.TH.Lib.Mapdyn thisModule pprPatSynTypeLanguage.Haskell.TH sequenceQliftnewNamemkName mkNameG_v mkNameG_d mkNameG_tcmkNameLmkNameSunType unTypeCode liftTyped mkModNameunsafeCodeCoercecharLstringLintegerLintPrimL wordPrimL floatPrimLdoublePrimL rationalLstringPrimL charPrimL liftStringlitPvarPtupPunboxedTupPunboxedSumPconPinfixPtildePbangPasPwildPrecPlistPsigPviewPfieldPatmatchclausevarEconElitEappEappTypeEinfixEinfixAppsectionLsectionRlamElamCaseEtupEunboxedTupEunboxedSumEcondEmultiIfEletEcaseEdoEcompEfromE fromThenEfromToEfromThenToElistEsigErecConErecUpdEstaticEunboundVarElabelEimplicitParamVarEmdoE getFieldEprojectionEfieldExpguardedBnormalBnormalGEpatGEbindSletSnoBindSparSrecSfunDvalDdataDnewtypeDtySynDclassDinstanceWithOverlapDsigDforImpDpragInlD pragSpecDpragSpecInlD pragSpecInstD pragRuleDpragAnnDdataFamilyDopenTypeFamilyD dataInstDnewtypeInstD tySynInstDclosedTypeFamilyDinfixLDinfixRDinfixND roleAnnotDstandaloneDerivWithStrategyDdefaultSigDpatSynD patSynSigD pragCompleteDimplicitParamBindDkiSigDcxtnoSourceUnpackednesssourceNoUnpacksourceUnpacknoSourceStrictness sourceLazysourceStrictnormalCrecCinfixCforallCgadtCrecGadtCbangbangTypevarBangTypeunidir implBidir explBidirprefixPatSyninfixPatSynrecordPatSynforallT forallVisTvarTconTtupleT unboxedTupleTunboxedSumTarrowTlistTappTappKindTsigT equalityTlitT promotedTpromotedTupleTpromotedNilT promotedConsT wildCardTimplicitParamTinfixTnumTyLitstrTyLit charTyLitplainTVkindedTVnominalRrepresentationalRphantomRinferRstarKconstraintKnoSigkindSigtyVarSiginjectivityAnncCallstdCallcApiprim javaScriptunsafesafe interruptiblefunDep mulArrowTtySynEqnquoteExpquotePatquoteDec quoteTyperuleVartypedRuleVarplainInvisTV kindedInvisTVvalueAnnotationtypeAnnotationmoduleAnnotationderivClause specifiedSpecinferredSpecLiftQuoteExpMatchClauseQExpQPatStmtConTypeQTypeDecBangTypeVarBangTypeFieldExpFieldPatNamePatQFunDepPred TyVarBndrUnitDecsQRuleBndrTySynEqnRoleInjectivityAnnKindOverlapDerivClause DerivStrategyDecs TyVarBndrSpecCodeModNameNoInlineInline InlinableConLikeFunLike AllPhases FromPhaseBeforePhaseOverlappableOverlappingOverlaps Incoherent stockStrategyanyclassStrategynewtypeStrategyviaStrategyghc-boot-th-9.2.1GHC.LanguageExtensions.TypeViewPatternsUnliftedNewtypesUnliftedFFITypesUnliftedDatatypes UnicodeSyntaxUndecidableSuperClassesUndecidableInstances UnboxedTuplesUnboxedSumsTypeSynonymInstances TypeOperators TypeInTypeTypeFamilyDependenciesTypeFamiliesTypeApplications TupleSectionsTransformListCompTraditionalRecordSyntaxTemplateHaskellQuotesTemplateHaskell StrictDataStrictStaticPointers StarIsTypeStandaloneKindSignaturesStandaloneDerivingScopedTypeVariablesRoleAnnotationsRelaxedPolyRec RelaxedLayoutRecursiveDoRecordWildCards RecordPunsRebindableSyntax RankNTypesQuasiQuotesQuantifiedConstraintsQualifiedDoPostfixOperators PolyKindsPatternSynonyms PatternGuardsPartialTypeSignaturesParallelListCompParallelArraysPackageImportsOverloadedStringsOverloadedRecordUpdateOverloadedRecordDotOverloadedListsOverloadedLabelsOverlappingInstancesNumericUnderscoresNumDecimalsNullaryTypeClassesNondecreasingIndentationNegativeLiteralsNamedWildCardsNPlusKPatterns MultiWayIfMultiParamTypeClassesMonomorphismRestrictionMonoLocalBindsMonadComprehensions MagicHashLinearTypesLiberalTypeSynonymsLexicalNegation LambdaCaseKindSignatures JavaScriptFFIInterruptibleFFIInstanceSigsIncoherentInstancesImpredicativeTypesImportQualifiedPostImplicitPreludeImplicitParamsHexFloatLiteralsGeneralizedNewtypeDerivingGHCForeignImportPrimGADTs GADTSyntaxFunctionalDependenciesForeignFunctionInterfaceFlexibleInstancesFlexibleContextsFieldSelectorsExtendedDefaultRulesExplicitNamespacesExplicitForAllExistentialQuantificationEmptyDataDerivingEmptyDataDecls EmptyCaseDuplicateRecordFieldsDoAndIfThenElseDisambiguateRecordFieldsDerivingViaDerivingStrategiesDeriveTraversable DeriveLift DeriveGeneric DeriveFunctorDeriveFoldableDeriveDataTypeableDeriveAnyClassDefaultSignaturesDatatypeContexts DataKindsCppConstraintKindsConstrainedClassMethodsCUSKsCApiFFIBlockArgumentsBinaryLiteralsBangPatternsAutoDeriveTypeableArrows ApplicativeDo!AlternativeLayoutRuleTransitionalAlternativeLayoutRuleAllowAmbiguousTypes ExtensionGHC.ForeignSrcLang.Type RawObject LangObjcxxLangObjcLangCxxLangCLangAsmForeignSrcLang addCorePluginaddDependentFileaddForeignFileaddForeignFilePathaddForeignSourceaddModFinalizeraddTempFileaddTopDeclsbadIObindCode bindCode_cmpEqcompareBytescounter dataToExpQ dataToPatQdataToQa defaultFixityeqBytesextsEnabled falseNamegetDocgetQ hoistCodeisExtEnabled isInstancejoinCodejustNameleftNameliftCodeliftDatalocation lookupNamelookupTypeNamelookupValueNamemanyName maxPrecedencememcmpmkNameGmkNameU mkOccName mkPkgNamemk_tup_name modStringnameBase nameModulenamePackage nameSpace newNameIOnonemptyNamenothingName occStringoneName pkgStringputDocputQrecoverreifyreifyAnnotationsreifyConStrictnessreifyFixityreifyInstancesreifyModule reifyRoles reifyTypereportreportError reportWarning rightNamerunIOrunQshowName showName'thenCmptrueName tupleDataName tupleTypeNameunTypeQunboxedSumDataNameunboxedSumTypeNameunboxedTupleDataNameunboxedTupleTypeNameunsafeTExpCoerce AnnLookupAnnLookupModule AnnLookupName AnnTargetModuleAnnotationTypeAnnotationValueAnnotationArityBangBodyGuardedBNormalBBytesbytesOffsetbytesPtr bytesSizeCallconvCApiCCall JavaScriptPrimStdCallCharPosexamineCodeForallCGadtCInfixCNormalCRecCRecGadtCCxtClassDClosedTypeFamilyDDataDDataFamilyD DataInstDDefaultSigDForeignDFunDImplicitParamBindDInfixD InstanceDKiSigDNewtypeDNewtypeInstDOpenTypeFamilyDPatSynD PatSynSigDPragmaD RoleAnnotDSigDStandaloneDerivDTySynD TySynInstDValDDecidedStrictnessDecidedLazy DecidedStrict DecidedUnpackAnyclassStrategyNewtypeStrategy StockStrategyViaStrategyDocLocArgDocDeclDocInstDoc ModuleDocAppEAppTypeE ArithSeqECaseECompEConECondEDoE GetFieldEImplicitParamVarEInfixELabelELamCaseELamELetEListELitEMDoEMultiIfEParensEProjectionERecConERecUpdESigEStaticETupEUInfixEUnboundVarEUnboxedSumEUnboxedTupEVarEFamilyResultSigKindSigNoSigTyVarSigFixityFixityDirectionInfixLInfixNInfixRForeignExportFImportFGuardNormalGPatGInfoClassIClassOpIDataConIFamilyIPatSynI PrimTyConITyConITyVarIVarIInstanceDecLit BytesPrimLCharL CharPrimLDoublePrimL FloatPrimLIntPrimLIntegerL RationalLStringLStringPrimL WordPrimLLocloc_endloc_filename loc_moduleloc_package loc_startModule ModuleInfoNameFlavourNameGNameLNameQNameSNameUNameIsAloneAppliedInfix NameSpaceDataName TcClsNameVarNameOccName ParentNameAsPBangPConPInfixPListPLitPParensPRecPSigPTildePTupPUInfixPUnboxedSumPUnboxedTupPVarPViewPWildP PatSynArgsInfixPatSynPrefixPatSynRecordPatSyn PatSynDir ExplBidir ImplBidirUnidir PatSynTypePhasesPkgNamePragmaAnnP CompletePInlinePLinePRulePSpecialiseInstPSpecialisePunQQuasiqAddCorePluginqAddDependentFileqAddForeignFilePathqAddModFinalizerqAddTempFileqAddTopDeclsqExtsEnabledqGetDocqGetQ qIsExtEnabled qLocationqLookupNameqNewNameqPutDocqPutQqRecoverqReifyqReifyAnnotationsqReifyConStrictnessqReifyFixityqReifyInstancesqReifyModuleqReifyRoles qReifyTypeqReportqRunIORangeFromR FromThenRFromThenToRFromToRInferRNominalRPhantomRRepresentationalRRuleVarTypedRuleVar RuleMatchSafety InterruptibleSafeUnsafeSourceStrictnessNoSourceStrictness SourceLazySourceStrictSourceUnpackednessNoSourceUnpackednessSourceNoUnpackSourceUnpackSpecificityInferredSpec SpecifiedSpecBindSLetSNoBindSParSRecS StrictTypeSumAltSumArityTExpTyLit CharTyLitNumTyLitStrTyLit TyVarBndrKindedTVPlainTVAppKindTAppTArrowTConTConstraintT EqualityTForallT ForallVisTImplicitParamTInfixTListTLitT MulArrowTParensT PromotedConsTPromotedNilT PromotedTPromotedTupleTSigTStarTTupleTUInfixTUnboxedSumT UnboxedTupleTVarT WildCardTTypeFamilyHeadUniqUnlifted VarStrictType$fApplicativeQ $fFunctorQ$fDataAnnLookup$fDataModule $fDataName$fDataAnnTarget $fDataBang$fDataSourceUnpackedness$fDataSourceStrictness $fDataBody$fDataGuard $fDataExp$fDataBytes$fDataCallconv$fDataClause $fDataPat $fDataDec $fDataCon$fDataDecidedStrictness$fDataDerivClause$fDataDerivStrategy $fDataType$fDataDocLoc$fDataFamilyResultSig$fDataFixity$fDataFixityDirection $fDataForeign$fDataSafety$fDataFunDep $fDataStmt $fDataInfo$fDataInjectivityAnn$fDataInline $fDataLit $fDataLoc$fDataMatch $fDataModName $fDataPkgName$fDataModuleInfo $fDataOccName$fDataNameFlavour$fDataNameSpace $fDataOverlap$fDataPatSynArgs$fDataPatSynDir$fDataPhases$fDataPragma$fDataRange $fDataRole$fDataRuleBndr$fDataRuleMatch$fDataSpecificity$fDataTyLit$fDataTySynEqn$fDataTyVarBndr$fDataTypeFamilyHead $fEqAnnLookup $fEqAnnTarget$fEqBang$fEqBody $fEqGuard$fEqExp $fEqBytes$fEqCallconv $fEqClause$fEqCon$fEqDec$fEqDecidedStrictness$fEqDerivClause$fEqDerivStrategy $fEqDocLoc$fEqFamilyResultSig $fEqFixity$fEqFixityDirection$fEqForeign $fEqFunDep$fEqName$fEqStmt$fEqInfo$fEqInjectivityAnn $fEqInline$fEqLit$fEqLoc $fEqMatch$fEqModName $fEqModule$fEqModuleInfo$fEqNameFlavour $fEqNameSpace$fEqOccName$fEqOverlap$fEqPat$fEqPatSynArgs $fEqPatSynDir $fEqPhases$fEqPkgName $fEqPragma $fEqRange$fEqRole$fEqRuleBndr $fEqRuleMatch $fEqSafety$fEqSourceStrictness$fEqSourceUnpackedness$fEqSpecificity $fEqTyLit$fEqTySynEqn $fEqTyVarBndr$fEqType$fEqTypeFamilyHead$fFunctorTyVarBndr$fGenericAnnLookup$fGenericAnnTarget $fGenericBang $fGenericBody$fGenericBytes$fGenericCallconv$fGenericClause$fGenericCon$fGenericDec$fGenericDecidedStrictness$fGenericDerivClause$fGenericDerivStrategy$fGenericDocLoc$fGenericExp$fGenericFamilyResultSig$fGenericFixity$fGenericFixityDirection$fGenericForeign$fGenericFunDep$fGenericGuard $fGenericInfo$fGenericInjectivityAnn$fGenericInline$fGenericLit$fGenericLoc$fGenericMatch$fGenericModName$fGenericModule$fGenericModuleInfo $fGenericName$fGenericNameFlavour$fGenericNameSpace$fGenericOccName$fGenericOverlap$fGenericPat$fGenericPatSynArgs$fGenericPatSynDir$fGenericPhases$fGenericPkgName$fGenericPragma$fGenericRange $fGenericRole$fGenericRuleBndr$fGenericRuleMatch$fGenericSafety$fGenericSourceStrictness$fGenericSourceUnpackedness$fGenericSpecificity $fGenericStmt$fGenericTyLit$fGenericTySynEqn$fGenericTyVarBndr $fGenericType$fGenericTypeFamilyHead$fLiftAddrRepAddr#$fLiftBoxedRep()$fLiftBoxedRep(,)$fLiftBoxedRep(,,)$fLiftBoxedRep(,,,)$fLiftBoxedRep(,,,,)$fLiftBoxedRep(,,,,,)$fLiftBoxedRep(,,,,,,)$fLiftBoxedRepBool$fLiftBoxedRepChar$fLiftBoxedRepDouble$fLiftBoxedRepEither$fLiftBoxedRepFloat$fLiftBoxedRepInt$fLiftBoxedRepInt16$fLiftBoxedRepInt32$fLiftBoxedRepInt64$fLiftBoxedRepInt8$fLiftBoxedRepInteger$fLiftBoxedRepMaybe$fLiftBoxedRepNatural$fLiftBoxedRepNonEmpty$fLiftBoxedRepRatio$fLiftBoxedRepVoid$fLiftBoxedRepWord$fLiftBoxedRepWord16$fLiftBoxedRepWord32$fLiftBoxedRepWord64$fLiftBoxedRepWord8$fLiftBoxedRep[]$fLiftDoubleRepDouble#$fLiftFloatRepFloat#$fLiftIntRepInt#$fLiftSumRep(#|#)$fLiftSumRep(#||#)$fLiftSumRep(#|||#)$fLiftSumRep(#||||#)$fLiftSumRep(#|||||#)$fLiftSumRep(#||||||#)$fLiftTupleRep(##)$fLiftTupleRep(#,#)$fLiftTupleRep(#,,#)$fLiftTupleRep(#,,,#)$fLiftTupleRep(#,,,,#)$fLiftTupleRep(#,,,,,#)$fLiftTupleRep(#,,,,,,#)$fLiftTupleRepSolo#$fLiftWordRepChar#$fLiftWordRepWord#$fMonadFailQ$fMonadQ$fMonadFixQ $fMonadIOQ $fMonoidQ$fSemigroupQ$fOrdAnnLookup$fOrdAnnTarget $fOrdBang $fOrdBody $fOrdGuard$fOrdExp $fOrdBytes $fOrdCallconv$fOrdClause$fOrdCon$fOrdDec$fOrdDecidedStrictness$fOrdDerivClause$fOrdDerivStrategy$fOrdDocLoc$fOrdFamilyResultSig$fOrdFixity$fOrdFixityDirection$fOrdForeign$fOrdFunDep $fOrdName $fOrdStmt $fOrdInfo$fOrdInjectivityAnn$fOrdInline$fOrdLit$fOrdLoc $fOrdMatch$fOrdModName$fOrdModule$fOrdModuleInfo$fOrdNameFlavour$fOrdNameSpace$fOrdOccName$fOrdOverlap$fOrdPat$fOrdPatSynArgs$fOrdPatSynDir$fOrdPhases$fOrdPkgName$fOrdPragma $fOrdRange $fOrdRole $fOrdRuleBndr$fOrdRuleMatch$fOrdSafety$fOrdSourceStrictness$fOrdSourceUnpackedness$fOrdSpecificity $fOrdTyLit $fOrdTySynEqn$fOrdTyVarBndr $fOrdType$fOrdTypeFamilyHead $fQuasiIO$fQuasiQ $fQuoteIO$fQuoteQ$fShowAnnLookup$fShowAnnTarget $fShowBang $fShowBody$fShowBytes$fShowCallconv$fShowClause $fShowCon $fShowDec$fShowDecidedStrictness$fShowDerivClause$fShowDerivStrategy$fShowDocLoc $fShowExp$fShowFamilyResultSig$fShowFixity$fShowFixityDirection $fShowForeign$fShowFunDep$fShowGuard $fShowInfo$fShowInjectivityAnn$fShowInline $fShowLit $fShowLoc$fShowMatch $fShowModName$fShowModule$fShowModuleInfo $fShowName$fShowNameFlavour$fShowNameSpace $fShowOccName $fShowOverlap $fShowPat$fShowPatSynArgs$fShowPatSynDir$fShowPhases $fShowPkgName$fShowPragma$fShowRange $fShowRole$fShowRuleBndr$fShowRuleMatch$fShowSafety$fShowSourceStrictness$fShowSourceUnpackedness$fShowSpecificity $fShowStmt$fShowTyLit$fShowTySynEqn$fShowTyVarBndr $fShowType$fShowTypeFamilyHead quoteFileQuasiQuoter$$$+$<+><>arrowbracesbracketscatcharcoloncommadcolondoubledoubleQuotesemptyequalsfcatfloatfsephanghcathsepintintegerisEmptylbracelbracklparennestparenspprNamepprName'ptext punctuatequotesrationalrbracerbrackrparensemisepspacetext to_HPJ_DocvcatDocPprM$fApplicativePprM $fFunctorPprM$fMonadPprM $fShowPprMappPrecbar bytesToStringcommaSepcommaSepAppliedcommaSepWithfromTANormal hashParensisStarTisSymOcc nestDepthnoPrecopPrecparensIfpprBangTypepprBodypprCxtpprExp pprFields pprFixity pprForall pprForall'pprForallVis pprFunArgType pprGadtRHS pprGuardedpprInfixExppprLitpprMatchPatpprMaybeExp pprParendTypepprParendTypeArgpprPatpprPatSynSigpprPrefixOccpprRecFields pprStrictType pprStringpprTyApppprTyLit pprUInfixTpprVarBangTypepprVarStrictType ppr_bndrs ppr_cxt_predsppr_datappr_decppr_deriv_clauseppr_deriv_strategyppr_newtypeppr_overlapppr_sigppr_tf_head ppr_tySynpprintquoteParenssemiSep showtextlsigPrecsplitunboxedSumBarsunopPrecwhere_clause ForallVisFlagForallInvis ForallVisPprpprppr_listPprFlagpprTyVarBndr PrecedenceTypeArgTANormalTyArg $fPprBang$fPprClause$fPprCon$fPprDec$fPprDecidedStrictness$fPprExp$fPprFamilyResultSig$fPprFlag()$fPprFlagSpecificity$fPprForeign$fPprFunDep $fPprInfo$fPprInjectivityAnn$fPprInline$fPprLit$fPprLoc $fPprMatch$fPprModule$fPprModuleInfo $fPprName$fPprPat$fPprPatSynArgs$fPprPatSynDir$fPprPhases$fPprPragma $fPprRange $fPprRole $fPprRuleBndr$fPprRuleMatch$fPprSourceStrictness$fPprSourceUnpackedness $fPprStmt $fPprTyLit$fPprTyVarBndr $fPprType$fPprTypeArg$fPpr[]$fShowForallVisFlagappKappsE arithSeqEarrowK bytesPrimLclassPconK dataD_doc dataInstD_docdocConsequalPfromR fromThenRfromThenToRfromToRfunD_doc instanceDisStrictlam1ElistKnewtypeD_docnewtypeInstD_docnormalG notStrictparensEparensPparensTpatGpatSynD_doc pragLineDstandaloneDerivD strictTypestringEtupleKuInfixEuInfixPuInfixTunpackedvarK varStrictType withDecDocwithDecsDocBangQ BangTypeQBodyQClauseQCodeQConQCxtQDecQDerivClauseQDerivStrategyQFamilyResultSigQ FieldExpQ FieldPatQGuardQInfoQKindQMatchQPatSynArgsQ PatSynDirQPredQRangeQ RuleBndrQSourceStrictnessQSourceUnpackednessQStmtQStrictTypeQTExpQTyLitQ TySynEqnQVarBangTypeQVarStrictTypeQmkBytes>>>>=insertlookupMapbase GHC.MaybeJustGHC.BaseString Data.DataDataNothingControl.Monad.Failfailghc-primGHC.ClassesEqMaybeGHC.PrimAddr#Control.Monad.FixmfixGHC.IO.ExceptionFixIOException GHC.TypesTrue