h-!ppx      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~3.5NoneThis class (which users should never see) is to be instantiated in order to use an otherwise-unused data constructor, such as the "kind-inference" data constructor for defunctionalization symbols.None A local variable that is captured in a lambda-lifted type family. (See Note [Tracking local variables] in  Data.Singletons.TH.Promote.Monad5 for an explanation of how lambda lifting works.) A  consists of:An  ::  that corresponds to the promoted, type-level version of a term-level variable name. An optional  ::  . When the kind of a local variable is known, we can use it to generate code with more precise kind information. See +Note [Local variables and kind information].&We maintain the invariant that if two  values share the same &, then they should both have the same  value.A  is very close in design to a , as both contain s and optional s. We use a separate , type to represent local variables because s can occur both in binding and argument positions in generated code (see Note [Local variables and kind information] (Wrinkle: Binding positions versus argument positions)), and using 5s to represent type arguments feels somewhat awkward.Apply a  to a list of  arguments. Because these s occur in argument positions, they will not contain any kind information. See Note [Local variables and kind information] (Wrinkle: Binding positions versus argument positions). Convert a ! used in a binding position to a  using the supplied flag. Because this is used in a binding position, we include kind information (if available) in the . See Note [Local variables and kind information] (Wrinkle: Binding positions versus argument positions). Convert a # used in an argument position to a . Because this is used in an argument positions, it will not kind any kind information. See Note [Local variables and kind information] (Wrinkle: Binding positions versus argument positions). Convert a # used in an argument position to a . Because this is used in an argument positions, it will not kind any kind information. See Note [Local variables and kind information] (Wrinkle: Binding positions versus argument positions). Convert a  to a . / /* *&&&&None 3;'If annotated, this maps let-bound term "s to their promoted counterparts.A let-bound, term-level name that is promoted to the type level. The first element of the pair (of type ) is the promoted counterpart to the term-level name, and the second element of the pair (of type [Name]) is the list of local variables that this definition closes over after being lambda-lifted. (See Note [Tracking local variables] in  Data.Singletons.TH.Promote.Monad.)Note that the promoted Name in the first element of the pair is not' a defunctionalization symbol, unlike LetBind in  Data.Singletons.TH.Promote.Monad. This is because it is sometimes convenient to fully apply the promoted name to all of its arguments (e.g., when singling type signatures), in which case we can avoid needing to involve defunctionalization symbols at all.Pairs of term-level variable 8s and their corresponding type-level names (encoded as s).The number of arguments in each clause. Although this can be computed from the list of ADClauses, this information is used multiple times during promotion and singling, so we cache this number here as a convenience.The promoted lambda.The list of clauses in the \cases expression. - - ) )!     NonegGenerate a new Uniqueis a valid Haskell infix data constructor (i.e., does it begin with a colon?)Is an identifier a legal data constructor name in Haskell? That is, is its first character an uppercase letter (prefix) or a colon (infix)?Is an identifier uppercase?"Note that this will always return  for infix names, since the concept of upper- and lower-case doesn't make sense for non-alphabetic characters. If you want to check if a name is legal as a data constructor, use the  function.Convert a list of s to a list of "es. Type variable binders with a  are converted to %, and type variable binders with an  are dropped entirely.(As an example, if you have this list of s: forall a {b} c {d e} f.  ... The corresponding list of  es would be:  @a @b @f Note that note of b, d, or e appear in the list. See also , which takes a list of  # as arguments instead of a list of s. Note that  .  is not the same thing as . This is because  only produces  binders as output, whereas  can produce both  and  binders.Call  first to ensure we have a # in the type namespace, then call .  " $) +5  *    "' )0   ! #( *; = NonenReturn a fresh alphanumeric !. In particular, if the supplied 0 is symbolic (e.g., (%%)), then return a fresh  with the  ty. Otherwise, return a fresh  with the same  as the supplied . See Note [Tracking local variables] in  Data.Singletons.TH.Promote.Monad for why we do this.If a . begins with one or more underscores, return  (us, rest), where us9 contain all of the underscores at the beginning of the  and rest contains the remainder of the . Otherwise, return .(C) 2019 Ryan ScottBSD-style (see LICENSE) Ryan Scott experimental non-portableNone#A convenient implementation of the  class. Use by calling .)Class that describes monads that contain ..Options that control the finer details of how  singletons-th%'s Template Haskell machinery works.Given the original name and the number of parameters it is applied to (the  argument), produces a type-level function name that can be partially applied when given the same number of parameters.Note that defunctionalization works over both term-level names (producing symbols for the promoted name) and type-level names (producing symbols directly for the name itself). As a result, this callback is used for names in both the term and type namespaces.Given the name of the original, unrefined value, produces the name of the singled equivalent of the value.Given the name of the original, unrefined data constructor, produces the name of the corresponding singleton data constructor.Given the name of the original, unrefined class, produces the name of the singled equivalent of the class.Given the name of the original, unrefined data type, produces the name of the corresponding singleton type.Given the name of the original, unrefined value, produces the name of the promoted equivalent of the value. This is used for both top-level and let6-bound names, and the difference is encoded in the  = argument. If promoting a top-level name, the argument is . If promoting a let -bound name, the argument is  Just uniq, where uniq is a globally unique number that can be used to distinguish the name from other local definitions of the same name (e.g., if two functions both use let x = ... in x).Given the name of the original, unrefined class, produces the name of the promoted equivalent of the class.Given the name of the original data type or data constructor, produces the name of the promoted equivalent. Unlike the singling-related options, in which there are separate  and  functions, we combine the handling of promoted data types and data constructors into a single option. This is because the names of promoted data types and data constructors can be difficult to distinguish in certain contexts without expensive compile-time checks.Because of the  DataKinds extension, most data type and data constructor names can be used in promoted contexts without any changes. As a result, this option will act like the identity function 99% of the time. There are some situations where it can be useful to override this option, however, as it can be used to promote primitive data types that do not have proper type-level equivalents, such as Natural and Text. See the "Arrows, Nat, Symbol, and literals" section of the  singletons  >https://github.com/goldfirere/singletons/blob/master/README.mdREADME for more details.If , then SingKind! instances will be generated. If , they will be omitted entirely. This can be useful in scenarios where TH-generated SingKind instances do not typecheck (for instance, when generating singletons for GADTs).If , then quoted declarations will be generated alongside their promoted and singled counterparts. If 0, then quoted declarations will be discarded.Sensible default . defaults to . That is, quoted declarations are generated alongside their promoted and singled counterparts. defaults to  . That is, SingKind instances are generated.The default behaviors for , promotedValueNamePrefix, , , , , and 1 are described in the "On names" section of the  singletons  >https://github.com/goldfirere/singletons/blob/master/README.mdREADME.Given the name of the original, unrefined, top-level value, produces the name of the promoted equivalent of the value.+Given the name of the original, unrefined, let-bound value and its globally unique number, produces the name of the promoted equivalent of the value.Given the original name of a function (term- or type-level), produces a type-level function name that can be partially applied even without being given any arguments (i.e., 0 arguments). Declare the " that a TH computation should use. Turn any  into an .      5  6    0    0  " $) +5   % '. 07NoneNonev Options for controlling how types are promoted at a fine granularity.If , allow promoting wildcard types. Otherwise, throw an error. In most places, GHC disallows kind-level wildcard types, so rather than promoting such wildcards and getting an error message from GHC  post facto, we can catch such wildcards early and give a more descriptive error message instead.If  , invoke - on the argument type being promoted. See 6Note [Vanilla-type validity checking during promotion]. Promote a  to the kind level and invoke . See 6Note [Vanilla-type validity checking during promotion]. Promote a  to the kind level. This is suffixed with "_NC" because we do not invoke  here. See 6Note [Vanilla-type validity checking during promotion]. The default : is not invoked.:Throw an error when attempting to promote a wildcard type. Promote a / to the kind level. This is the workhorse for  and .Promote a DTypeArg to the kind level. This is suffixed with "_NC" because we do not invoke checkVanillaDType here. See 6Note [Vanilla-type validity checking during promotion].Promote a DType to the kind level, splitting it into its type variable binders, argument types, and result type in the process. ,,(C) 2023 Ryan ScottBSD-style (see LICENSE) Ryan Scott experimental non-portableNone'The name of the data typeNoneBring a list of =s into scope for the duration the supplied computation. See Note [Tracking local variables].Map from term-level s of local variables to their type-level counterparts. Note that scoped type variables are stored separately in  pr_scoped_tvs. See Note [Tracking local variables].Map from term-level s of variables bound in lambdas and function clauses to their type-level counterparts. See Note [Tracking local variables].:The set of scoped type variables currently in scope. See Note [Scoped type variables].Bring a set of type variables into scope for the duration the supplied computation. See Note [Tracking local variables] and Note [Scoped type variables].Bring a list of < into scope for the duration the supplied computation. See Note [Tracking local variables]."A pair consisting of a term-level  of a variable, bound in a let binding or where clause, and its type-level counterpart. The type will always be a defunctionalization symbol so that it can be partially applied if necessary. See Note [Tracking local variables].Map a term-level  to its type-level counterpart. This function is aware of any local variables that are currently in scope. See Note [Tracking local variables].   = =9999"9$9)9+90:::!:3;;;; NoneNMap from term-level 9s of local variables to their singled counterparts. See Note [Tracking local variables] in  Data.Singletons.TH.Promote.Monad.Bring a list of let-bound names into scope for the duration the supplied computation, where the first element of each pair is the original, term-level name, and the second element of each pair is the singled counterpart. See Note [Tracking local variables] in  Data.Singletons.TH.Promote.Monad.Map a term-level  to its singled counterpart. This function is aware of any local variables that are currently in scope. See Note [Tracking local variables] in  Data.Singletons.TH.Promote.Monad.7Map a data constructor name to its singled counterpart.Bring a list of lambda-bound names into scope for the duration the supplied computation, where the first element of each pair is the original, term-level name, and the second element of each pair is the singled counterpart. See Note [Tracking local variables] in  Data.Singletons.TH.Promote.Monad.  ? ?< <8888"8$8)999!93:::: :":'NoneNone(C) 2018 Ryan ScottBSD-style (see LICENSE) Ryan Scott experimental non-portableNoneNone8The standalone kind signature for the original data type3The user-written binders for the original data type*The original data type, promoted to a kind7The standalone kind signature for the singled data type(C) 2018 Ryan ScottBSD-style (see LICENSE) Ryan Scott experimental non-portableNoneS Forall type.Type app, variable other than in last argument(Type app, variable only in last argumentThe variable itselfDoes not contain variableDetect if a Name occurs as an argument to some type family. This makes an effort to exclude  oversaturated arguments to type families. For instance, if one declared the following type family:  type family F a :: Type -> Type Then in the type F a b, we would consider a to be an argument to F , but not b.Variable to look for How to foldType to process(C) 2015 Richard EisenbergBSD-style (see LICENSE) Ryan Scott experimental non-portableNoneNoneThe original2 constructors (for inferring the instance context)The  singletons constructorsThe name of the data typeThe name of the data typeThe original2 constructors (for inferring the instance context)(C) 2018 Ryan ScottBSD-style (see LICENSE) Ryan Scott experimental non-portableNone(C) 2017 Ryan ScottBSD-style (see LICENSE) Ryan Scott experimental non-portableNone=Parenthesize an infix constructor name if it is being applied as a prefix function (e.g., data Amp a = (:&) a a)Turn a context like ( a,  b) into (ShowSing a, ShowSing b),. This is necessary for standalone-derived  instances for singleton types.(C) 2015 Richard EisenbergBSD-style (see LICENSE) Ryan Scott experimental non-portableNone/#Make a *non-singleton* Ord instance (C) 2018 Ryan ScottBSD-style (see LICENSE) Ryan Scott experimental non-portableNone!(C) 2018 Ryan ScottBSD-style (see LICENSE) Ryan Scott experimental non-portableNone"(C) 2020 Ryan ScottBSD-style (see LICENSE) Ryan Scott experimental non-portableNone#(C) 2015 Richard EisenbergBSD-style (see LICENSE) Ryan Scott experimental non-portableNone$(C) 2015 Richard EisenbergBSD-style (see LICENSE) Ryan Scott experimental non-portableNone%(C) 2015 Richard EisenbergBSD-style (see LICENSE) Ryan Scott experimental non-portableNone Split up a [DDec] into its pieces, extracting ! instances from deriving clauses"The deriving strategy, if present.The class being derived (e.g., :), possibly applied to some number of arguments (e.g.,  C Int Bool). ctx if ctx was provided via StandaloneDeriving.  if using a deriving clause.$The data type argument to the class.https://github.com/goldfirere/singletons/blob/master/README.mdREADME for further explanation.Promote each declaration, discarding the originals. Note that a promoted datatype uses the same definition as an original datatype, so this will not work with datatypes. Classes, instances, and functions are all fine.Generate defunctionalization symbols for each of the provided type-level declaration ?s. See the "Promotion and partial application" section of the  singletons  >https://github.com/goldfirere/singletons/blob/master/README.mdREADME for further explanation.Produce instances for PEq from the given typesProduce an instance for PEq from the given typeProduce instances for POrd from the given typesProduce an instance for POrd from the given typeProduce instances for PBounded from the given typesProduce an instance for PBounded from the given typeProduce instances for PEnum from the given typesProduce an instance for PEnum from the given typeProduce instances for PShow from the given typesProduce an instance for PShow from the given typePromote a term pattern into a type pattern, accumulating bound variable names in . InstanceSigsInstantiations for class tyvars See Note [Promoted class method kinds]%Let-binding unique (if locally bound)#Name of the function being promoted0Information about the promoted kind (if present)&The local variables currently in scopeThe kind of the pattern ( if known, 7 if unknown). When the kind is known, we can record a ! for variable patterns (see the ? case below) that includes more precise kind information. See Note [Local variables and kind information] (Wrinkle: Binding positions versus argument positions) in *Data.Singletons.TH.Promote.Syntax.LocalVar for more information.%Let-binding unique (if locally bound)#Name of the function being promoted0Information about the promoted kind (if present)&The local variables currently in scopeName of type familyLocal variables#Variables for type family argumentsType family result+( ( )None Generate singled definitions for each of the provided type-level declaration 5s. For example, the singletons-th package itself uses 2$(genSingletons [''Bool, ''Maybe, ''Either, ''[]]))to generate singletons for Prelude types.Make promoted and singled versions of all declarations given, retaining the original declarations. See the  >https://github.com/goldfirere/singletons/blob/master/README.mdREADME for further explanation.Make promoted and singled versions of all declarations given, discarding the original declarations. Note that a singleton based on a datatype needs the original datatype, so this will fail if it sees any datatype declarations. Classes, instances, and functions are all fine.Create instances of SEq for the given typesCreate instance of SEq for the given typeCreate instances of SDecide, , , and  for each type in the list.Create instances of SDecide, , , and  for the given type.Create instances of SOrd for the given typesCreate instance of SOrd for the given typeCreate instances of SBounded for the given typesCreate instance of SBounded for the given typeCreate instances of SEnum for the given typesCreate instance of SEnum for the given typeCreate instance of SShow for the given type(Not to be confused with showShowInstance.)Create instances of SShow for the given types(Not to be confused with .)Create instance of  for the given singleton type(Not to be confused with .)Create instances of  for the given singleton types(Not to be confused with .)Create an instance for SingI TyCon{N}, where N1 is the positive number provided as an argument.5Note that the generated code requires the use of the QuantifiedConstraints language extension.Create an instance for SingI TyCon{N}, where N1 is the positive number provided as an argument.5Note that the generated code requires the use of the QuantifiedConstraints language extension.If given a non-empty list of , construct a case expression that brings singleton equality constraints into scope via pattern-matching. See "Note [Singling pattern signatures].'(C) 2013 Richard EisenbergBSD-style (see LICENSE) Ryan Scott experimental non-portableNone The function  generates a case expression where each right-hand side is identical. This may be useful if the type-checker requires knowledge of which constructor is used to satisfy equality or type-class constraints, but where each constructor is treated the same.For  , unlike , the scrutinee is a singleton. But make sure to pass in the name of the original datatype, preferring ''Maybe over ''SMaybe. In other words, sCases ''Maybe is equivalent to  ''SMaybe..The head of the type of the scrutinee. (e.g., ''SBool)*The scrutinee, in a Template Haskell quote%The body, in a Template Haskell quote>The head of the type the scrutinee's type is based on. (Like ''Maybe or ''Bool.)*The scrutinee, in a Template Haskell quote%The body, in a Template Haskell quote  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHjIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHjIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~(C) 2013 Richard EisenbergBSD-style (see LICENSE) Ryan Scott experimental non-portableNone'Produce a representation and singleton for the collection of types given. A datatype Rep is created, with one constructor per type in the declared universe. When this type is promoted by the  singletons-th1 library, the constructors become full types in *&, not just promoted data constructors. For example, )$(singletonStar [''Nat, ''Bool, ''Maybe])generates the following: data Rep = Nat | Bool | Maybe Rep deriving (Eq, Ord, Read, Show)$and its singleton. However, because Rep is promoted to *0, the singleton is perhaps slightly unexpected: data SRep (a :: *) where SNat :: Sing Nat SBool :: Sing Bool SMaybe :: Sing a -> Sing (Maybe a) type instance Sing @(*) = SRepThe unexpected part is that Nat, Bool, and Maybe above are the real Nat, Bool, and Maybe&, not just promoted data constructors."Please note that this function is very$ experimental. Use at your own risk.A list of Template Haskell Name s for types  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHjIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~*+,*-.*-/*01*012345645745845945:45;45<45=45>45?458@459A45:B45;C45F45G45H45I45J45K45L45M45N45O45P45Q45R45S45T45U45V45W45X45Y45Z45[45\45]45^45_45`45a45b45c45d45e45f45g45h45i45j45k45l45645m45n45o45p45q45r45s45t45u45v45w45x45y45z45{45|45|45|}45~45454545454545?45454545454545454545454545454545454545454545454545454545454545454545454545454545444444'''''''''''''')))))))))))))))))))**     ****                                                                                     * *+**                    G                                                                               ** !!!!!"#$%%%%%%%%%%%%%%%%%%%%''''''''''''''''''''''''''''''')))))))))))))Z)))))))singletons-th-3.5-inplaceData.Singletons.TH)Data.Singletons.TH.SuppressUnusedWarningsData.Singletons.TH.OptionsData.Singletons.TH.CustomStar singletons-th"Data.Singletons.TH.Syntax.LocalVar)src/Data/Singletons/TH/Syntax/LocalVar.hsData.Singletons.TH.Syntax src/Data/Singletons/TH/Syntax.hsData.Singletons.TH.Utilsrc/Data/Singletons/TH/Util.hsData.Singletons.TH.Names!src/Data/Singletons/TH/Options.hs Data.Singletons.TH.Single.FixityData.Singletons.TH.Promote.Type&src/Data/Singletons/TH/Promote/Type.hsData.Singletons.TH.Single.Ord Data.Singletons.TH.Promote.Monad'src/Data/Singletons/TH/Promote/Monad.hsData.Singletons.TH.Single.Monad&src/Data/Singletons/TH/Single/Monad.hsData.Singletons.TH.Single.Type Data.Singletons.TH.Promote.DefunData.Singletons.TH.Single.DefunData.Singletons.TH.Single.Data Data.Singletons.TH.Deriving.Util!Data.Singletons.TH.Deriving.Infer Data.Singletons.TH.Single.Decide'Data.Singletons.TH.Deriving.Traversable Data.Singletons.TH.Deriving.ShowData.Singletons.TH.Deriving.Ord$Data.Singletons.TH.Deriving.Foldable#Data.Singletons.TH.Deriving.FunctorData.Singletons.TH.Deriving.Eq Data.Singletons.TH.Deriving.Enum#Data.Singletons.TH.Deriving.BoundedData.Singletons.TH.Partition#src/Data/Singletons/TH/Partition.hsData.Singletons.TH.Promote!src/Data/Singletons/TH/Promote.hsData.Singletons.TH.Single ghc-internalGHC.Internal.BaseVoidGHC.Internal.Data.Type.Equality:~:ReflGHC.Internal.Data.ProxyProxySuppressUnusedWarningssuppressUnusedWarningssingletons-3.0.4-inplaceData.Singletons@@FromSingSLambda2SLambda3SLambda4SLambda5SLambda6SLambda7SLambda8Sing applySing2 applySing3 applySing4 applySing5 applySing6 applySing7 applySing8demotedemote1demote2sing1sing2 singByProxy singByProxy# singByProxy1 singByProxy1# singByProxy2 singByProxy2#singFun1singFun2singFun3singFun4singFun5singFun6singFun7singFun8 singInstancesingThat singThat1 singThat2 unSingFun1 unSingFun2 unSingFun3 unSingFun4 unSingFun5 unSingFun6 unSingFun7 unSingFun8 usingSingI1 usingSingI2withSing withSing1 withSing2 withSingI withSomeSing@@@#@$@@@#@$$@@@#@$$$Apply ApplySym0 ApplySym1 ApplySym2 ApplyTyConApplyTyConAux1ApplyTyConAux2 DemoteSym0 DemoteSym1KindOf KindOfSym0 KindOfSym1SLambda applySing SWrappedSing SWrapSing sUnwrapSingSameKind SameKindSym0 SameKindSym1 SameKindSym2 SingFunction1 SingFunction2 SingFunction3 SingFunction4 SingFunction5 SingFunction6 SingFunction7 SingFunction8SingIsingSingI1liftSingSingI2 liftSing2 SingInstanceSingKindDemotefromSingtoSingSomeSingTyConTyCon1TyCon2TyCon3TyCon4TyCon5TyCon6TyCon7TyCon8TyFun UnwrapSing WrappedSingWrapSing unwrapSing~>~>@#@$~>@#@$$~>@#@$$$Data.Singletons.DecideDecision DisprovedProvedRefutedSDecide%~OptionsM OptionsMonad getOptionsOptionsdefunctionalizedNamesingledValueNamesingledDataConNamesingledClassNamesingledDataTypeNamepromotedValueNamepromotedClassNamepromotedDataTypeOrConNamegenSingKindInsts genQuotedDecsdefaultOptionspromotedTopLevelValueNamepromotedLetBoundValueNamedefunctionalizedName0 withOptions$fOptionsMonadRWST$fOptionsMonadWriterT$fOptionsMonadStateT$fOptionsMonadReaderT$fOptionsMonadQWithAux$fOptionsMonadDsM$fOptionsMonadQ$fOptionsMonadOptionsM$fFunctorOptionsM$fApplicativeOptionsM$fMonadOptionsM$fMonadTransOptionsM$fQuoteOptionsM$fQuasiOptionsM$fMonadFailOptionsM$fMonadIOOptionsM$fDsMonadOptionsM genPromotionspromote promoteOnlygenDefunSymbolspromoteEqInstancespromoteEqInstancepromoteOrdInstancespromoteOrdInstancepromoteBoundedInstancespromoteBoundedInstancepromoteEnumInstancespromoteEnumInstancepromoteShowInstancespromoteShowInstance genSingletons singletonssingletonsOnlysingEqInstancessingEqInstancesingDecideInstancessingDecideInstancesingOrdInstancessingOrdInstancesingBoundedInstancessingBoundedInstancesingEnumInstancessingEnumInstancesingShowInstancesingShowInstancesshowSingInstanceshowSingInstancessingITyConInstancessingITyConInstancecasessCases singletonStarLocalVarlvNameGHC.Internal.TH.SyntaxNamelvKindGHC.Internal.MaybeMaybeth-desugar-1.18-dc6c610a1108ea6c8ee9bb650efabde8cea68ff8867ac32e49efdcc010a6cc34Language.Haskell.TH.Desugar.ASTDKindDTyVarBndrUnitfoldTypeLocalVarsDType localVarToTvb DTyVarBndrlocalVarToTypelocalVarToTypeArg Language.Haskell.TH.Desugar.CoreDTypeArg tvbToLocalVar $fOrdLocalVar $fEqLocalVar$fDataLocalVar$fShowLocalVar LetDecEnv lde_proms LetDecProm VarPromotions ADLamCasesEbuildLetDecEnvemptyLetDecEnv infixDecl typeBinding valueBinding AClassDeclADClauseADExpADAppEADConEADLetEADLitEADSigEADVarEADPatADBangPADConPADLitPADSigPADTildePADVarPADWildP AInstDecl ALetDecEnv ALetDecRHS AnnotatedAnnotationFlag Unannotated ClassDeclcd_atfscd_cxtcd_fdscd_ldecd_namecd_tvbsClosedTypeFamilyDeclDataDecl DerivedDeclded_decl ded_mb_cxtded_typeded_type_tycon DerivedEqDeclDerivedOrdDeclDerivedShowDecl FamilyInfoClosedOpenIfAnnInstDecl id_arg_tysid_cxtid_methsid_nameid_sigs lde_defns lde_infix lde_types LetDecRHS AFunctionAValue UFunctionUValueOpenTypeFamilyDecl PromDPatInfosprom_dpat_sig_kvsprom_dpat_varsSingDSigPaInfos TySynDeclTypeFamilyDeclgetTypeFamilyDecl UClassDecl UInstDecl ULetDecEnv ULetDecRHS$fMonoidPromDPatInfos$fSemigroupPromDPatInfos$fMonoidLetDecEnv$fSemigroupLetDecEnv qNewUniqueisInfixDataCon isDataConNameisUpcaseghc-prim GHC.TypesFalsedtvbSpecsToBndrVisDTyVarBndrSpec DTyVarBndrVis SpecifiedSpec BndrInvis InferredSpecdtvbForAllTyFlagsToBndrVis Language.Haskell.TH.Desugar.Util ForAllTyFlagdtvbForAllTyFlagsToSpecsBndrReqdsReifyTypeNameInfo!Language.Haskell.TH.Desugar.ReifylookupTypeNameWithLocalsdsReify addBinding addElementbuildDataDTvbs checkForRepcheckForRepInDeclscheckVanillaDType concatMapM countArgsdefaultMaybeToTypeKinddefaultTvbToTypeKind dropTvbKind evalForAux evalForPairevalWithoutAux extractNameextractNameArgsextractRecSelNamesextractTvbFlagextractTvbKindextractTvbNamefilterInvisTvbArgsfoldExpfoldType foldTypeTvbsfstOf3 headNameStrinferMaybeKindTV isHsLetterliftFstliftSndlistify mapAndUnzip3M mapMaybeMmaybeKindToResultSig maybeSigT multiCase noExactName noExactTyVarsnoPrefix orIfEmptypartitionLetDecs partitionWithpartitionWithM prefixConName prefixName qReportErrorqReportWarningravelVanillaDTyperecSelsOfConFieldsresultSigToMaybeKindsnocViewsubstFamilyResultSig suffixName tailNameStr toUpcaseStr tvbToTypetysOfConFieldsuniquePrefixesunravelVanillaDTypeunravelVanillaDType_eitherupcase zipWith3MQWithAuxQWArunQWAUnravelM runUnravelM$fFunctorQWithAux$fApplicativeQWithAux$fMonadQWithAux$fMonadTransQWithAux$fMonadWritermQWithAux$fMonadReaderrQWithAux$fMonadFailQWithAux$fMonadIOQWithAux$fQuasiQWithAux$fDsMonadQWithAux$fFunctorUnravelM$fApplicativeUnravelM$fMonadUnravelM$fMonadErrorListUnravelM$fMonadReaderBoolUnravelMmkTyNameOccNamesplitUnderscoresStringJustNothingandNameapNameapply applyName applySingNameapplyTyConAux1NameapplyTyConNameboolKiboolName boundedName cmpEQName cmpGTName cmpLTName compareName composeNameconsNameconstraintNamedecideCoercionNamedecideEqualityName demoteName disprovedNameenumNameeqName equalityName equalsName errorNamefmapName foldApply foldMapName foldableName foldlName foldrName fromEnumNamefromIntegerName fromSingNamefromStringName functorNamegtName liftA2Name liftSing2Name liftSingNamelistName mappendName maxBoundName memptyName minBoundNamemkEqPredmkListE mkSingINamemkSingMethName mkTyConNamemodifyConNameDType negateNamenilNameordName orderingName provedNamepureNamereflNamerepName replaceNamesDecideClassNamesDecideMethName sameKindName sappendName showCharNameshowCommaSpaceNameshowName showParenName showSName showSingName showSpaceNameshowStringName showsPrecName singFamilysingFamilyName singI1Name singI2Name singINamesingKindClassNamesingKindConstraint singMethNamesomeSingDataNamesomeSingTypeName stringNamesuppressClassNamesuppressMethodName symbolNametestCoercionClassNametestCoercionMethNametestEqualityClassNametestEqualityMethName toEnumName toSingNametraversableName traverseNametyFunArrowName withSingINameIntUniqTrueDsMonad singInfixDeclsingReifiedInfixDeclsPromoteTypeOptionsptoAllowWildcardsptoCheckVanilla promoteTypepromoteType_NCdefaultPromoteTypeOptionspromoteType_optionspromoteTypeArg_NCpromoteUnraveled$fShowPromoteTypeOptionsmkOrdInstanceForSingletonLetBindPrEnv pr_local_varspr_lambda_varspr_scoped_vars emitDecsM scopedBind lambdaBind lookupVarE allLocalsemitDecsletBindpromoteM promoteMDecs promoteM_PrM$fOptionsMonadPrM $fDsMonadPrM $fFunctorPrM$fApplicativePrM $fMonadPrM $fQuasiPrM$fMonadReaderPrEnvPrM$fMonadWriterListPrM$fMonadFailPrM $fMonadIOPrMSgEnv sg_local_vars bindLambdas lookupConE$fOptionsMonadSgM askContext bindContextbindLets singDecsMsingM wrapSingFunSgM $fDsMonadSgM $fFunctorSgM$fApplicativeSgM $fMonadSgM$fMonadReaderSgEnvSgM$fMonadWriterListSgM$fMonadFailSgM $fMonadIOSgM $fQuasiSgMsingPred singPredRec singPred_NCsingTypebuildDefunSymsbuildDefunSymsClosedTypeFamilyDbuildDefunSymsDataDbuildDefunSymsOpenTypeFamilyDbuildDefunSymsTySynDbuildDefunSymsTypeFamilyHeadbuildTyFunArrowbuildTyFunArrow_maybedefunAssociatedTypeFamilies defunInfo defunReifydefunTopLevelTypeDeclsdefunctionalize DefunKindInfo DefunNoSAKDefunSAK singDefuns singDataSAKsingCtor singDataDFT ft_forall ft_bad_app ft_ty_appft_varft_trivisInTypeFamilyAppfunctorLikeTraversedeepSubtypesContainingfoldDataConArgsfunctorLikeValidityChecksgetDVarTName_maybeisFunctorLikeClassNamemkSimpleConClause mkSimpleLam mkSimpleLam2mkSimpleWildLammkSimpleWildLam2 DerivDesc FFoldTypeinferConstraintsinferConstraintsDefmkDecideInstancemkEqInstanceForSingletonmkTestInstancemkDecideMethClausemkEmptyDecideMethClause TestInstance TestCoercion TestEqualitymkTraversableInstanceparenInfixConNamemkShowSingContextGHC.Internal.ShowShowmkShowInstance mkOrdInstancemkFoldableInstancemkFunctorInstanceReplacer ImmediateNestedreplace mkEqInstancemkEnumInstancemkBoundedInstance partitionDecs GHC.ClassesOrdpartitionDerivingEqisStockOrDefaultpartitionClassDec partitionDecpartitionInstanceDecPartitionedDecsPDecs pd_class_decspd_closed_type_family_decs pd_data_decspd_derived_eq_decspd_derived_ord_decspd_derived_show_decspd_instance_decs pd_let_decspd_open_type_family_decspd_ty_syn_decs$fMonoidPartitionedDecs$fSemigroupPartitionedDecs promotePatInstanceMethods promoteClauseDVarPpromoteLetDecNamedTypeFamilyHead_with_localspromote'promoteClassDecpromoteDataDecpromoteDataDecs promoteDecs promoteExppromoteInfixDecl promoteInfopromoteInstancepromoteInstanceDecpromoteLetDecEnvpromoteLetDecRHSpromoteLetDecs promoteLitExp promoteLitPat promoteMethodpromoteReifiedInfixDeclsLetDecRHSKindInfoLDRKI LetDecRHSSortClassMethodRHS LetBindingRHS MethodSortDefaultMethods$fShowLetDecRHSSort$fShowMethodSort mkSigPaCaseE buildDataLets buildMethLets sEqToSDecide singClassD singClausesingDerivedEqDecssingDerivedOrdDecssingDerivedShowDecssingExpsingInfo singInstD singLetDecEnv singLetDecRHSsingLitsingPatsingTopLevelDecs singTySig singletons'