!9.      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-None&',-.=>?@AHSUVXk,static4Type family representing the type of a continuation.static>Type family representing the type of a continuation of 2 args. static>Type family representing the type of a continuation of 3 args.$static"Null constraint over 1 type param.%static6Convert a list of constraints into a single constraint&staticGData type wrapping a constraint, to avoid ImpredicativeTypes GHC error.8static#Null constraint over 2 type params.=staticCombine two constraintsEstaticEntailment over 2 type params.Fstatic{Combine two constraint constructors, each taking 2 type params, into a single constraint constructor taking 2 type params.*This is analogous to the term-level idiom ap (ap . ((,) .) . c0) c1P that combines two functions c0, c1 that each take 2 params, into a single one.GstaticICombine two constraint constructors into a single constraint constructor.*This is analogous to the term-level idiom ap ((,) . c0) c17 that combines two functions c0, c1 into a single one.]staticResult type of .`static"Heterogeneous unconstrained table."To add or remove constraints, see ,  and .astaticA b? with a constraint that applies only to the value, not the key.bstatic Heterogeneous constrained table.estaticMaybe that carries its type.staticjLookup an element in the table, and generate some proofs about the result that can be used by the caller.static*Lookup two elements in two related tables..The types of the outputs are provably related.static=Zip two related tables, giving a third table related to both..The types of the outputs are provably related.static@Zip three related tables, giving a fourth table related to both..The types of the outputs are provably related.staticWeaken the constraint on a b.staticStrengthen the constraint on a b.staticStrengthen the constraint on a `.s $%&'()*+,-./0189:;=>?@ABEFGHIJKLOPQRSTUVW\]_^`abdcegfhijklmnopqrstuvwxyz{|}~s   )0./,-*+1&'(%$;9:8B@A>?=LJKHIGFEWUVSTQROPjyz{|}~klmnopqrstuvwxihegfbdca`]_^\None&',-.479=?@AHSVXWBstatic=A value and its external representation, indexed by some key.static:Convert an external value into its generic representation.static9Convert a generic representation into its external value.This may fail, since g% may have to represent several other v' as well, which k should help determine.static7Possible errors when resolving a key in a static table.static;Serialisable external value, with an associated static-key.ga is a type that can generically represent all the external interface of your static values. See  and  for more details.staticUniform generic wrapper.zIn a type-safe language like Haskell, one needs to know in advance the type of something in order to deserialise it successfully. In many applications however, the point at which data enters the program is separate from the point at which we have enough type information to fully deserialise a statically-keyed value. Between these points, we often want to deserialise the other: parts of that data, and perform logic based on its value..This wrapper works around that fact by double-encoding the static-value. This is perhaps suboptimal performance-wise, but is simple to implement and use, especially in a compositional manner. When data first enters the program, one can deserialise the whole data using the mechanism represented by s, which will then contain  b instances of this type inside it. When you finally have enough type information to perform the rest of the deserialise you can call J on these parts, to recovered the typed value corresponding to each part.5This wrapper also short-circuits the case of calling  then r without attempting to serialise the value in between. In this case the original value is simply wrapped in the 0 constructor, no attempt to serialise based on s) is actually made, and no value based on b is ever constructed.If you need optimal performance and really must avoid double-serialising, you can instead define your own ADT as a sum-type over all your possible serialisation types, make this serialisable, and implement  for it.s. is a constraint over serialisable types, e.g . or /. b* is the concrete serialisation type, e.g. 0.static instance for 1.Note that by nature this is not serialisable, and is only really meant for testing purposes. Neither can it support a generic 2 or 3& instance; if you need that then try  or .None&',-.4HSUVXklstaticEA continuation from an internal and external value, to a result type r.staticRepExt c g ext k v is a constraint comprising: RepVal g (ext v) k c k v)modulo singletons defunctionalisation on c and ext.static:Internal value, typed-indexed by an associated static-key. Generally, v is not expected to be serialisable or otherwise representable outside of the program. For cases where it is, you should define an instance of . That then enables you to use 3 and other utility functions with this constraint.static/Standalone static key with no associated value.0Users typically don't need this, and should use  or  as appropriate.static Similar to 4 for a , extract the type from the 51 key and run a typed function on the typed value.static^Convert an internal value to an external value, depending on the existence of an instance of  to help perform the conversion.staticHelper function for building bs.static Given an  of an external value g, do the following: 4Lookup the corresponding internal value (I) of type v.&Decode the external value (X) of type g/, if its type can be decoded into the type ext v.*Lookup the corresponding continuation (C).4Apply (C) to (I) and (X), returning a value of type r.None&',-.=>?@AHSUVXkstaticA post-closure is a function that takes a runtime result, and converts all the results of all different closures into the same type.staticJA closure is a function that takes a runtime argument, and gives a result.It is created by applying a constraint and environment to a pre-closure. Typically you do this once on a table of pre-closures, using .staticA pre-closure is a function that takes two statically-known arguments: a constraint, and an explicit argument; and gives a closure.ATypically, you define a bunch of top-level functions of the form (ctx => env -> arg -> res)=, then create a table of pre-closures using the TH function .staticAAn applied closure, consisting of its static key and an argument.static!Closure, internal representation.The type parameter env# is meant for a bag of functions known statically at compile time, that you don't need to serialise and so don't want the added complexity of dealing with $(mkStatic). For example, if your function takes in extra utility functions, but these are all statically-known. The type parameter cxt< are the constraint types, which is effectively similar to env: except that Haskell deals with them slightly differently.static Create a ! in its serialisable static form.staticA  whose result is exactly r.staticRepClosure c g k v is a constraint comprising: RepVal g (Arg v) k  c k (Res v)  Closure v)modulo singletons defunctionalisation on c.static'A continuation from the result type to x.staticJApply a table of pre-closures to its inputs, creating a table of closures.staticEApply a table of closures to its inputs, creating a table of results.staticJApply a table of results to its post-closures, creating a table of values.static\Apply a table of closures to a table of inputs and post-closures, giving a table of values.JThis method is just a demo, users will want one of the exported functions.static8Create a table of closures from a table of pre-closures._We apply the relevant constraints and environment arguments, statically-known at compile time.static Convert a  table into a  table, deducing constraints.&This is used to convert the result of = into a form that can be passed to the other functions e.g. .staticzApply a closure table to a single input and a post-processing table, giving a single result (if the input key was found).TThis is the statically-typed version; for a version that runs for unknown keys see .staticzApply a closure table to a single input and a post-processing table, giving a single result (if the input key was found).eThis is the dynamically-typed version; for a version that type-checks for statically-known keys see .staticyApply a closure table to a single input, and pass the constrained result to a continuation (if the input key was found).TThis is the statically-typed version; for a version that runs for unknown keys see .staticyApply a closure table to a single input, and pass the constrained result to a continuation (if the input key was found).eThis is the dynamically-typed version; for a version that type-checks for statically-known keys see .static|Evaluate a closure application with statically-known type, against a table of closures, that all have the same result type.static~Evaluate a closure application with statically-unknown type, against a table of closures, that all have the same result type.2     2     None4bcd4bcdNone-.HUVk6static Needed for ', definition taken from /https://gitlab.haskell.org/ghc/ghc/issues/12073&staticGCreate top-level statically-keyed values from regular top-level values.'staticCreate top-level statically-keyed values from regular top-level values, when their definitions need to refer to other statically-keyed values.hSince TH cannot handle references to names defined later in the source file, it is not possible to use &` for this purpose; you must use this function instead, and then register the names later using *.!See unit tests for example usage.)staticvCreate a table holding the static values for a list of top-level names, binding it to the top-level name "staticTab".*staticpCreate a table holding the static values for a list of top-level names, binding it to the given top-level name.+staticRefer to a static value, as a . Be sure to pass the argument to * so the referent exists.,static+Get the symbol key of a static value, as a . Be sure to pass the argument to * so the referent exists.!Users typically don't need this; +L is more type-safe as it includes the type of the value, and this does not.-staticBGet the symbol key type of a static value, as a type-level string.7static1Apply a list of expressions to a base expression.8static#Construct a promoted-list of types.9static5Convert a context (a list of types) to a single type.:staticJLook up the "original name" (module:name) and type of a top-level function;static5Extract type info from top-level decls without using <.=static7Simplify a source-level type. This attempts to do what <G does but without needing the definition to exist at the splice point.>static Variation on ?7 which takes a single expression to define the function@static.The name of a type variable binding occurrenceAstaticCFully qualified name, as a type-level String literal of kind Symbol &'(&'()*+,- +,-&'()*&'(B      !"#$%&'()*+,-.//0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@>?ABCD;EFGHIJKLMNOPQMRSTUV%static-0.1.0.0-7wqGG0f3J7JHnhbc0pzNq6Control.Static.CommonControl.Static.SerialiseControl.Static.StaticControl.Static.ClosureControl.Static.TH mkStaticTabControl.StaticSKeyaplookupKV lookupKV_IfTyContTyCont2 TyContSym0TyContSym0KindInference TyContSym1TyContSym1KindInference TyContSym2$$fSuppressUnusedWarnings->TyContSym1$$fSuppressUnusedWarnings->TyContSym0TyCont3 TyCont2Sym0TyCont2Sym0KindInference TyCont2Sym1TyCont2Sym1KindInference TyCont2Sym2TyCont2Sym2KindInference TyCont2Sym3%$fSuppressUnusedWarnings->TyCont2Sym2%$fSuppressUnusedWarnings->TyCont2Sym1%$fSuppressUnusedWarnings->TyCont2Sym0 TyCont3Sym0TyCont3Sym0KindInference TyCont3Sym1TyCont3Sym1KindInference TyCont3Sym2TyCont3Sym2KindInference TyCont3Sym3TyCont3Sym3KindInference TyCont3Sym4%$fSuppressUnusedWarnings->TyCont3Sym3%$fSuppressUnusedWarnings->TyCont3Sym2%$fSuppressUnusedWarnings->TyCont3Sym1%$fSuppressUnusedWarnings->TyCont3Sym0NullC ConstrainListCxtWunCxtWApApSym0ApSym0KindInferenceApSym1ApSym1KindInferenceApSym2ApSym2KindInferenceApSym3sAp$fSingI->ApSym2 $fSuppressUnusedWarnings->ApSym2$fSingI->ApSym1 $fSuppressUnusedWarnings->ApSym1$fSingI->ApSym0 $fSuppressUnusedWarnings->ApSym0NullC2 NullCSym0NullCSym0KindInference NullCSym1#$fSuppressUnusedWarnings->NullCSym0AndC NullC2Sym0NullC2Sym0KindInference NullC2Sym1NullC2Sym1KindInference NullC2Sym2$$fSuppressUnusedWarnings->NullC2Sym1$$fSuppressUnusedWarnings->NullC2Sym0Class2AndC2AndC1AndCSym0AndCSym0KindInferenceAndCSym1AndCSym1KindInferenceAndCSym2"$fSuppressUnusedWarnings->AndCSym1"$fSuppressUnusedWarnings->AndCSym0 Class2Sym0Class2Sym0KindInference Class2Sym1Class2Sym1KindInference Class2Sym2Class2Sym2KindInference Class2Sym3Class2Sym3KindInference Class2Sym4$$fSuppressUnusedWarnings->Class2Sym3$$fSuppressUnusedWarnings->Class2Sym2$$fSuppressUnusedWarnings->Class2Sym1$$fSuppressUnusedWarnings->Class2Sym0DictOfTCMaybe TCNothingTCJustTTabTCTab'TCTabTCNilTCConsTMaybeTNothingTJustProofLookupKV_If ProofLookupKV LookupKV_IfLookupKVLookupKV_IfSym0LookupKV_IfSym0KindInferenceLookupKV_IfSym1LookupKV_IfSym1KindInferenceLookupKV_IfSym2LookupKV_IfSym2KindInferenceLookupKV_IfSym3LookupKV_IfSym3KindInferenceLookupKV_IfSym4LookupKV_IfSym4KindInferenceLookupKV_IfSym5LookupKV_IfSym5KindInferenceLookupKV_IfSym6 LookupKVSym0LookupKVSym0KindInference LookupKVSym1LookupKVSym1KindInference LookupKVSym2LookupKVSym2KindInference LookupKVSym3 sLookupKV sLookupKV_IflookupTC lookupTC2 zipWithTC zipWith3TC withTCDicttoTCDictweakenTC strengthenTC strengthenTC0$fSingI->LookupKV_IfSym5$fSingI->LookupKV_IfSym4$fSingI->LookupKV_IfSym3$fSingI->LookupKV_IfSym2$fSingI->LookupKV_IfSym1$fSingI->LookupKV_IfSym0$fSingI->LookupKVSym2$fSingI->LookupKVSym1$fSingI->LookupKVSym0)$fSuppressUnusedWarnings->LookupKV_IfSym0)$fSuppressUnusedWarnings->LookupKV_IfSym1)$fSuppressUnusedWarnings->LookupKV_IfSym2)$fSuppressUnusedWarnings->LookupKV_IfSym3)$fSuppressUnusedWarnings->LookupKV_IfSym4)$fSuppressUnusedWarnings->LookupKV_IfSym5&$fSuppressUnusedWarnings->LookupKVSym0&$fSuppressUnusedWarnings->LookupKVSym1&$fSuppressUnusedWarnings->LookupKVSym2$fProofLookupKVvktafk[][]%$fProofLookupKV_Ifbktafkk'kkv'vvFalse$$fProofLookupKV_Ifbktafkk'kkv'vvTrue$fProofLookupKVvktafk::RepValtoRepfromRep SKeyedErrorSKeyedNotFoundSKeyedExtDecodeFailure SKeyedExt$fReadSKeyedExt$fShowSKeyedExt$fGenericSKeyedExt$fBinarySKeyedExt$fSerialiseSKeyedExt $fEqSKeyedExt$fOrdSKeyedExt$fFunctorSKeyedExt$fReadSKeyedError$fShowSKeyedError$fGenericSKeyedError$fBinarySKeyedError$fSerialiseSKeyedError$fEqSKeyedError$fOrdSKeyedErrorDBinary DSerialiseDoubleEncodingDecoded HalfEncoded RepValSym0RepValSym0KindInference RepValSym1RepValSym1KindInference RepValSym2RepValSym2KindInference RepValSym3 castOrFaildecodeFullyOrFail$fRepValktDynamicvk$$fSuppressUnusedWarnings->RepValSym2$$fSuppressUnusedWarnings->RepValSym1$$fSuppressUnusedWarnings->RepValSym0$fOrdDoubleEncoding$fEqDoubleEncoding$fRepValktDoubleEncodingvk$fSerialiseDoubleEncoding$fOrdDoubleEncoding0$fEqDoubleEncoding0$fRepValktDoubleEncodingvk0$fBinaryDoubleEncodingTyContIX RepExtSym3SKeyed withSKeyedExt toSKeyedExttoSKeyedEither skeyedCons$fFunctorSKeyed TyContIXSym0TyContIXSym0KindInference TyContIXSym1TyContIXSym1KindInference TyContIXSym2TyContIXSym2KindInference TyContIXSym3 gwithStatic withStaticCtswithSomeStaticCts withStaticCxtwithSomeStaticCxt&$fSuppressUnusedWarnings->TyContIXSym2&$fSuppressUnusedWarnings->TyContIXSym1&$fSuppressUnusedWarnings->TyContIXSym0 PostClosurePre applyPostClosureArgResapply PreClosureCxtEnvPartapplyPre ClosureApply ClosureFunc applyClosure envTabCons envTabNil $fClosure->$fPreClosureCxtW$fPostClosurex-> RepClosure' RepClosureResContPreSym0PreSym0KindInferencePreSym1ResSym0ResSym0KindInferenceResSym1ArgSym0ArgSym0KindInferenceArgSym1PartSym0PartSym0KindInferencePartSym1EnvSym0EnvSym0KindInferenceEnvSym1CxtSym0CxtSym0KindInferenceCxtSym1applyClosureTabPreapplyClosureTabapplyClosureTabPostevalClosureTab mkClosureTab repClosureTabwithEvalClosureCtswithEvalSomeClosureCtswithEvalClosureCxtwithEvalSomeClosureCxt evalClosureevalSomeClosure!$fSuppressUnusedWarnings->CxtSym0!$fSuppressUnusedWarnings->EnvSym0"$fSuppressUnusedWarnings->PartSym0!$fSuppressUnusedWarnings->ArgSym0!$fSuppressUnusedWarnings->ResSym0!$fSuppressUnusedWarnings->PreSym0 mkStaticsmkStaticsWithRefsdefaultStaticTabmkDefStaticTab staticRef staticKey staticKeyType(serialise-0.2.3.0-GqFoOM5Y0TNLWxAImDYvM0Codec.Serialise.Class Serialisebinary-0.8.6.0Data.Binary.ClassBinarybytestring-0.10.8.2Data.ByteString.Lazy.Internal ByteStringbase Data.DynamicDynamicghc-prim GHC.ClassesEqOrd'singletons-2.5.1-3waiIYls6BVLZFhearlvVoData.Singletons.Internal withSomeSingGHC.BaseStringmfixQapListtyList cxtToTypegetTypesigsOftemplate-haskellLanguage.Haskell.TH.Syntaxreify simplifyTypesfnD Language.Haskell.TH.Lib.InternalfunD tyVarNamesymFQN