h&qWg      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ Safe-Inferred$/$ghc-tcplugin-apiA collection of :s where the coercions and the types are stored separately.Use  to obtain  from a list of s.This datatype is used in , mkClassPredRedns and -, which expect separate types and coercions.Invariant: the two stored lists are of the same length, and the RHS type of each coercion is the corresponding type.ghc-tcplugin-apiA  in which the  has Representational role.ghc-tcplugin-apiA  in which the  has u role.ghc-tcplugin-api!Stores a heterogeneous reduction.The stored kind coercion must relate the kinds of the stored reduction. That is, in "HetReduction (Reduction co xi) kco, we must have: / co :: ty ~ xi kco :: typeKind ty ~ typeKind xighc-tcplugin-apiA 4 is the result of an operation that rewrites a type ty_in. The  includes the rewritten type ty_out and a  co such that co :: ty_in ~ ty_out, where the role of the coercion is determined by the context. That is, the LHS type of the coercion is the original type ty_in+, while its RHS type is the rewritten type ty_out.A Reduction is always homogeneous, unless it is wrapped inside a -, which separately stores the kind coercion.ghc-tcplugin-api!Create a heterogeneous reduction.Pre-condition: the provided kind coercion (second argument) relates the kinds of the stored reduction. That is, if the coercion stored in the  is of the form  co :: ty ~ xi4Then the kind coercion supplied must be of the form:  kco :: typeKind ty ~ typeKind xighc-tcplugin-api%Homogenise a heterogeneous reduction.Given "HetReduction (Reduction co xi) kco, with 1 co :: ty ~ xi kco :: typeKind(ty) ~ typeKind(xi)'this returns the homogeneous reduction: hco :: ty ~ ( xi |> sym kco )ghc-tcplugin-api Create a  from a pair of a  and a 'Type.Pre-condition: the RHS type of the coercion matches the provided type (perhaps up to zonking).Use ! when you only have the coercion.ghc-tcplugin-api4Get the original, unreduced type corresponding to a .This is obtained by computing the LHS kind of the stored coercion, which may be slow.ghc-tcplugin-apiTurn a  into a - by inspecting the RHS type of the coercion. Prefer using  when you already know the RHS type of the coercion, to avoid computing it anew.ghc-tcplugin-api1Downgrade the role of the coercion stored in the .ghc-tcplugin-api1Downgrade the role of the coercion stored in the , from u to Representational.ghc-tcplugin-api0Compose a reduction with a coercion on the left.Pre-condition: the provided coercion's RHS type must match the LHS type of the coercion that is stored in the reduction.ghc-tcplugin-apiThe reflexive reduction.ghc-tcplugin-api Create a  from a kind cast, in which the casted type is the rewritten type.Given ty :: k1, mco :: k1 ~ k2, produces the  ty ~res_co~> (ty |> mco) at the given v.ghc-tcplugin-api Create a  from a kind cast, in which the casted type is the rewritten type.Given ty :: k1, mco :: k1 ~ k2, produces the  ty ~res_co~> (ty |> mco) at the given v.ghc-tcplugin-api Create a  from a kind cast, in which the casted type is the original (non-rewritten) type.Given ty :: k1, mco :: k1 ~ k2, produces the  (ty |> mco) ~res_co~> ty at the given v.ghc-tcplugin-api Create a  from a kind cast, in which the casted type is the original (non-rewritten) type.Given ty :: k1, mco :: k1 ~ k2, produces the  (ty |> mco) ~res_co~> ty at the given v.ghc-tcplugin-api Apply a cast to the result of a .Given a  ty1 ~co1~> (ty2 :: k2) and a kind coercion kco with LHS kind k2, produce a new  ty1 ~co2~> ( ty2 |> kco ) of the given v; (which must match the role of the coercion stored in the  argument).ghc-tcplugin-api Apply a cast to the result of a  , using an  MCoercionN.Given a  ty1 ~co1~> (ty2 :: k2) and a kind coercion mco with LHS kind k2, produce a new  ty1 ~co2~> ( ty2 |> mco ) of the given v; (which must match the role of the coercion stored in the  argument).ghc-tcplugin-apiApply a cast to a 1, casting both the original and the reduced type.Given cast_co and   ty ~co~> xi, this function returns the  ,(ty |> cast_co) ~return_co~> (xi |> cast_co) of the given v; (which must match the role of the coercion stored in the  argument).Pre-condition: the  passed in is the same as the LHS type of the coercion stored in the .ghc-tcplugin-apiApply casts on both sides of a  (of the given v).Use  when you want to cast both the original and reduced types in a  using the same coercion.Pre-condition: the  passed in is the same as the LHS type of the coercion stored in the .ghc-tcplugin-api Apply one  to another. Combines  and .ghc-tcplugin-apiCreate a function . Combines  and .ghc-tcplugin-api Create a & associated to a  type, from a kind  and a body . Combines  and .ghc-tcplugin-api Create a  of a quantified type from a  of the body. Combines  and k.ghc-tcplugin-api Create a # from a coercion between coercions. Combines  and U.ghc-tcplugin-apiCreate a reflexive  whose RHS is the given , with the specified v.ghc-tcplugin-apiCreate . from individual lists of coercions and types.The lists should be of the same length, and the RHS type of each coercion should match the specified type in the other list.ghc-tcplugin-api Combines  and V.ghc-tcplugin-api TyConAppCo for  s: combines  and .ghc-tcplugin-apiReduce the arguments of a n .ghc-tcplugin-apiObtain  from a list of s by unzipping.ghc-tcplugin-apiGet the reverse of an ghc-tcplugin-apiCast a type by an ghc-tcplugin-apiLike , but with an ghc-tcplugin-apiheterogeneous reductionghc-tcplugin-api kind coercionghc-tcplugin-api desired roleghc-tcplugin-api current roleghc-tcplugin-api original typeghc-tcplugin-apicoercion to cast withghc-tcplugin-api'rewritten type, with rewriting coercionghc-tcplugin-api original typeghc-tcplugin-api!coercion to cast with on the leftghc-tcplugin-api'rewritten type, with rewriting coercionghc-tcplugin-api"coercion to cast with on the rightghc-tcplugin-apimultiplicity reductionghc-tcplugin-apiargument reductionghc-tcplugin-apiresult reductionghc-tcplugin-apikind reductionghc-tcplugin-apibody reductionghc-tcplugin-api!role of the created coercion, "r"ghc-tcplugin-apico :: phi1 ~N phi2ghc-tcplugin-api g1 :: phi1ghc-tcplugin-api g2 :: phi2ghc-tcplugin-apires_co :: g1 ~r g2/ Safe-Inferred '(-?*P ghc-tcplugin-api8The plugin does not rewrite the type family application.ghc-tcplugin-apiThe plugin rewrites the type family application providing a rewriting together with evidence.7The plugin can also emit additional wanted constraints.ghc-tcplugin-api"Result of running a solver plugin.ghc-tcplugin-api*Insoluble constraints found by the plugin.These constraints will be added to the inert set, and reported as insoluble to the user.ghc-tcplugin-api1Solved constraints, together with their evidence.These are removed from the inert set, and the evidence for them is recorded.ghc-tcplugin-api/New constraints that the plugin wishes to emit.%These will be added to the work list.ghc-tcplugin-api&The type-family rewriting environment.ghc-tcplugin-api,The plugin has not found any contradictions,The first field is for constraints that were solved. The second field contains new work, that should be processed by the constraint solver.ghc-tcplugin-apiThe plugin found a contradiction. The returned constraints are removed from the inert set, and recorded as insoluble.7The returned list of constraints should never be empty.ghc-tcplugin-apiEmulate type-family rewriting functionality in a constraint solving plugin, by traversing through all the constraints and rewriting any type-family applications inside them. Safe-Inferred%&')*-1?Aghc-tcplugin-apiUse this type like  to write an error message. This error message can then be thrown at the type-level by the plugin, by emitting a wanted constraint whose predicate is obtained from .A  will still need to be provided in order to inform GHC of the origin of the error (e.g.: which part of the source code should be highlighted?). See .ghc-tcplugin-apiShow the text as is.ghc-tcplugin-apiPretty print the given type.ghc-tcplugin-apiPut two messages side by side.ghc-tcplugin-apiStack two messages vertically.ghc-tcplugin-apiMonads for type-checking plugins which are able to emit new constraints and throw errors.2These operations are supported by the monads that  and ? use; it is not possible to emit work or throw type errors in  or .See  and  - for functions which require this typeclass.ghc-tcplugin-apiA * is essentially a reader monad over GHC's    monad.This means we have both a lift and an unlift operation, similar to  MonadUnliftIO or MonadBaseControl.See for instance , which is an example of function that one would not be able to write using only a lift operation.Note that you must import the internal module in order to access the methods. Please report a bug if you find yourself needing this functionality.ghc-tcplugin-apiLift a computation from GHC's  monad.ghc-tcplugin-apiLift a computation from the    monad.ghc-tcplugin-apiUnlift a computation from the    monad.If this type signature seems confusing, I recommend reading Alexis King's excellent blog post on MonadBaseControl: https://lexi-lambda.github.io/blog/2019/09/07/demystifying-monadbasecontrol/Demystifying MonadBaseControlghc-tcplugin-api?The monad used for a type-checker plugin, parametrised by the  of the plugin.ghc-tcplugin-apiA record containing all the stages necessary for the operation of a type-checking plugin, as defined in this API.Note1: this is not the same record as GHC's built-in    record. Use  for the conversion.To create a type-checking plugin, define something of this type and then call  on the result. This will return something that can be passed to : plugin :: GHC.Plugins.Plugin plugin = GHC.Plugins.defaultPlugin { GHC.Plugins.tcPlugin = \ args -> Just $ GHC.TcPlugin.API.mkTcPlugin ( myTcPlugin args ) } myTcPlugin :: [String] -> GHC.TcPlugin.API.TcPlugin myTcPlugin args = ...ghc-tcplugin-api.Initialise plugin, when entering type-checker.ghc-tcplugin-apiSolve some constraints.This function will be invoked at two points in the constraint solving process: once to manipulate given constraints, and once to solve wanted constraints. In the first case (and only in the first case), no wanted constraints will be passed to the plugin.The plugin can either return a contradiction, or specify that it has solved some constraints (with evidence), and possibly emit additional wanted constraints.Use $ \ _ _ _ -> pure $ TcPluginOK [] [] 5 if your plugin does not provide this functionality.ghc-tcplugin-api+Rewrite saturated type family applications.The plugin is expected to supply a mapping from type family names to rewriting functions. For each type family , the plugin should provide a function which takes in the given constraints and arguments of a saturated type family application, and return a possible rewriting. See + for the expected shape of such a function.Use  const emptyUFM 4 if your plugin does not provide this functionality.ghc-tcplugin-api9Clean up after the plugin, when exiting the type-checker.ghc-tcplugin-apiFor rewriting type family applications, a type-checking plugin provides a function of this type for each type family .The function is provided with the current set of Given constraints, together with the arguments to the type family. The type family application will always be fully saturated.ghc-tcplugin-apiThe solve function of a type-checking plugin takes in Given and Wanted constraints, and should return a   indicating which Wanted constraints it could solve, or whether any are insoluble.ghc-tcplugin-api5Stage of a type-checking plugin, used as a data kind.ghc-tcplugin-apiOnly available in the solver part of the type-checking plugin.ghc-tcplugin-apiAsk for the Derived constraints that the solver was provided with.2Always returns the empty list on GHC 9.4 or above.ghc-tcplugin-api*Ask for the current rewriting environment.Only available in the rewriter part of the type-checking plugin.ghc-tcplugin-apiTake a function whose argument and result types are both within the    monad, and return a function that works within a type-checking plugin monad.Please report a bug if you find yourself needing to use this function.ghc-tcplugin-apiUse this function to create a type-checker plugin to pass to GHC.ghc-tcplugin-api4Create an error type with the desired error message. The result can be paired with a 8 in order to throw a type error, for instance by using .ghc-tcplugin-apiGivensghc-tcplugin-api!Type family arguments (saturated)ghc-tcplugin-apiGivensghc-tcplugin-apiWantedsghc-tcplugin-api.type-checking plugin written with this libraryghc-tcplugin-apitype-checking plugin for GHC+0/.-,+0/.-,56 Safe-Inferred 1?V#ghc-tcplugin-api Package-qualifier after renamingghc-tcplugin-apiNo package qualifierghc-tcplugin-apiImport from home-unitghc-tcplugin-apiImport from another unitghc-tcplugin-apiRun an  computation within the plugin.ghc-tcplugin-api4Output some debugging information within the plugin.ghc-tcplugin-api$Compatibility function to convert a  to Maybe FastString+ on older versions of GHC (9.2 and below).-On newer GHCs, this is the identity function.ghc-tcplugin-api/Lookup a Haskell module from the given package.ghc-tcplugin-apiObtain the full internal , (with its unique identifier, etc) from its .Example usage: +lookupOrig preludeModule ( mkTcOcc "Bool" )This will obtain the  associated with the type .You can then call  to obtain the associated .ghc-tcplugin-apiLookup a type constructor from its name (datatype, type synonym or type family).ghc-tcplugin-api#Lookup a data constructor (such as , , ...) from its name.ghc-tcplugin-api!Lookup a typeclass from its name.ghc-tcplugin-api2Lookup a global typecheckable-thing from its name.ghc-tcplugin-apiLookup a typecheckable-thing available in a local context, such as a local type variable.ghc-tcplugin-api.Lookup an identifier, such as a type variable.ghc-tcplugin-api?Obtain the current global and local type-checking environments.ghc-tcplugin-api3Obtain all currently-reachable typeclass instances.ghc-tcplugin-api:Obtain all currently-reachable data/type family instances.First result: external instances. Second result: instances in the current home package.ghc-tcplugin-api2Ask GHC what a type family application reduces to.Warning$: can cause a loop when used within .ghc-tcplugin-apiCreate a new unique. Useful for generating new variables in the plugin.ghc-tcplugin-apiCreate a new meta-variable (unification variable) of the given kind.ghc-tcplugin-apiQuery whether a type variable is touchable: - is it a unification variable (and not a skolem variable)? - is it actually unifiable given the current )?ghc-tcplugin-apiZonk the given type, which takes the metavariables in the type and substitutes their actual value.ghc-tcplugin-apiZonk a given constraint.ghc-tcplugin-apiCreate a new Wanted constraint.Requires a location (so that error messages can say where the constraint came from, what things were in scope at that point, etc), as well as the actual constraint (encoded as a type).ghc-tcplugin-apiCreate a new Given constraint.Unlike 1, we need to supply evidence for this constraint.ghc-tcplugin-api Obtain the   from a .This can be useful to obtain the location of the constraint currently being rewritten, so that newly emitted constraints can be given the same location information.ghc-tcplugin-api/Set the location information for a computation.ghc-tcplugin-apiUse the  to set the   for a computation.ghc-tcplugin-api!Create a fresh evidence variable.ghc-tcplugin-apiCreate a fresh coercion hole.ghc-tcplugin-apiBind an evidence variable.ghc-tcplugin-apiConjure up a coercion witnessing an equality between two types at the given v (u or s).This amounts to telling GHC "believe me, these things are equal".The plugin is responsible for not emitting any unsound coercions, such as a coercion between  and .ghc-tcplugin-apiConjure up an evidence term for an equality between two types at the given v (u or s).;This can be used to supply a proof of a wanted equality in .The plugin is responsible for not emitting any unsound equalities, such as an equality between  and .ghc-tcplugin-apiProvide a rewriting of a saturated type family application at the given v (u or s).The result can be passed to  to specify the outcome of rewriting a type family application.ghc-tcplugin-api%Text at the top of the debug message.ghc-tcplugin-api%Formatted document to print (use the ' pretty-printing function to obtain an  from any )ghc-tcplugin-apiModule name, e.g.  Data.List.ghc-tcplugin-apiPackage name, e.g.  Just "base". Use Nothing for the current home packageghc-tcplugin-apiName of equality (for the plugin's internal use, or for debugging)ghc-tcplugin-apiLHSghc-tcplugin-apiRHSghc-tcplugin-apiName of equality (for the plugin's internal use, or for debugging)ghc-tcplugin-apiLHSghc-tcplugin-apiRHSghc-tcplugin-api!Name of reduction (for debugging)ghc-tcplugin-apiRole of reduction (u or s)ghc-tcplugin-api Type family ghc-tcplugin-apiType family argumentsghc-tcplugin-api4The type that the type family application reduces to  ! "#$%&'()*+0/.-,1523467BA@?>=<;:98CDIFEHGLKJMNOPQRSTUVWXYZ[\]^ba`_cdefghijklnmopqrvutswxyz{|}~BA@?>=<;:98wzxy{IHGEFN}*+\rqpoUZ#$%" 1~ CMODfeW[(TYSXVPRQdcjikhg]^0/.-,nmLKJl  &)vutsba`_!|523476' Safe-Inferred/012?g ghc-tcplugin-api;A type whose instances are defined generically, using the Generic1 representation.  is a higher-kinded version of  Generically that uses . Wear Named thing -> m ( Wear Resolved thing )ghc-tcplugin-apiThis class exposes the method  which will perform name resolution for all the fields in a datatype.Example usage: we define a record that will hold the things we want to look up, using the  type family. For example: data MyData n = MyData { myClass :: !( Wear n Class ) , myTyCon :: !( Wear n TyCon ) , myDataCon :: !( Wear n DataCon ) , myPromDataCon :: !( Wear n (Promoted DataCon) ) } deriving stock Generic deriving ResolveNames via Generically1 MyDataNow we can specify the names of the things which we want to look up, together with the modules and packages in which they belong: myNames :: MyData Named myNames = MyData { myClass = QualifiedName "MyClass" "My.Module" ( Just "my-pkg-name" ) , ... }Then we can call : resolvedNames :: MonadTcPlugin m => m (MyData Resolved) resolvedNames = resolveNames myNamesThis returns a record containing the looked up things we want, e.g. myClass :: Class, myPromDataCon :: TyCon, etc.ghc-tcplugin-api ?@A@B@C@DEFEGEHEIEJKLMNMOMPMQMRMSTUTVTWTXTYTZT[T\T]T^T_`abcdedfdgdhdidjdkdldmdnopqrqsqtquqvqwqxqyqzq{q|q}q~qqoooo``qqqqqqOPE@@  oooooooo /ghc-tcplugin-api-0.8.2.0-ACodgk6ayHwDAYptpsCx8bGHC.TcPlugin.APIGHC.TcPlugin.API.InternalGHC.TcPlugin.API.Names(GHC.TcPlugin.API.Internal.Shim.ReductionGHC.TcPlugin.API.Internal.ShimGHC.Tc.Types.ConstraintCtLoc setCtLocMemitWorkGHC.TcTcM GHC.Tc.TypesTcPlugin GHC.PluginsPluginGHC.Core.TyConTyConTcPluginSolveResult newWantedghcGHC.Tc.Utils.TcMTypewriteMetaTyVarisFilledMetaTyVar_maybeGHC.Tc.Utils.MonadnewName TcTyThingTcGblEnvHoleDest EvVarDestTcEvDestQCInst CtFlavour ctev_predctev_loc ctev_evar ctev_dest CtEvidenceCtmkNonCanonicalctPredctOriginctLoc ctFlavour ctEvidencectEvExprctEqRelbumpCtLocDepthGHC.Tc.Types.OriginCtOriginGHC.Tc.Types.EvidenceEvExprEvTerm EvBindsVareb_rhseb_lhsEvBind lookupEvBind evDataConApp evCoercionevCastGHC.Core.InstEnvInstEnvsTcLclEnvGHC.Tc.Utils.TcTypeTcTypeTcLevelMetaInfo isSkolemTyVarGHC.Types.TyThing lookupTyCon lookupThinglookupId lookupDataCon MonadThings GHC.Types.Id mkLocalIdGHC.CoreVarTypeCoercionExprCoreExprCoreBndrGHC.Unit.Finder.Types fr_unusablesfr_suggestionsfr_pkgs_hiddenfr_pkgfr_pathsfr_mods_hiddenNotFound NoPackage FoundMultipleFound FindResultGHC.Core.DataCon classDataConGHC.Core.FamInstEnv FamInstEnvGHC.Core.Predicate IrredPred ForAllPredEqPred ClassPredPredReprEqNomEqEqRel mkClassPredclassifyPredTypeGHC.Core.CoercionmkPrimEqPredRole GHC.Core.TypetyConAppTyConPicky_maybe splitAppTyssplitAppTy_maybe mkStrLitTy mkNumLitTy mkCoercionTymkAppTys isTyVarTy isStrLitTy isNumLitTyisCoercionTy_maybegetTyVar_maybeeqTypeOneManyGHC.Core.TyCo.Repch_ref ch_co_var CoercionHolemkVisFunTysManymkVisFunTyMany mkTyVarTys mkTyVarTymkPiTysmkPiTymkInvisFunTysManymkInvisFunTyMany mkForAllTysGHC.Core.ClassFunDep classTyConClassmkUnivCo mkTransComkSymComkReflCoGHC.Core.Coercion.AxiomRepresentationalPhantomNominalRoleGHC.Types.Name.OccurrencemkVarOcc mkTyVarOccmkTcOcc mkDataOccmkClsOcc GHC.Types.VarEvVarCoVarmkTyVarDataConpromoteDataContyConAppTyCon_maybesplitTyConApp_maybe mkTyConTy mkTyConAppmkAppTy isCoercionTyUnivCoProvenancePredTypeMultKind mkForAllTyTyThing MetaDetails isMetaTyVarGHC.Types.Basic UnboxedTupleConstraintTuple BoxedTuple TupleSort NotPromoted IsPromoted PromotionFlagUnboxedBoxedBoxityArity isPromotedTyVarTcTyVarIdGHC.Unit.TypesunitIdFSstringToUnitIdGHC.Unit.Module.Name mkModuleNameGHC.Types.NameNameGHC.Types.SrcLoc RealLocatedLocatedL GenLocatedunLocgetLocGHC.Types.Unique.DFMUniqDFMlookupUDFM_Directly lookupUDFMelemUDFMGHC.Types.Unique.FMUniqFM listToUFMemptyUFMGHC.Types.UniqueUniqueGHC.Utils.PanicpprPanicGHC.Utils.Outputableppr OutputableOccNameGHC.Data.FastString FastStringunpackFSfsLitGHC.Utils.Panic.PlainpanicUnitIdModuleSDoc ModuleName ReductionreductionCoercionreductionReducedTypeTcPluginRewriteResultTcPluginNoRewriteTcPluginRewriteTotcPluginReductiontcRewriterWanteds RewriteEnv TcPluginOkTcPluginContradictionTcPluginErrorMessageTxt PrintType:|::-:MonadTcPluginWork MonadTcPlugin liftTcPluginM unsafeLiftTcMunsafeWithRunInTcM TcPluginM tcPluginInit tcPluginSolvetcPluginRewrite tcPluginStopTcPluginRewriterTcPluginSolver TcPluginStageInitSolveRewriteStop TcPluginStopM tcPluginStopMTcPluginRewriteMtcPluginRewriteMTcPluginSolveMtcPluginSolveM TcPluginInitM tcPluginInitM askEvBinds askDeriveds askRewriteEnvunsafeLiftThroughTcM mkTcPluginmkTcPluginErrorTy$fMonadThingsTcPluginM$fMonadTcPluginTcPluginM$fMonadTcPluginTcPluginM0$fMonadTcPluginTcPluginM1$fMonadTcPluginTcPluginM2$fMonadTcPluginWorkTcPluginM$fMonadTcPluginWorkTcPluginM0$fMonadTcPluginWorkTcPluginM1$fMonadTcPluginWorkTcPluginM2$fFunctorTcPluginM$fApplicativeTcPluginM$fMonadTcPluginM$fFunctorTcPluginM0$fApplicativeTcPluginM0$fMonadTcPluginM0$fFunctorTcPluginM1$fApplicativeTcPluginM1$fMonadTcPluginM1$fFunctorTcPluginM2$fApplicativeTcPluginM2$fMonadTcPluginM2PkgQual NoPkgQualThisPkgOtherPkg tcPluginIO tcPluginTrace pkgQual_pkgfindImportedModule lookupOrig tcLookupTyContcLookupDataCon tcLookupClasstcLookupGlobaltcLookup tcLookupIdgetEnvs getInstEnvsgetFamInstEnvsmatchFam newUnique newFlexiTyVarisTouchableTcPluginM zonkTcTypezonkCtnewGivenrewriteEnvCtLocsetCtLocRewriteMnewEvVarnewCoercionHole setEvBindmkPluginUnivComkPluginUnivEvTermmkTyFamAppReduction$fOutputablePkgQual $fOrdPkgQual $fEqPkgQual Generically1 ResolveNames Lookupable mkOccNamelookupWearPromotedNameResolutionNamedResolved QualifiedName Qualifiednamemodule'package resolveNames$fLookupableTYPEPromoted$fLookupableTYPEClass$fLookupableTYPEDataCon$fLookupableTYPETyCon$fResolveNameab$fGTraversableCcK1K1$fGTraversableCcV1V1$fGTraversableCcU1U1$fGTraversableCcM1M1$fGTraversableCc:+::+:$fGTraversableCc:*::*:$fResolveNamesGenerically1 Reductions unzipRedns mkAppRednsmkTyConAppRedn ReductionR ReductionN HetReductionmkHetReductionhomogeniseHetRedn mkReduction coercionRednreductionOriginalType downgradeRedn mkSubRedn mkTransRedn mkReflRednmkGReflRightRednmkGReflRightMRednmkGReflLeftRednmkGReflLeftMRednmkCoherenceRightRednmkCoherenceRightMRedn mkCastRedn1 mkCastRedn2 mkAppRednmkAppCo mkFunRednmkFunComkFunTy mkForAllRedn mkForAllComkHomoForAllRednmkHomoForAllCosmkProofIrrelRednmkProofIrrelCo mkReflCoRedn mkReductionsmkAppCos mkTyConAppComkClassPredRednmkSymMCo MCoercion mkCastTyMComkCoherenceRightMComkCoherenceRightCoArgsReductionssimplifyArgsWorkermkGReflLeftMComkGReflRightMCo mkTransMCoRtcPluginInsolubleCtstcPluginSolvedCtstcPluginNewCts shimRewriterFEfe_loc fe_flavour fe_eq_relbase GHC.TypeLits ErrorMessageghc-prim GHC.TypesIOBoolTrue GHC.MaybeJustIntFloat GHC.GenericsGeneric ResolveName resolveName UnwearNamed