h,sc      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~3.3None singletons-thThis 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.None1None  singletons-thGenerate a new Unique singletons-this a valid Haskell infix data constructor (i.e., does it begin with a colon?) singletons-thIs an identifier a legal data constructor name in Haskell? That is, is its first character an uppercase letter (prefix) or a colon (infix)? singletons-thIs 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. singletons-thNon@capture-avoiding substitution. (If you want capture-avoiding substitution, use substTy from !Language.Haskell.TH.Desugar.Subst. singletons-thCall  first to ensure we have a # in the type namespace, then call .None Q singletons-thReturn 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. singletons-thIf 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  singletons-th#A convenient implementation of the  class. Use by calling . singletons-th)Class that describes monads that contain . singletons-th.Options that control the finer details of how  singletons-th%'s Template Haskell machinery works. singletons-thGiven 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. singletons-thGiven the name of the original, unrefined value, produces the name of the singled equivalent of the value. singletons-thGiven the name of the original, unrefined data constructor, produces the name of the corresponding singleton data constructor. singletons-thGiven the name of the original, unrefined class, produces the name of the singled equivalent of the class. singletons-thGiven the name of the original, unrefined data type, produces the name of the corresponding singleton type. singletons-thGiven 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). singletons-thGiven the name of the original, unrefined class, produces the name of the promoted equivalent of the class. singletons-thGiven 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. singletons-thIf , 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). singletons-thIf , then quoted declarations will be generated alongside their promoted and singled counterparts. If 0, then quoted declarations will be discarded. singletons-thSensible 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. singletons-thGiven the name of the original, unrefined, top-level value, produces the name of the promoted equivalent of the value. singletons-th+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. singletons-thGiven 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). singletons-th Declare the " that a TH computation should use. singletons-th Turn any  into an . None! None'9  singletons-thOptions for controlling how types are promoted at a fine granularity. singletons-thIf , 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. singletons-thIf  , invoke - on the argument type being promoted. See 6Note [Vanilla-type validity checking during promotion]. singletons-th Promote a  to the kind level and invoke . See 6Note [Vanilla-type validity checking during promotion]. singletons-th 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]. singletons-th The default : is not invoked.:Throw an error when attempting to promote a wildcard type. singletons-th Promote a / to the kind level. This is the workhorse for  and . singletons-thPromote 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]. singletons-thPromote 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' singletons-thThe name of the data type None- singletons-thBring a list of =s into scope for the duration the supplied computation. See Note [Tracking local variables]. singletons-thMap 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]. singletons-thMap from term-level s of variables bound in lambdas and function clauses to their type-level counterparts. See Note [Tracking local variables]. singletons-th:The set of scoped type variables currently in scope. See Note [Scoped type variables]. singletons-thBring a list of type variables into scope for the duration the supplied computation. See Note [Tracking local variables] and Note [Scoped type variables]. singletons-thBring a list of < into scope for the duration the supplied computation. See Note [Tracking local variables]. singletons-th"A pair consisting of a term-level  of a variable, bound in a let binding or where. clause, and its type-level counterpart. See Note [Tracking local variables]. singletons-thMap 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].  None2d singletons-thMap from term-level 9s of local variables to their singled counterparts. See Note [Tracking local variables] in  Data.Singletons.TH.Promote.Monad. singletons-thBring 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. singletons-thMap 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. singletons-th7Map a data constructor name to its singled counterpart. singletons-thBring 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. None2None2(C) 2018 Ryan ScottBSD-style (see LICENSE) Ryan Scott experimental non-portableNone3SNone5/ singletons-th8The standalone kind signature for the original data type singletons-th3The user-written binders for the original data type singletons-th*The original data type, promoted to a kind singletons-th7The standalone kind signature for the singled data type singletons-th Type Then in the type F a b, we would consider a to be an argument to F , but not b. singletons-thVariable to look for singletons-th How to fold singletons-thType to process(C) 2015 Richard EisenbergBSD-style (see LICENSE) Ryan Scott experimental non-portableNone9None: singletons-thThe original2 constructors (for inferring the instance context) singletons-thThe  singletons constructors singletons-thThe name of the data type singletons-thThe name of the data type singletons-thThe 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< singletons-thParenthesize an infix constructor name if it is being applied as a prefix function (e.g., data Amp a = (:&) a a) singletons-thTurn 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=| singletons-th#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?S(C) 2015 Richard EisenbergBSD-style (see LICENSE) Ryan Scott experimental non-portableNone?(C) 2015 Richard EisenbergBSD-style (see LICENSE) Ryan Scott experimental non-portableNoneB singletons-th Split up a [DDec] into its pieces, extracting ! instances from deriving clauses singletons-th"The deriving strategy, if present. singletons-thThe class being derived (e.g., :), possibly applied to some number of arguments (e.g.,  C Int Bool). singletons-th ctx if ctx was provided via StandaloneDeriving.  if using a deriving clause. singletons-th$The data type argument to the class. singletons-thhttps://github.com/goldfirere/singletons/blob/master/README.mdREADME for further explanation. singletons-thPromote 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. singletons-thGenerate 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. singletons-thProduce instances for PEq from the given types singletons-thProduce an instance for PEq from the given type singletons-thProduce instances for POrd from the given types singletons-thProduce an instance for POrd from the given type singletons-thProduce instances for PBounded from the given types singletons-thProduce an instance for PBounded from the given type singletons-thProduce instances for PEnum from the given types singletons-thProduce an instance for PEnum from the given type singletons-thProduce instances for PShow from the given types singletons-thProduce an instance for PShow from the given type singletons-th InstanceSigs singletons-thInstantiations for class tyvars See Note [Promoted class method kinds] singletons-th%Let-binding unique (if locally bound) singletons-th#Name of the function being promoted singletons-th0Information about the promoted kind (if present) singletons-th&The local variables currently in scope singletons-th%Let-binding unique (if locally bound) singletons-th#Name of the function being promoted singletons-th0Information about the promoted kind (if present) singletons-th&The local variables currently in scope singletons-thName of type family singletons-thLocal variables singletons-th#Variables for type family arguments singletons-thType family result,NoneW singletons-thGenerate 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. singletons-thMake 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. singletons-thMake 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. singletons-thCreate instances of SEq for the given types singletons-thCreate instance of SEq for the given type singletons-thCreate instances of SDecide, , , and  for each type in the list. singletons-thCreate instances of SDecide, , , and  for the given type. singletons-thCreate instances of SOrd for the given types singletons-thCreate instance of SOrd for the given type singletons-thCreate instances of SBounded for the given types singletons-thCreate instance of SBounded for the given type singletons-thCreate instances of SEnum for the given types singletons-thCreate instance of SEnum for the given type singletons-thCreate instance of SShow for the given type(Not to be confused with showShowInstance.) singletons-thCreate instances of SShow for the given types(Not to be confused with .) singletons-thCreate instance of  for the given singleton type(Not to be confused with .) singletons-thCreate instances of  for the given singleton types(Not to be confused with .) singletons-thCreate 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. singletons-thCreate 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. singletons-thIf 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\V singletons-th 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. singletons-th.The head of the type of the scrutinee. (e.g., ''SBool) singletons-th*The scrutinee, in a Template Haskell quote singletons-th%The body, in a Template Haskell quote singletons-th>The head of the type the scrutinee's type is based on. (Like ''Maybe or ''Bool.) singletons-th*The scrutinee, in a Template Haskell quote singletons-th%The body, in a Template Haskell quote  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHjIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~oikljabX}BFGcdefj?@A~  !"#$%&'()*+,-./0123456789:;=CDEHIJKLMQRSUVWYZ[\]^_`ghpqrstuvwxyz{|(C) 2013 Richard EisenbergBSD-style (see LICENSE) Ryan Scott experimental non-portableNoneb singletons-thProduce 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. singletons-thA list of Template Haskell Name s for types  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHjIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !" #$ #% &' &'()*+,*+-*+.*+/*+0*+1*+2*+3*+4*+5*+.6*+/7*+08*+19*+2:*+3;*+4<*+=*+>*+?*+@*+A*+B*+C*+D*+E*+F*+G*+H*+I*+J*+K*+L*+M*+N*+O*+P*+Q*+R*+S*+T*+U*+V*+W*+X*+Y*+Z*+[*+\*+]*+^*+_*+`*+a*+b*+,*+c*+d*+e*+f*+g*+h*+i*+j*+k*+l*+m*+n*+o*+p*+q*+r*+r*+rs*+t*+u*+uv*+w*+x*+y*+z*+5*+{*+|*+}*+~*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+****** !  =                                          Psingletons-th-3.3-inplaceData.Singletons.TH)Data.Singletons.TH.SuppressUnusedWarningsData.Singletons.TH.OptionsData.Singletons.TH.CustomStar singletons-thData.Singletons.TH.SyntaxData.Singletons.TH.UtilData.Singletons.TH.Names Data.Singletons.TH.Single.FixityData.Singletons.TH.Promote.TypeData.Singletons.TH.Single.Ord Data.Singletons.TH.Promote.MonadData.Singletons.TH.Single.MonadData.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.PartitionData.Singletons.TH.PromoteData.Singletons.TH.SinglebaseGHC.BaseVoidData.Type.Equality:~:Refl Data.ProxyProxySuppressUnusedWarningssuppressUnusedWarningssingletons-3.0.2-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 singletonStarbuildLetDecEnvemptyLetDecEnv infixDecl typeBinding valueBinding AClassDeclADClauseADExpADAppEADCaseEADConEADLamEADLetEADLitEADSigEADVarEADMatchADPatADBangPADConPADLitPADSigPADTildePADVarPADWildP 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 LetDecEnv lde_defns lde_infix lde_proms lde_types LetDecRHS AFunctionAValue UFunctionUValueOpenTypeFamilyDecl PromDPatInfosprom_dpat_sig_kvsprom_dpat_varsSingDSigPaInfos TySynDeclTypeFamilyDeclgetTypeFamilyDecl UClassDecl UInstDecl ULetDecEnv ULetDecRHS VarPromotions qNewUniqueisInfixDataCon isDataConNameisUpcaseghc-prim GHC.TypesFalse substTypedsReifyTypeNameInfoth-desugar-1.16-b0bc292af80b321d6d062adc913e72b518cf65f62b1e5a2e577140d187ad8369!Language.Haskell.TH.Desugar.ReifylookupTypeNameWithLocalstemplate-haskellLanguage.Haskell.TH.SyntaxName Language.Haskell.TH.Desugar.CoredsReify addBinding addElementbuildDataDTvbs checkForRepcheckForRepInDeclscheckVanillaDType concatMapM countArgsdefaultMaybeToTypeKinddefaultTvbToTypeKind dropTvbKind evalForAux evalForPairevalWithoutAux extractNameextractNameArgsextractRecSelNamesextractTvbFlagextractTvbKindextractTvbNamefilterInvisTvbArgsfoldExpfoldType foldTypeTvbsfstOf3 headNameStrinferMaybeKindTV isHsLetterliftFstliftSndlistify mapAndUnzip3M mapDTVKind mapDTVName mapMaybeMmaybeKindToResultSig maybeSigT multiCase noExactName noExactTyVarsnoPrefix orIfEmptypartitionLetDecs partitionWithpartitionWithM prefixConName prefixName qReportErrorqReportWarningravelVanillaDTyperecSelsOfConFieldsresultSigToMaybeKindsnocViewsubstFamilyResultSig substKindsubstTvb substTvbs subst_tele suffixName tailNameStr toUpcaseStr tvbToTypetysOfConFieldsuniquePrefixesunravelVanillaDTypeunravelVanillaDType_eitherupcase zipWith3MQWithAuxQWArunQWAUnravelM runUnravelMmkTyNameOccNamesplitUnderscoresString GHC.MaybeJustNothingandNameapNameapply 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 withSingINameIntMaybeUniqTrueDsMonad singInfixDeclsingReifiedInfixDeclsPromoteTypeOptionsptoAllowWildcardsptoCheckVanilla promoteTypeLanguage.Haskell.TH.Desugar.ASTDTypepromoteType_NCdefaultPromoteTypeOptionspromoteType_optionspromoteTypeArg_NCpromoteUnraveledmkOrdInstanceForSingletonLetBindPrEnv pr_local_varspr_lambda_varspr_scoped_vars emitDecsM scopedBind lambdaBind lookupVarE allLocalsemitDecsletBindpromoteM promoteMDecs promoteM_PrMSgEnv sg_local_vars bindLambdas lookupConE$fOptionsMonadSgM askContext bindContextbindLets singDecsMsingM wrapSingFunSgMsingPred singPredRec singPred_NCsingTypebuildDefunSymsbuildDefunSymsClosedTypeFamilyDbuildDefunSymsDataDbuildDefunSymsOpenTypeFamilyDbuildDefunSymsTySynDbuildDefunSymsTypeFamilyHeadbuildTyFunArrowbuildTyFunArrow_maybedefunAssociatedTypeFamilies defunInfo defunReifydefunTopLevelTypeDeclsdefunctionalize DefunKindInfo DefunNoSAKDefunSAK singDefuns singDataSAKmatchUpSigWithDeclsingCtor singDataDFT ft_forall ft_bad_app ft_ty_appft_varft_trivisInTypeFamilyAppfunctorLikeTraversedeepSubtypesContainingfoldDataConArgsfunctorLikeValidityChecksgetDVarTName_maybeisFunctorLikeClassNamemkSimpleConClause mkSimpleLam mkSimpleLam2 DerivDesc FFoldTypeinferConstraintsinferConstraintsDefmkDecideInstancemkEqInstanceForSingletonmkTestInstancemkDecideMethClausemkEmptyDecideMethClause TestInstance TestCoercion TestEqualitymkTraversableInstanceparenInfixConNamemkShowSingContextGHC.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_decsInstanceMethods promoteClausepromoteLetDecNamedTypeFamilyHead_with_localspromote'promoteClassDecpromoteDataDecpromoteDataDecs promoteDecs promoteExppromoteInfixDecl promoteInfopromoteInstancepromoteInstanceDecpromoteLetDecEnvpromoteLetDecRHSpromoteLetDecs promoteLitExp promoteLitPat promoteMatch promoteMethod promotePatpromoteReifiedInfixDeclsLetDecRHSKindInfoLDRKI LetDecRHSSortClassMethodRHS LetBindingRHS MethodSortDefaultMethods mkSigPaCaseE buildDataLets buildMethLets isException sEqToSDecide singClassD singClausesingDerivedEqDecssingDerivedOrdDecssingDerivedShowDecssingExpsingInfo singInstD singLetDecEnv singLetDecRHSsingLit singMatchsingPatsingTopLevelDecs singTySig singletons'