| Safe Haskell | Safe-Inferred | 
|---|---|
| Language | Haskell2010 | 
GHC.Plugins
Contents
Description
This module is not used by GHC itself. Rather, it exports all of the functions and types you are likely to need when writing a plugin for GHC. So authors of plugins can probably get away simply with saying "import GHC.Plugins".
Particularly interesting modules for plugin writers include GHC.Core and GHC.Core.Opt.Monad.
Synopsis
- module GHC.Driver.Plugins
- module GHC.Types.Name.Reader
- data OccName
- emptyFsEnv :: FastStringEnv a
- extendFsEnv :: FastStringEnv a -> FastString -> a -> FastStringEnv a
- lookupFsEnv :: FastStringEnv a -> FastString -> Maybe a
- mkFsEnv :: [(FastString, a)] -> FastStringEnv a
- type FastStringEnv a = UniqFM FastString a
- alterOccEnv :: (Maybe elt -> Maybe elt) -> OccEnv elt -> OccName -> OccEnv elt
- avoidClashesOccEnv :: TidyOccEnv -> [OccName] -> TidyOccEnv
- clsName :: NameSpace
- dataName :: NameSpace
- delFromOccEnv :: OccEnv a -> OccName -> OccEnv a
- delListFromOccEnv :: OccEnv a -> [OccName] -> OccEnv a
- delTidyOccEnvList :: TidyOccEnv -> [FastString] -> TidyOccEnv
- demoteOccName :: OccName -> Maybe OccName
- elemOccEnv :: OccName -> OccEnv a -> Bool
- elemOccSet :: OccName -> OccSet -> Bool
- emptyOccEnv :: OccEnv a
- emptyOccSet :: OccSet
- emptyTidyOccEnv :: TidyOccEnv
- extendOccEnv :: OccEnv a -> OccName -> a -> OccEnv a
- extendOccEnvList :: OccEnv a -> [(OccName, a)] -> OccEnv a
- extendOccEnv_Acc :: (a -> b -> b) -> (a -> b) -> OccEnv b -> OccName -> a -> OccEnv b
- extendOccEnv_C :: (a -> a -> a) -> OccEnv a -> OccName -> a -> OccEnv a
- extendOccSet :: OccSet -> OccName -> OccSet
- extendOccSetList :: OccSet -> [OccName] -> OccSet
- filterOccEnv :: (elt -> Bool) -> OccEnv elt -> OccEnv elt
- filterOccSet :: (OccName -> Bool) -> OccSet -> OccSet
- foldOccEnv :: (a -> b -> b) -> b -> OccEnv a -> b
- initTidyOccEnv :: [OccName] -> TidyOccEnv
- intersectOccSet :: OccSet -> OccSet -> OccSet
- isDataConNameSpace :: NameSpace -> Bool
- isDataOcc :: OccName -> Bool
- isDataSymOcc :: OccName -> Bool
- isDefaultMethodOcc :: OccName -> Bool
- isDerivedOccName :: OccName -> Bool
- isEmptyOccSet :: OccSet -> Bool
- isSymOcc :: OccName -> Bool
- isTcClsNameSpace :: NameSpace -> Bool
- isTcOcc :: OccName -> Bool
- isTvNameSpace :: NameSpace -> Bool
- isTvOcc :: OccName -> Bool
- isTypeableBindOcc :: OccName -> Bool
- isValNameSpace :: NameSpace -> Bool
- isValOcc :: OccName -> Bool
- isVarNameSpace :: NameSpace -> Bool
- isVarOcc :: OccName -> Bool
- lookupOccEnv :: OccEnv a -> OccName -> Maybe a
- mapOccEnv :: (a -> b) -> OccEnv a -> OccEnv b
- minusOccSet :: OccSet -> OccSet -> OccSet
- mkBuilderOcc :: OccName -> OccName
- mkClassDataConOcc :: OccName -> OccName
- mkClassOpAuxOcc :: OccName -> OccName
- mkClsOcc :: String -> OccName
- mkClsOccFS :: FastString -> OccName
- mkCon2TagOcc :: OccName -> OccName
- mkDFunOcc :: String -> Bool -> OccSet -> OccName
- mkDataCOcc :: OccName -> OccName
- mkDataConWorkerOcc :: OccName -> OccName
- mkDataConWrapperOcc :: OccName -> OccName
- mkDataOcc :: String -> OccName
- mkDataOccFS :: FastString -> OccName
- mkDataTOcc :: OccName -> OccName
- mkDefaultMethodOcc :: OccName -> OccName
- mkDictOcc :: OccName -> OccName
- mkEqPredCoOcc :: OccName -> OccName
- mkForeignExportOcc :: OccName -> OccName
- mkGen1R :: OccName -> OccName
- mkGenR :: OccName -> OccName
- mkIPOcc :: OccName -> OccName
- mkInstTyCoOcc :: OccName -> OccName
- mkInstTyTcOcc :: String -> OccSet -> OccName
- mkLocalOcc :: Unique -> OccName -> OccName
- mkMatcherOcc :: OccName -> OccName
- mkMaxTagOcc :: OccName -> OccName
- mkMethodOcc :: OccName -> OccName
- mkNewTyCoOcc :: OccName -> OccName
- mkOccEnv :: [(OccName, a)] -> OccEnv a
- mkOccEnv_C :: (a -> a -> a) -> [(OccName, a)] -> OccEnv a
- mkOccName :: NameSpace -> String -> OccName
- mkOccNameFS :: NameSpace -> FastString -> OccName
- mkOccSet :: [OccName] -> OccSet
- mkRecFldSelOcc :: String -> OccName
- mkRepEqOcc :: OccName -> OccName
- mkSpecOcc :: OccName -> OccName
- mkSuperDictAuxOcc :: Int -> OccName -> OccName
- mkSuperDictSelOcc :: Int -> OccName -> OccName
- mkTag2ConOcc :: OccName -> OccName
- mkTcOcc :: String -> OccName
- mkTcOccFS :: FastString -> OccName
- mkTyConRepOcc :: OccName -> OccName
- mkTyVarOcc :: String -> OccName
- mkTyVarOccFS :: FastString -> OccName
- mkVarOcc :: String -> OccName
- mkVarOccFS :: FastString -> OccName
- mkWorkerOcc :: OccName -> OccName
- nameSpacesRelated :: NameSpace -> NameSpace -> Bool
- occEnvElts :: OccEnv a -> [a]
- occNameString :: OccName -> String
- parenSymOcc :: OccName -> SDoc -> SDoc
- plusOccEnv :: OccEnv a -> OccEnv a -> OccEnv a
- plusOccEnv_C :: (a -> a -> a) -> OccEnv a -> OccEnv a -> OccEnv a
- pprNameSpace :: NameSpace -> SDoc
- pprNameSpaceBrief :: NameSpace -> SDoc
- pprNonVarNameSpace :: NameSpace -> SDoc
- pprOccEnv :: (a -> SDoc) -> OccEnv a -> SDoc
- pprOccName :: OccName -> SDoc
- setOccNameSpace :: NameSpace -> OccName -> OccName
- srcDataName :: NameSpace
- startsWithUnderscore :: OccName -> Bool
- tcClsName :: NameSpace
- tcName :: NameSpace
- tidyOccName :: TidyOccEnv -> OccName -> (TidyOccEnv, OccName)
- tvName :: NameSpace
- unionManyOccSets :: [OccSet] -> OccSet
- unionOccSets :: OccSet -> OccSet -> OccSet
- unitOccEnv :: OccName -> a -> OccEnv a
- unitOccSet :: OccName -> OccSet
- class HasOccName name where
- data NameSpace
- data OccEnv a
- type OccSet = UniqSet OccName
- type TidyOccEnv = UniqFM FastString Int
- data Name
- data OccName
- emptyFsEnv :: FastStringEnv a
- extendFsEnv :: FastStringEnv a -> FastString -> a -> FastStringEnv a
- lookupFsEnv :: FastStringEnv a -> FastString -> Maybe a
- mkFsEnv :: [(FastString, a)] -> FastStringEnv a
- type FastStringEnv a = UniqFM FastString a
- alterOccEnv :: (Maybe elt -> Maybe elt) -> OccEnv elt -> OccName -> OccEnv elt
- avoidClashesOccEnv :: TidyOccEnv -> [OccName] -> TidyOccEnv
- clsName :: NameSpace
- dataName :: NameSpace
- delFromOccEnv :: OccEnv a -> OccName -> OccEnv a
- delListFromOccEnv :: OccEnv a -> [OccName] -> OccEnv a
- delTidyOccEnvList :: TidyOccEnv -> [FastString] -> TidyOccEnv
- demoteOccName :: OccName -> Maybe OccName
- elemOccEnv :: OccName -> OccEnv a -> Bool
- elemOccSet :: OccName -> OccSet -> Bool
- emptyOccEnv :: OccEnv a
- emptyOccSet :: OccSet
- emptyTidyOccEnv :: TidyOccEnv
- extendOccEnv :: OccEnv a -> OccName -> a -> OccEnv a
- extendOccEnvList :: OccEnv a -> [(OccName, a)] -> OccEnv a
- extendOccEnv_Acc :: (a -> b -> b) -> (a -> b) -> OccEnv b -> OccName -> a -> OccEnv b
- extendOccEnv_C :: (a -> a -> a) -> OccEnv a -> OccName -> a -> OccEnv a
- extendOccSet :: OccSet -> OccName -> OccSet
- extendOccSetList :: OccSet -> [OccName] -> OccSet
- filterOccEnv :: (elt -> Bool) -> OccEnv elt -> OccEnv elt
- filterOccSet :: (OccName -> Bool) -> OccSet -> OccSet
- foldOccEnv :: (a -> b -> b) -> b -> OccEnv a -> b
- initTidyOccEnv :: [OccName] -> TidyOccEnv
- intersectOccSet :: OccSet -> OccSet -> OccSet
- isDataConNameSpace :: NameSpace -> Bool
- isDataOcc :: OccName -> Bool
- isDataSymOcc :: OccName -> Bool
- isDefaultMethodOcc :: OccName -> Bool
- isDerivedOccName :: OccName -> Bool
- isEmptyOccSet :: OccSet -> Bool
- isSymOcc :: OccName -> Bool
- isTcClsNameSpace :: NameSpace -> Bool
- isTcOcc :: OccName -> Bool
- isTvNameSpace :: NameSpace -> Bool
- isTvOcc :: OccName -> Bool
- isTypeableBindOcc :: OccName -> Bool
- isValNameSpace :: NameSpace -> Bool
- isValOcc :: OccName -> Bool
- isVarNameSpace :: NameSpace -> Bool
- isVarOcc :: OccName -> Bool
- lookupOccEnv :: OccEnv a -> OccName -> Maybe a
- mapOccEnv :: (a -> b) -> OccEnv a -> OccEnv b
- minusOccSet :: OccSet -> OccSet -> OccSet
- mkBuilderOcc :: OccName -> OccName
- mkClassDataConOcc :: OccName -> OccName
- mkClassOpAuxOcc :: OccName -> OccName
- mkClsOcc :: String -> OccName
- mkClsOccFS :: FastString -> OccName
- mkCon2TagOcc :: OccName -> OccName
- mkDFunOcc :: String -> Bool -> OccSet -> OccName
- mkDataCOcc :: OccName -> OccName
- mkDataConWorkerOcc :: OccName -> OccName
- mkDataConWrapperOcc :: OccName -> OccName
- mkDataOcc :: String -> OccName
- mkDataOccFS :: FastString -> OccName
- mkDataTOcc :: OccName -> OccName
- mkDefaultMethodOcc :: OccName -> OccName
- mkDictOcc :: OccName -> OccName
- mkEqPredCoOcc :: OccName -> OccName
- mkForeignExportOcc :: OccName -> OccName
- mkGen1R :: OccName -> OccName
- mkGenR :: OccName -> OccName
- mkIPOcc :: OccName -> OccName
- mkInstTyCoOcc :: OccName -> OccName
- mkInstTyTcOcc :: String -> OccSet -> OccName
- mkLocalOcc :: Unique -> OccName -> OccName
- mkMatcherOcc :: OccName -> OccName
- mkMaxTagOcc :: OccName -> OccName
- mkMethodOcc :: OccName -> OccName
- mkNewTyCoOcc :: OccName -> OccName
- mkOccEnv :: [(OccName, a)] -> OccEnv a
- mkOccEnv_C :: (a -> a -> a) -> [(OccName, a)] -> OccEnv a
- mkOccName :: NameSpace -> String -> OccName
- mkOccNameFS :: NameSpace -> FastString -> OccName
- mkOccSet :: [OccName] -> OccSet
- mkRecFldSelOcc :: String -> OccName
- mkRepEqOcc :: OccName -> OccName
- mkSpecOcc :: OccName -> OccName
- mkSuperDictAuxOcc :: Int -> OccName -> OccName
- mkSuperDictSelOcc :: Int -> OccName -> OccName
- mkTag2ConOcc :: OccName -> OccName
- mkTcOcc :: String -> OccName
- mkTcOccFS :: FastString -> OccName
- mkTyConRepOcc :: OccName -> OccName
- mkTyVarOcc :: String -> OccName
- mkTyVarOccFS :: FastString -> OccName
- mkVarOcc :: String -> OccName
- mkVarOccFS :: FastString -> OccName
- mkWorkerOcc :: OccName -> OccName
- nameSpacesRelated :: NameSpace -> NameSpace -> Bool
- occEnvElts :: OccEnv a -> [a]
- occNameString :: OccName -> String
- parenSymOcc :: OccName -> SDoc -> SDoc
- plusOccEnv :: OccEnv a -> OccEnv a -> OccEnv a
- plusOccEnv_C :: (a -> a -> a) -> OccEnv a -> OccEnv a -> OccEnv a
- pprNameSpace :: NameSpace -> SDoc
- pprNameSpaceBrief :: NameSpace -> SDoc
- pprNonVarNameSpace :: NameSpace -> SDoc
- pprOccEnv :: (a -> SDoc) -> OccEnv a -> SDoc
- pprOccName :: OccName -> SDoc
- setOccNameSpace :: NameSpace -> OccName -> OccName
- srcDataName :: NameSpace
- startsWithUnderscore :: OccName -> Bool
- tcClsName :: NameSpace
- tcName :: NameSpace
- tidyOccName :: TidyOccEnv -> OccName -> (TidyOccEnv, OccName)
- tvName :: NameSpace
- unionManyOccSets :: [OccSet] -> OccSet
- unionOccSets :: OccSet -> OccSet -> OccSet
- unitOccEnv :: OccName -> a -> OccEnv a
- unitOccSet :: OccName -> OccSet
- class HasOccName name where
- data NameSpace
- data OccEnv a
- type OccSet = UniqSet OccName
- type TidyOccEnv = UniqFM FastString Int
- getOccFS :: NamedThing a => a -> FastString
- getOccString :: NamedThing a => a -> String
- getSrcLoc :: NamedThing a => a -> SrcLoc
- getSrcSpan :: NamedThing a => a -> SrcSpan
- isBuiltInSyntax :: Name -> Bool
- isDataConName :: Name -> Bool
- isDynLinkName :: Platform -> Module -> Name -> Bool
- isExternalName :: Name -> Bool
- isHoleName :: Name -> Bool
- isInternalName :: Name -> Bool
- isSystemName :: Name -> Bool
- isTyConName :: Name -> Bool
- isTyVarName :: Name -> Bool
- isValName :: Name -> Bool
- isVarName :: Name -> Bool
- isWiredIn :: NamedThing thing => thing -> Bool
- isWiredInName :: Name -> Bool
- localiseName :: Name -> Name
- mkClonedInternalName :: Unique -> Name -> Name
- mkDerivedInternalName :: (OccName -> OccName) -> Unique -> Name -> Name
- mkExternalName :: Unique -> Module -> OccName -> SrcSpan -> Name
- mkFCallName :: Unique -> String -> Name
- mkInternalName :: Unique -> OccName -> SrcSpan -> Name
- mkSysTvName :: Unique -> FastString -> Name
- mkSystemName :: Unique -> OccName -> Name
- mkSystemNameAt :: Unique -> OccName -> SrcSpan -> Name
- mkSystemVarName :: Unique -> FastString -> Name
- mkWiredInName :: Module -> OccName -> Unique -> TyThing -> BuiltInSyntax -> Name
- nameIsFromExternalPackage :: Unit -> Name -> Bool
- nameIsHomePackage :: Module -> Name -> Bool
- nameIsHomePackageImport :: Module -> Name -> Bool
- nameIsLocalOrFrom :: Module -> Name -> Bool
- nameModule :: HasDebugCallStack => Name -> Module
- nameModule_maybe :: Name -> Maybe Module
- nameNameSpace :: Name -> NameSpace
- nameOccName :: Name -> OccName
- nameSrcLoc :: Name -> SrcLoc
- nameSrcSpan :: Name -> SrcSpan
- nameStableString :: Name -> String
- nameUnique :: Name -> Unique
- pprDefinedAt :: Name -> SDoc
- pprInfixName :: (Outputable a, NamedThing a) => a -> SDoc
- pprModulePrefix :: PprStyle -> Module -> OccName -> SDoc
- pprNameDefnLoc :: Name -> SDoc
- pprNameUnqualified :: Name -> SDoc
- pprPrefixName :: NamedThing a => a -> SDoc
- setNameLoc :: Name -> SrcSpan -> Name
- setNameUnique :: Name -> Unique -> Name
- stableNameCmp :: Name -> Name -> Ordering
- tidyNameOcc :: Name -> OccName -> Name
- wiredInNameTyThing_maybe :: Name -> Maybe TyThing
- data BuiltInSyntax
- class NamedThing a where- getOccName :: a -> OccName
- getName :: a -> Name
 
- module GHC.Types.Var
- data Var
- globaliseId :: Id -> Id
- idDetails :: Id -> IdDetails
- idInfo :: HasDebugCallStack => Id -> IdInfo
- isExportedId :: Var -> Bool
- isGlobalId :: Var -> Bool
- isId :: Var -> Bool
- isLocalId :: Var -> Bool
- setIdMult :: Id -> Mult -> Id
- updateIdTypeAndMult :: (Type -> Type) -> Id -> Id
- updateIdTypeAndMultM :: Monad m => (Type -> m Type) -> Id -> m Id
- updateIdTypeButNotMult :: (Type -> Type) -> Id -> Id
- type Id = Var
- type InId = Id
- type InVar = Var
- type JoinId = Id
- type OutId = Id
- type OutVar = Var
- asJoinId :: Id -> JoinArity -> JoinId
- asJoinId_maybe :: Id -> Maybe JoinArity -> Id
- clearOneShotLambda :: Id -> Id
- hasNoBinding :: Id -> Bool
- idArity :: Id -> Arity
- idCafInfo :: Id -> CafInfo
- idCallArity :: Id -> Arity
- idCoreRules :: Id -> [CoreRule]
- idCprInfo :: Id -> CprSig
- idDataCon :: Id -> DataCon
- idDemandInfo :: Id -> Demand
- idFunRepArity :: Id -> RepArity
- idHasRules :: Id -> Bool
- idInlineActivation :: Id -> Activation
- idInlinePragma :: Id -> InlinePragma
- idIsFrom :: Module -> Id -> Bool
- idJoinArity :: JoinId -> JoinArity
- idLFInfo_maybe :: Id -> Maybe LambdaFormInfo
- idMult :: Id -> Mult
- idName :: Id -> Name
- idOccInfo :: Id -> OccInfo
- idOneShotInfo :: Id -> OneShotInfo
- idRuleMatchInfo :: Id -> RuleMatchInfo
- idScaledType :: Id -> Scaled Type
- idSpecialisation :: Id -> RuleInfo
- idStateHackOneShotInfo :: Id -> OneShotInfo
- idStrictness :: Id -> StrictSig
- idType :: Id -> Kind
- idUnfolding :: Id -> Unfolding
- idUnique :: Id -> Unique
- isClassOpId_maybe :: Id -> Maybe Class
- isConLikeId :: Id -> Bool
- isDFunId :: Id -> Bool
- isDataConId_maybe :: Id -> Maybe DataCon
- isDataConRecordSelector :: Id -> Bool
- isDataConWorkId :: Id -> Bool
- isDataConWorkId_maybe :: Id -> Maybe DataCon
- isDataConWrapId :: Id -> Bool
- isDataConWrapId_maybe :: Id -> Maybe DataCon
- isDeadBinder :: Id -> Bool
- isDeadEndId :: Var -> Bool
- isFCallId :: Id -> Bool
- isFCallId_maybe :: Id -> Maybe ForeignCall
- isImplicitId :: Id -> Bool
- isJoinId :: Var -> Bool
- isJoinId_maybe :: Var -> Maybe JoinArity
- isNaughtyRecordSelector :: Id -> Bool
- isNeverLevPolyId :: Id -> Bool
- isOneShotBndr :: Var -> Bool
- isPatSynRecordSelector :: Id -> Bool
- isPrimOpId :: Id -> Bool
- isPrimOpId_maybe :: Id -> Maybe PrimOp
- isProbablyOneShotLambda :: Id -> Bool
- isRecordSelector :: Id -> Bool
- isStateHackType :: Type -> Bool
- isStrictId :: Id -> Bool
- localiseId :: Id -> Id
- maybeModifyIdInfo :: Maybe IdInfo -> Id -> Id
- mkExportedLocalId :: IdDetails -> Name -> Type -> Id
- mkExportedVanillaId :: Name -> Type -> Id
- mkGlobalId :: IdDetails -> Name -> Type -> IdInfo -> Id
- mkLocalCoVar :: Name -> Type -> CoVar
- mkLocalId :: HasDebugCallStack => Name -> Mult -> Type -> Id
- mkLocalIdOrCoVar :: Name -> Mult -> Type -> Id
- mkLocalIdWithInfo :: HasDebugCallStack => Name -> Mult -> Type -> IdInfo -> Id
- mkScaledTemplateLocal :: Int -> Scaled Type -> Id
- mkSysLocal :: FastString -> Unique -> Mult -> Type -> Id
- mkSysLocalM :: MonadUnique m => FastString -> Mult -> Type -> m Id
- mkSysLocalOrCoVar :: FastString -> Unique -> Mult -> Type -> Id
- mkSysLocalOrCoVarM :: MonadUnique m => FastString -> Mult -> Type -> m Id
- mkTemplateLocal :: Int -> Type -> Id
- mkTemplateLocals :: [Type] -> [Id]
- mkTemplateLocalsNum :: Int -> [Type] -> [Id]
- mkUserLocal :: OccName -> Unique -> Mult -> Type -> SrcSpan -> Id
- mkUserLocalOrCoVar :: OccName -> Unique -> Mult -> Type -> SrcSpan -> Id
- mkVanillaGlobal :: Name -> Type -> Id
- mkVanillaGlobalWithInfo :: Name -> Type -> IdInfo -> Id
- mkWorkerId :: Unique -> Id -> Type -> Id
- modifyIdInfo :: HasDebugCallStack => (IdInfo -> IdInfo) -> Id -> Id
- modifyInlinePragma :: Id -> (InlinePragma -> InlinePragma) -> Id
- realIdUnfolding :: Id -> Unfolding
- recordSelectorTyCon :: Id -> RecSelParent
- scaleIdBy :: Mult -> Id -> Id
- scaleVarBy :: Mult -> Var -> Var
- setCaseBndrEvald :: StrictnessMark -> Id -> Id
- setIdArity :: Id -> Arity -> Id
- setIdCafInfo :: Id -> CafInfo -> Id
- setIdCallArity :: Id -> Arity -> Id
- setIdCprInfo :: Id -> CprSig -> Id
- setIdDemandInfo :: Id -> Demand -> Id
- setIdInfo :: Id -> IdInfo -> Id
- setIdLFInfo :: Id -> LambdaFormInfo -> Id
- setIdName :: Id -> Name -> Id
- setIdOccInfo :: Id -> OccInfo -> Id
- setIdOneShotInfo :: Id -> OneShotInfo -> Id
- setIdSpecialisation :: Id -> RuleInfo -> Id
- setIdStrictness :: Id -> StrictSig -> Id
- setIdType :: Id -> Type -> Id
- setIdUnfolding :: Id -> Unfolding -> Id
- setIdUnique :: Id -> Unique -> Id
- setInlineActivation :: Id -> Activation -> Id
- setInlinePragma :: Id -> InlinePragma -> Id
- setOneShotLambda :: Id -> Id
- stateHackOneShot :: OneShotInfo
- transferPolyIdInfo :: Id -> [Var] -> Id -> Id
- typeOneShot :: Type -> OneShotInfo
- updOneShotInfo :: Id -> OneShotInfo -> Id
- zapFragileIdInfo :: Id -> Id
- zapIdDemandInfo :: Id -> Id
- zapIdOccInfo :: Id -> Id
- zapIdStrictness :: Id -> Id
- zapIdTailCallInfo :: Id -> Id
- zapIdUsageEnvInfo :: Id -> Id
- zapIdUsageInfo :: Id -> Id
- zapIdUsedOnceInfo :: Id -> Id
- zapJoinId :: Id -> Id
- zapLamIdInfo :: Id -> Id
- zapStableUnfolding :: Id -> Id
- module GHC.Types.Id.Info
- module GHC.Core.Opt.Monad
- module GHC.Core
- module GHC.Types.Literal
- module GHC.Core.DataCon
- module GHC.Core.Utils
- module GHC.Core.Make
- module GHC.Core.FVs
- data InScopeSet
- extendTCvSubst :: TCvSubst -> TyCoVar -> Type -> TCvSubst
- type TvSubstEnv = TyVarEnv Type
- addInScopeSet :: Subst -> VarSet -> Subst
- cloneBndr :: Subst -> Unique -> Var -> (Subst, Var)
- cloneBndrs :: Subst -> UniqSupply -> [Var] -> (Subst, [Var])
- cloneIdBndr :: Subst -> UniqSupply -> Id -> (Subst, Id)
- cloneIdBndrs :: Subst -> UniqSupply -> [Id] -> (Subst, [Id])
- cloneRecIdBndrs :: Subst -> UniqSupply -> [Id] -> (Subst, [Id])
- deShadowBinds :: CoreProgram -> CoreProgram
- delBndr :: Subst -> Var -> Subst
- delBndrs :: Subst -> [Var] -> Subst
- emptySubst :: Subst
- extendIdSubst :: Subst -> Id -> CoreExpr -> Subst
- extendIdSubstList :: Subst -> [(Id, CoreExpr)] -> Subst
- extendInScope :: Subst -> Var -> Subst
- extendInScopeIds :: Subst -> [Id] -> Subst
- extendInScopeList :: Subst -> [Var] -> Subst
- extendSubst :: Subst -> Var -> CoreArg -> Subst
- extendSubstList :: Subst -> [(Var, CoreArg)] -> Subst
- extendSubstWithVar :: Subst -> Var -> Var -> Subst
- extendTvSubst :: Subst -> TyVar -> Type -> Subst
- extendTvSubstList :: Subst -> [(TyVar, Type)] -> Subst
- getTCvSubst :: Subst -> TCvSubst
- isEmptySubst :: Subst -> Bool
- isInScope :: Var -> Subst -> Bool
- lookupIdSubst :: HasDebugCallStack => Subst -> Id -> CoreExpr
- lookupTCvSubst :: Subst -> TyVar -> Type
- mkEmptySubst :: InScopeSet -> Subst
- mkOpenSubst :: InScopeSet -> [(Var, CoreArg)] -> Subst
- mkSubst :: InScopeSet -> TvSubstEnv -> CvSubstEnv -> IdSubstEnv -> Subst
- setInScope :: Subst -> InScopeSet -> Subst
- substBind :: HasDebugCallStack => Subst -> CoreBind -> (Subst, CoreBind)
- substBindSC :: HasDebugCallStack => Subst -> CoreBind -> (Subst, CoreBind)
- substBndr :: Subst -> Var -> (Subst, Var)
- substBndrs :: Subst -> [Var] -> (Subst, [Var])
- substCo :: HasCallStack => Subst -> Coercion -> Coercion
- substDVarSet :: Subst -> DVarSet -> DVarSet
- substExpr :: HasDebugCallStack => Subst -> CoreExpr -> CoreExpr
- substExprSC :: HasDebugCallStack => Subst -> CoreExpr -> CoreExpr
- substIdInfo :: Subst -> Id -> IdInfo -> Maybe IdInfo
- substIdOcc :: Subst -> Id -> Id
- substIdType :: Subst -> Id -> Id
- substInScope :: Subst -> InScopeSet
- substRecBndrs :: Subst -> [Id] -> (Subst, [Id])
- substRulesForImportedIds :: Subst -> [CoreRule] -> [CoreRule]
- substSpec :: Subst -> Id -> RuleInfo -> RuleInfo
- substTickish :: Subst -> Tickish Id -> Tickish Id
- substTy :: Subst -> Type -> Type
- substUnfolding :: Subst -> Unfolding -> Unfolding
- substUnfoldingSC :: Subst -> Unfolding -> Unfolding
- zapSubstEnv :: Subst -> Subst
- type IdSubstEnv = IdEnv CoreExpr
- data Subst = Subst InScopeSet IdSubstEnv TvSubstEnv CvSubstEnv
- module GHC.Core.Rules
- module GHC.Types.Annotations
- module GHC.Driver.Session
- module GHC.Unit.State
- module GHC.Unit.Module
- data AnonArgFlag
- data ArgFlag where
- type TyVar = Var
- data Var
- mkForAllTy :: TyCoVar -> ArgFlag -> Type -> Type
- type Kind = Type
- type Mult = Type
- type PredType = Type
- data Scaled a
- type ThetaType = [PredType]
- data TyCoBinder
- data TyThing
- data Type
- coreView :: Type -> Maybe Type
- isCoercionTy :: Type -> Bool
- isLiftedTypeKind :: Kind -> Bool
- isMultiplicityTy :: Type -> Bool
- isPredTy :: HasDebugCallStack => Type -> Bool
- isRuntimeRepTy :: Type -> Bool
- mkAppTy :: Type -> Type -> Type
- mkCastTy :: Type -> Coercion -> Type
- partitionInvisibleTypes :: TyCon -> [Type] -> ([Type], [Type])
- piResultTy :: HasDebugCallStack => Type -> Type -> Type
- splitTyConApp_maybe :: HasDebugCallStack => Type -> Maybe (TyCon, [Type])
- tcView :: Type -> Maybe Type
- tyConAppTyCon_maybe :: Type -> Maybe TyCon
- liftedTypeKind :: Kind
- unrestrictedFunTyCon :: TyCon
- binderArgFlag :: VarBndr tv argf -> argf
- binderType :: VarBndr TyCoVar argf -> Type
- binderVar :: VarBndr tv argf -> tv
- binderVars :: [VarBndr tv argf] -> [tv]
- isInvisibleArgFlag :: ArgFlag -> Bool
- isTyVar :: Var -> Bool
- isVisibleArgFlag :: ArgFlag -> Bool
- mkTyCoVarBinder :: vis -> TyCoVar -> VarBndr TyCoVar vis
- mkTyCoVarBinders :: vis -> [TyCoVar] -> [VarBndr TyCoVar vis]
- mkTyVarBinder :: vis -> TyVar -> VarBndr TyVar vis
- mkTyVarBinders :: vis -> [TyVar] -> [VarBndr TyVar vis]
- sameVis :: ArgFlag -> ArgFlag -> Bool
- tyVarKind :: TyVar -> Kind
- tyVarSpecToBinders :: [VarBndr a Specificity] -> [VarBndr a ArgFlag]
- data Specificity
- type TyCoVar = Id
- type TyCoVarBinder = VarBndr TyCoVar ArgFlag
- type TyVarBinder = VarBndr TyVar ArgFlag
- isConstraintKindCon :: TyCon -> Bool
- foldTyCo :: Monoid a => TyCoFolder env a -> env -> (Type -> a, [Type] -> a, Coercion -> a, [Coercion] -> a)
- isInvisibleBinder :: TyCoBinder -> Bool
- isNamedBinder :: TyCoBinder -> Bool
- isVisibleBinder :: TyCoBinder -> Bool
- mkForAllTys :: [TyCoVarBinder] -> Type -> Type
- mkInvisForAllTys :: [InvisTVBinder] -> Type -> Type
- mkInvisFunTy :: Mult -> Type -> Type -> Type
- mkInvisFunTyMany :: Type -> Type -> Type
- mkInvisFunTysMany :: [Type] -> Type -> Type
- mkPiTy :: TyCoBinder -> Type -> Type
- mkPiTys :: [TyCoBinder] -> Type -> Type
- mkTyConApp :: TyCon -> [Type] -> Type
- mkTyConTy :: TyCon -> Type
- mkTyVarTy :: TyVar -> Type
- mkTyVarTys :: [TyVar] -> [Type]
- mkVisFunTy :: Mult -> Type -> Type -> Type
- mkVisFunTyMany :: Type -> Type -> Type
- mkVisFunTys :: [Scaled Type] -> Type -> Type
- mkVisFunTysMany :: [Type] -> Type -> Type
- typeSize :: Type -> Int
- type KindOrType = Type
- type KnotTied ty = ty
- data TyCoFolder env a = TyCoFolder {}
- closeOverKinds :: TyCoVarSet -> TyCoVarSet
- closeOverKindsDSet :: DTyVarSet -> DTyVarSet
- closeOverKindsList :: [TyVar] -> [TyVar]
- coVarsOfType :: Type -> CoVarSet
- coVarsOfTypes :: [Type] -> CoVarSet
- noFreeVarsOfType :: Type -> Bool
- scopedSort :: [TyCoVar] -> [TyCoVar]
- tyCoFVsBndr :: TyCoVarBinder -> FV -> FV
- tyCoFVsOfType :: Type -> FV
- tyCoFVsVarBndr :: Var -> FV -> FV
- tyCoFVsVarBndrs :: [Var] -> FV -> FV
- tyCoVarsOfType :: Type -> TyCoVarSet
- tyCoVarsOfTypeDSet :: Type -> DTyCoVarSet
- tyCoVarsOfTypeWellScoped :: Type -> [TyVar]
- tyCoVarsOfTypes :: [Type] -> TyCoVarSet
- tyCoVarsOfTypesWellScoped :: [Type] -> [TyVar]
- tidyFreeTyCoVars :: TidyEnv -> [TyCoVar] -> TidyEnv
- tidyKind :: TidyEnv -> Kind -> Kind
- tidyOpenKind :: TidyEnv -> Kind -> (TidyEnv, Kind)
- tidyOpenTyCoVar :: TidyEnv -> TyCoVar -> (TidyEnv, TyCoVar)
- tidyOpenTyCoVars :: TidyEnv -> [TyCoVar] -> (TidyEnv, [TyCoVar])
- tidyOpenType :: TidyEnv -> Type -> (TidyEnv, Type)
- tidyOpenTypes :: TidyEnv -> [Type] -> (TidyEnv, [Type])
- tidyTopType :: Type -> Type
- tidyTyCoVarBinder :: TidyEnv -> VarBndr TyCoVar vis -> (TidyEnv, VarBndr TyCoVar vis)
- tidyTyCoVarBinders :: TidyEnv -> [VarBndr TyCoVar vis] -> (TidyEnv, [VarBndr TyCoVar vis])
- tidyTyCoVarOcc :: TidyEnv -> TyCoVar -> TyCoVar
- tidyType :: TidyEnv -> Type -> Type
- tidyTypes :: TidyEnv -> [Type] -> [Type]
- tidyVarBndr :: TidyEnv -> TyCoVar -> (TidyEnv, TyCoVar)
- tidyVarBndrs :: TidyEnv -> [TyCoVar] -> (TidyEnv, [TyCoVar])
- cloneTyVarBndr :: TCvSubst -> TyVar -> Unique -> (TCvSubst, TyVar)
- cloneTyVarBndrs :: TCvSubst -> [TyVar] -> UniqSupply -> (TCvSubst, [TyVar])
- composeTCvSubst :: TCvSubst -> TCvSubst -> TCvSubst
- composeTCvSubstEnv :: InScopeSet -> (TvSubstEnv, CvSubstEnv) -> (TvSubstEnv, CvSubstEnv) -> (TvSubstEnv, CvSubstEnv)
- emptyTCvSubst :: TCvSubst
- emptyTvSubstEnv :: TvSubstEnv
- extendCvSubst :: TCvSubst -> CoVar -> Coercion -> TCvSubst
- extendTCvInScope :: TCvSubst -> Var -> TCvSubst
- extendTCvInScopeList :: TCvSubst -> [Var] -> TCvSubst
- extendTCvInScopeSet :: TCvSubst -> VarSet -> TCvSubst
- extendTCvSubst :: TCvSubst -> TyCoVar -> Type -> TCvSubst
- extendTCvSubstList :: TCvSubst -> [Var] -> [Type] -> TCvSubst
- extendTCvSubstWithClone :: TCvSubst -> TyCoVar -> TyCoVar -> TCvSubst
- extendTvSubstAndInScope :: TCvSubst -> TyVar -> Type -> TCvSubst
- extendTvSubstBinderAndInScope :: TCvSubst -> TyCoBinder -> Type -> TCvSubst
- extendTvSubstWithClone :: TCvSubst -> TyVar -> TyVar -> TCvSubst
- getTCvInScope :: TCvSubst -> InScopeSet
- getTCvSubstRangeFVs :: TCvSubst -> VarSet
- getTvSubstEnv :: TCvSubst -> TvSubstEnv
- isEmptyTCvSubst :: TCvSubst -> Bool
- lookupTyVar :: TCvSubst -> TyVar -> Maybe Type
- mkEmptyTCvSubst :: InScopeSet -> TCvSubst
- mkTCvSubst :: InScopeSet -> (TvSubstEnv, CvSubstEnv) -> TCvSubst
- mkTvSubstPrs :: [(TyVar, Type)] -> TCvSubst
- notElemTCvSubst :: Var -> TCvSubst -> Bool
- setTvSubstEnv :: TCvSubst -> TvSubstEnv -> TCvSubst
- substCoUnchecked :: TCvSubst -> Coercion -> Coercion
- substCoWithUnchecked :: [TyVar] -> [Type] -> Coercion -> Coercion
- substScaledTy :: HasCallStack => TCvSubst -> Scaled Type -> Scaled Type
- substScaledTyUnchecked :: HasCallStack => TCvSubst -> Scaled Type -> Scaled Type
- substScaledTys :: HasCallStack => TCvSubst -> [Scaled Type] -> [Scaled Type]
- substScaledTysUnchecked :: TCvSubst -> [Scaled Type] -> [Scaled Type]
- substTheta :: HasCallStack => TCvSubst -> ThetaType -> ThetaType
- substThetaUnchecked :: TCvSubst -> ThetaType -> ThetaType
- substTyAddInScope :: TCvSubst -> Type -> Type
- substTyUnchecked :: TCvSubst -> Type -> Type
- substTyVar :: TCvSubst -> TyVar -> Type
- substTyVarBndr :: HasCallStack => TCvSubst -> TyVar -> (TCvSubst, TyVar)
- substTyVarBndrs :: HasCallStack => TCvSubst -> [TyVar] -> (TCvSubst, [TyVar])
- substTyVars :: TCvSubst -> [TyVar] -> [Type]
- substTyWith :: HasCallStack => [TyVar] -> [Type] -> Type -> Type
- substTyWithUnchecked :: [TyVar] -> [Type] -> Type -> Type
- substTys :: HasCallStack => TCvSubst -> [Type] -> [Type]
- substTysUnchecked :: TCvSubst -> [Type] -> [Type]
- substTysWith :: [TyVar] -> [Type] -> [Type] -> [Type]
- substVarBndr :: HasCallStack => TCvSubst -> TyCoVar -> (TCvSubst, TyCoVar)
- substVarBndrs :: HasCallStack => TCvSubst -> [TyCoVar] -> (TCvSubst, [TyCoVar])
- unionTCvSubst :: TCvSubst -> TCvSubst -> TCvSubst
- zapTCvSubst :: TCvSubst -> TCvSubst
- zipCoEnv :: HasDebugCallStack => [CoVar] -> [Coercion] -> CvSubstEnv
- zipTCvSubst :: HasDebugCallStack => [TyCoVar] -> [Type] -> TCvSubst
- zipTvSubst :: HasDebugCallStack => [TyVar] -> [Type] -> TCvSubst
- zipTyEnv :: HasDebugCallStack => [TyVar] -> [Type] -> TvSubstEnv
- data TCvSubst = TCvSubst InScopeSet TvSubstEnv CvSubstEnv
- type TvSubstEnv = TyVarEnv Type
- funTyCon :: TyCon
- pattern Many :: Mult
- pattern One :: Mult
- appTyArgFlags :: Type -> [Type] -> [ArgFlag]
- applyTysX :: [TyVar] -> Type -> [Type] -> Type
- binderRelevantType_maybe :: TyCoBinder -> Maybe Type
- buildSynTyCon :: Name -> [KnotTied TyConBinder] -> Kind -> [Role] -> KnotTied Type -> TyCon
- classifiesTypeWithValues :: Kind -> Bool
- coAxNthLHS :: CoAxiom br -> Int -> Type
- dropForAlls :: Type -> Type
- dropRuntimeRepArgs :: [Type] -> [Type]
- eqType :: Type -> Type -> Bool
- eqTypeX :: RnEnv2 -> Type -> Type -> Bool
- eqTypes :: [Type] -> [Type] -> Bool
- eqVarBndrs :: RnEnv2 -> [Var] -> [Var] -> Maybe RnEnv2
- expandTypeSynonyms :: Type -> Type
- filterOutInferredTypes :: TyCon -> [Type] -> [Type]
- filterOutInvisibleTypes :: TyCon -> [Type] -> [Type]
- funArgTy :: Type -> Type
- funResultTy :: Type -> Type
- getCastedTyVar_maybe :: Type -> Maybe (TyVar, CoercionN)
- getRuntimeRep :: HasDebugCallStack => Type -> Type
- getRuntimeRep_maybe :: HasDebugCallStack => Type -> Maybe Type
- getTyVar :: String -> Type -> TyVar
- getTyVar_maybe :: Type -> Maybe TyVar
- invisibleTyBndrCount :: Type -> Int
- irrelevantMult :: Scaled a -> a
- isAlgType :: Type -> Bool
- isAnonTyCoBinder :: TyCoBinder -> Bool
- isAtomicTy :: Type -> Bool
- isCoVarType :: Type -> Bool
- isCoercionTy_maybe :: Type -> Maybe Coercion
- isDataFamilyAppType :: Type -> Bool
- isFamFreeTy :: Type -> Bool
- isForAllTy :: Type -> Bool
- isForAllTy_co :: Type -> Bool
- isForAllTy_ty :: Type -> Bool
- isFunTy :: Type -> Bool
- isKindLevPoly :: Kind -> Bool
- isLiftedRuntimeRep :: Type -> Bool
- isLiftedType_maybe :: HasDebugCallStack => Type -> Maybe Bool
- isLinearType :: Type -> Bool
- isLitTy :: Type -> Maybe TyLit
- isManyDataConTy :: Mult -> Bool
- isMultiplicityVar :: TyVar -> Bool
- isNumLitTy :: Type -> Maybe Integer
- isOneDataConTy :: Mult -> Bool
- isPiTy :: Type -> Bool
- isPrimitiveType :: Type -> Bool
- isRuntimeRepKindedTy :: Type -> Bool
- isRuntimeRepVar :: TyVar -> Bool
- isStrLitTy :: Type -> Maybe FastString
- isStrictType :: HasDebugCallStack => Type -> Bool
- isTauTy :: Type -> Bool
- isTyVarTy :: Type -> Bool
- isTypeLevPoly :: Type -> Bool
- isUnboxedSumType :: Type -> Bool
- isUnboxedTupleType :: Type -> Bool
- isUnliftedRuntimeRep :: Type -> Bool
- isUnliftedType :: HasDebugCallStack => Type -> Bool
- isUnliftedTypeKind :: Kind -> Bool
- isValidJoinPointType :: JoinArity -> Type -> Bool
- kindRep :: HasDebugCallStack => Kind -> Type
- kindRep_maybe :: HasDebugCallStack => Kind -> Maybe Type
- linear :: a -> Scaled a
- mapTyCo :: Monad m => TyCoMapper () m -> (Type -> m Type, [Type] -> m [Type], Coercion -> m Coercion, [Coercion] -> m [Coercion])
- mapTyCoX :: Monad m => TyCoMapper env m -> (env -> Type -> m Type, env -> [Type] -> m [Type], env -> Coercion -> m Coercion, env -> [Coercion] -> m [Coercion])
- mightBeUnliftedType :: Type -> Bool
- mkAnonBinder :: AnonArgFlag -> Scaled Type -> TyCoBinder
- mkAppTys :: Type -> [Type] -> Type
- mkCoercionTy :: Coercion -> Type
- mkFamilyTyConApp :: TyCon -> [Type] -> Type
- mkInfForAllTy :: TyVar -> Type -> Type
- mkInfForAllTys :: [TyVar] -> Type -> Type
- mkNumLitTy :: Integer -> Type
- mkScaled :: Mult -> a -> Scaled a
- mkSpecForAllTy :: TyVar -> Type -> Type
- mkSpecForAllTys :: [TyVar] -> Type -> Type
- mkStrLitTy :: FastString -> Type
- mkTyCoInvForAllTy :: TyCoVar -> Type -> Type
- mkTyCoInvForAllTys :: [TyCoVar] -> Type -> Type
- mkTyConBindersPreferAnon :: [TyVar] -> TyCoVarSet -> [TyConBinder]
- mkVisForAllTys :: [TyVar] -> Type -> Type
- newTyConInstRhs :: TyCon -> [Type] -> Type
- nonDetCmpTc :: TyCon -> TyCon -> Ordering
- nonDetCmpType :: Type -> Type -> Ordering
- nonDetCmpTypeX :: RnEnv2 -> Type -> Type -> Ordering
- nonDetCmpTypes :: [Type] -> [Type] -> Ordering
- nonDetCmpTypesX :: RnEnv2 -> [Type] -> [Type] -> Ordering
- occCheckExpand :: [Var] -> Type -> Maybe Type
- partitionInvisibles :: [(a, ArgFlag)] -> ([a], [a])
- piResultTys :: HasDebugCallStack => Type -> [Type] -> Type
- pprUserTypeErrorTy :: Type -> SDoc
- repGetTyVar_maybe :: Type -> Maybe TyVar
- repSplitAppTy_maybe :: HasDebugCallStack => Type -> Maybe (Type, Type)
- repSplitAppTys :: HasDebugCallStack => Type -> (Type, [Type])
- repSplitTyConApp_maybe :: HasDebugCallStack => Type -> Maybe (TyCon, [Type])
- resultIsLevPoly :: Type -> Bool
- scaledSet :: Scaled a -> b -> Scaled b
- seqType :: Type -> ()
- seqTypes :: [Type] -> ()
- splitAppTy :: Type -> (Type, Type)
- splitAppTy_maybe :: Type -> Maybe (Type, Type)
- splitAppTys :: Type -> (Type, [Type])
- splitCastTy_maybe :: Type -> Maybe (Type, Coercion)
- splitForAllTy :: Type -> (TyCoVar, Type)
- splitForAllTy_co_maybe :: Type -> Maybe (TyCoVar, Type)
- splitForAllTy_maybe :: Type -> Maybe (TyCoVar, Type)
- splitForAllTy_ty_maybe :: Type -> Maybe (TyCoVar, Type)
- splitForAllTys :: Type -> ([TyCoVar], Type)
- splitForAllTysInvis :: Type -> ([InvisTVBinder], Type)
- splitForAllTysReq :: Type -> ([ReqTVBinder], Type)
- splitForAllVarBndrs :: Type -> ([TyCoVarBinder], Type)
- splitFunTy :: Type -> (Type, Type, Type)
- splitFunTy_maybe :: Type -> Maybe (Type, Type, Type)
- splitFunTys :: Type -> ([Scaled Type], Type)
- splitListTyConApp_maybe :: Type -> Maybe Type
- splitPiTy :: Type -> (TyCoBinder, Type)
- splitPiTy_maybe :: Type -> Maybe (TyCoBinder, Type)
- splitPiTys :: Type -> ([TyCoBinder], Type)
- splitPiTysInvisible :: Type -> ([TyCoBinder], Type)
- splitPiTysInvisibleN :: Int -> Type -> ([TyCoBinder], Type)
- splitTyConApp :: Type -> (TyCon, [Type])
- splitVisVarsOfType :: Type -> Pair TyCoVarSet
- splitVisVarsOfTypes :: [Type] -> Pair TyCoVarSet
- stripCoercionTy :: Type -> Coercion
- synTyConResKind :: TyCon -> Kind
- tcIsConstraintKind :: Kind -> Bool
- tcIsLiftedTypeKind :: Kind -> Bool
- tcIsRuntimeTypeKind :: Kind -> Bool
- tcRepSplitAppTy_maybe :: Type -> Maybe (Type, Type)
- tcReturnsConstraintKind :: Kind -> Bool
- tcSplitTyConApp_maybe :: HasCallStack => Type -> Maybe (TyCon, [Type])
- tcTypeKind :: HasDebugCallStack => Type -> Kind
- tyBinderType :: TyBinder -> Type
- tyCoBinderType :: TyCoBinder -> Type
- tyCoBinderVar_maybe :: TyCoBinder -> Maybe TyCoVar
- tyConAppArgN :: Int -> Type -> Type
- tyConAppArgs :: Type -> [Type]
- tyConAppArgs_maybe :: Type -> Maybe [Type]
- tyConAppNeedsKindSig :: Bool -> TyCon -> Int -> Bool
- tyConAppTyCon :: Type -> TyCon
- tyConAppTyConPicky_maybe :: Type -> Maybe TyCon
- tyConArgFlags :: TyCon -> [Type] -> [ArgFlag]
- tyConBindersTyCoBinders :: [TyConBinder] -> [TyCoBinder]
- tyConsOfType :: Type -> UniqSet TyCon
- tymult :: a -> Scaled a
- typeKind :: HasDebugCallStack => Type -> Kind
- unrestricted :: a -> Scaled a
- userTypeError_maybe :: Type -> Maybe Type
- data TyCoMapper env m = TyCoMapper {}
- module GHC.Core.TyCon
- data Var
- pickLR :: LeftOrRight -> (a, a) -> a
- data LeftOrRight
- data Coercion
- type CoercionN = Coercion
- data MCoercion
- data UnivCoProvenance
- pprCo :: Coercion -> SDoc
- isCoVar :: Var -> Bool
- mkCoVar :: Name -> Type -> CoVar
- type CoVar = Id
- type TyCoVar = Id
- data Role
- coVarKindsTypesRole :: HasDebugCallStack => CoVar -> (Kind, Kind, Type, Type, Role)
- coVarRole :: CoVar -> Role
- coercionKind :: Coercion -> Pair Type
- coercionLKind :: Coercion -> Type
- coercionRKind :: Coercion -> Type
- coercionType :: Coercion -> Type
- decomposePiCos :: HasDebugCallStack => CoercionN -> Pair Type -> [Type] -> ([CoercionN], CoercionN)
- isGReflCo :: Coercion -> Bool
- isReflCo :: Coercion -> Bool
- isReflexiveCo :: Coercion -> Bool
- liftCoSubst :: HasDebugCallStack => Role -> LiftingContext -> Type -> Coercion
- mkAppCo :: Coercion -> Coercion -> Coercion
- mkAxiomInstCo :: CoAxiom Branched -> BranchIndex -> [Coercion] -> Coercion
- mkAxiomRuleCo :: CoAxiomRule -> [Coercion] -> Coercion
- mkCoVarCo :: CoVar -> Coercion
- mkCoercionType :: Role -> Type -> Type -> Type
- mkForAllCo :: TyCoVar -> CoercionN -> Coercion -> Coercion
- mkFunCo :: Role -> CoercionN -> Coercion -> Coercion -> Coercion
- mkGReflCo :: Role -> Type -> MCoercionN -> Coercion
- mkInstCo :: Coercion -> Coercion -> Coercion
- mkKindCo :: Coercion -> Coercion
- mkLRCo :: LeftOrRight -> Coercion -> Coercion
- mkNomReflCo :: Type -> Coercion
- mkNthCo :: HasDebugCallStack => Role -> Int -> Coercion -> Coercion
- mkPhantomCo :: Coercion -> Type -> Type -> Coercion
- mkProofIrrelCo :: Role -> Coercion -> Coercion -> Coercion -> Coercion
- mkReflCo :: Role -> Type -> Coercion
- mkSubCo :: Coercion -> Coercion
- mkSymCo :: Coercion -> Coercion
- mkTransCo :: Coercion -> Coercion -> Coercion
- mkTyConAppCo :: HasDebugCallStack => Role -> TyCon -> [Coercion] -> Coercion
- mkUnivCo :: UnivCoProvenance -> Role -> Type -> Type -> Coercion
- seqCo :: Coercion -> ()
- data LiftingContext = LC TCvSubst LiftCoEnv
- coHoleCoVar :: CoercionHole -> CoVar
- coercionSize :: Coercion -> Int
- setCoHoleCoVar :: CoercionHole -> CoVar -> CoercionHole
- data BlockSubstFlag
- data CoercionHole = CoercionHole {- ch_co_var :: CoVar
- ch_blocker :: BlockSubstFlag
- ch_ref :: IORef (Maybe Coercion)
 
- type CoercionP = Coercion
- type CoercionR = Coercion
- type MCoercionR = MCoercion
- coVarsOfCo :: Coercion -> CoVarSet
- tyCoFVsOfCo :: Coercion -> FV
- tyCoFVsOfCos :: [Coercion] -> FV
- tyCoVarsOfCo :: Coercion -> TyCoVarSet
- tyCoVarsOfCoDSet :: Coercion -> DTyCoVarSet
- tyCoVarsOfCos :: [Coercion] -> TyCoVarSet
- tidyCo :: TidyEnv -> Coercion -> Coercion
- tidyCos :: TidyEnv -> [Coercion] -> [Coercion]
- emptyCvSubstEnv :: CvSubstEnv
- extendTvSubstAndInScope :: TCvSubst -> TyVar -> Type -> TCvSubst
- getCvSubstEnv :: TCvSubst -> CvSubstEnv
- lookupCoVar :: TCvSubst -> Var -> Maybe Coercion
- substCoVar :: TCvSubst -> CoVar -> Coercion
- substCoVarBndr :: HasCallStack => TCvSubst -> CoVar -> (TCvSubst, CoVar)
- substCoVars :: TCvSubst -> [CoVar] -> [Coercion]
- substCoWith :: HasCallStack => [TyVar] -> [Type] -> Coercion -> Coercion
- substCos :: HasCallStack => TCvSubst -> [Coercion] -> [Coercion]
- type CvSubstEnv = CoVarEnv Coercion
- pprParendCo :: Coercion -> SDoc
- badCoercionHole :: Type -> Bool
- badCoercionHoleCo :: Coercion -> Bool
- buildCoercion :: Type -> Type -> CoercionN
- castCoercionKind :: Coercion -> CoercionN -> CoercionN -> Coercion
- castCoercionKind1 :: Coercion -> Role -> Type -> Type -> CoercionN -> Coercion
- castCoercionKind2 :: Coercion -> Role -> Type -> Type -> CoercionN -> CoercionN -> Coercion
- coToMCo :: Coercion -> MCoercion
- coVarKind :: CoVar -> Type
- coVarName :: CoVar -> Name
- coVarTypes :: HasDebugCallStack => CoVar -> Pair Type
- coercionKindRole :: Coercion -> (Pair Type, Role)
- coercionKinds :: [Coercion] -> Pair [Type]
- coercionRole :: Coercion -> Role
- composeSteppers :: NormaliseStepper ev -> NormaliseStepper ev -> NormaliseStepper ev
- decomposeCo :: Arity -> Coercion -> [Role] -> [Coercion]
- decomposeFunCo :: HasDebugCallStack => Role -> Coercion -> (CoercionN, Coercion, Coercion)
- downgradeRole :: Role -> Role -> Coercion -> Coercion
- emptyLiftingContext :: InScopeSet -> LiftingContext
- eqCoercion :: Coercion -> Coercion -> Bool
- eqCoercionX :: RnEnv2 -> Coercion -> Coercion -> Bool
- etaExpandCoAxBranch :: CoAxBranch -> ([TyVar], [Type], Type)
- extendLiftingContext :: LiftingContext -> TyCoVar -> Coercion -> LiftingContext
- extendLiftingContextAndInScope :: LiftingContext -> TyCoVar -> Coercion -> LiftingContext
- getCoVar_maybe :: Coercion -> Maybe CoVar
- instNewTyCon_maybe :: TyCon -> [Type] -> Maybe (Type, Coercion)
- isCoVar_maybe :: Coercion -> Maybe CoVar
- isGReflCo_maybe :: Coercion -> Maybe (Type, Role)
- isGReflMCo :: MCoercion -> Bool
- isMappedByLC :: TyCoVar -> LiftingContext -> Bool
- isReflCoVar_maybe :: Var -> Maybe Coercion
- isReflCo_maybe :: Coercion -> Maybe (Type, Role)
- isReflexiveCo_maybe :: Coercion -> Maybe (Type, Role)
- lcInScopeSet :: LiftingContext -> InScopeSet
- lcSubstLeft :: LiftingContext -> TCvSubst
- lcSubstRight :: LiftingContext -> TCvSubst
- lcTCvSubst :: LiftingContext -> TCvSubst
- liftCoSubstTyVar :: LiftingContext -> Role -> TyVar -> Maybe Coercion
- liftCoSubstVarBndrUsing :: (LiftingContext -> Type -> (CoercionN, a)) -> LiftingContext -> TyCoVar -> (LiftingContext, TyCoVar, CoercionN, a)
- liftCoSubstWith :: Role -> [TyCoVar] -> [Coercion] -> Type -> Coercion
- liftCoSubstWithEx :: Role -> [TyVar] -> [Coercion] -> [TyCoVar] -> [Type] -> (Type -> Coercion, [Type])
- liftEnvSubstLeft :: TCvSubst -> LiftCoEnv -> TCvSubst
- liftEnvSubstRight :: TCvSubst -> LiftCoEnv -> TCvSubst
- ltRole :: Role -> Role -> Bool
- mapStepResult :: (ev1 -> ev2) -> NormaliseStepResult ev1 -> NormaliseStepResult ev2
- mkAppCos :: Coercion -> [Coercion] -> Coercion
- mkAxInstCo :: Role -> CoAxiom br -> BranchIndex -> [Type] -> [Coercion] -> Coercion
- mkAxInstLHS :: CoAxiom br -> BranchIndex -> [Type] -> [Coercion] -> Type
- mkAxInstRHS :: CoAxiom br -> BranchIndex -> [Type] -> [Coercion] -> Type
- mkCoCast :: Coercion -> CoercionR -> Coercion
- mkCoVarCos :: [CoVar] -> [Coercion]
- mkCoherenceLeftCo :: Role -> Type -> CoercionN -> Coercion -> Coercion
- mkCoherenceRightCo :: Role -> Type -> CoercionN -> Coercion -> Coercion
- mkFamilyTyConAppCo :: TyCon -> [CoercionN] -> CoercionN
- mkForAllCos :: [(TyCoVar, CoercionN)] -> Coercion -> Coercion
- mkGReflLeftCo :: Role -> Type -> CoercionN -> Coercion
- mkGReflRightCo :: Role -> Type -> CoercionN -> Coercion
- mkHeteroCoercionType :: Role -> Kind -> Kind -> Type -> Type -> Type
- mkHeteroPrimEqPred :: Kind -> Kind -> Type -> Type -> Type
- mkHeteroReprPrimEqPred :: Kind -> Kind -> Type -> Type -> Type
- mkHoleCo :: CoercionHole -> Coercion
- mkHomoForAllCos :: [TyCoVar] -> Coercion -> Coercion
- mkPiCo :: Role -> Var -> Coercion -> Coercion
- mkPiCos :: Role -> [Var] -> Coercion -> Coercion
- mkPrimEqPred :: Type -> Type -> Type
- mkPrimEqPredRole :: Role -> Type -> Type -> PredType
- mkRepReflCo :: Type -> Coercion
- mkReprPrimEqPred :: Type -> Type -> Type
- mkSubstLiftingContext :: TCvSubst -> LiftingContext
- mkTransMCo :: MCoercion -> MCoercion -> MCoercion
- mkUnbranchedAxInstCo :: Role -> CoAxiom Unbranched -> [Type] -> [Coercion] -> Coercion
- mkUnbranchedAxInstLHS :: CoAxiom Unbranched -> [Type] -> [Coercion] -> Type
- mkUnbranchedAxInstRHS :: CoAxiom Unbranched -> [Type] -> [Coercion] -> Type
- multToCo :: Mult -> Coercion
- nthCoRole :: Int -> Coercion -> Role
- nthRole :: Role -> TyCon -> Int -> Role
- pprCoAxBranch :: TyCon -> CoAxBranch -> SDoc
- pprCoAxBranchLHS :: TyCon -> CoAxBranch -> SDoc
- pprCoAxBranchUser :: TyCon -> CoAxBranch -> SDoc
- pprCoAxiom :: CoAxiom br -> SDoc
- promoteCoercion :: Coercion -> CoercionN
- setCoVarName :: CoVar -> Name -> CoVar
- setCoVarUnique :: CoVar -> Unique -> CoVar
- setNominalRole_maybe :: Role -> Coercion -> Maybe Coercion
- simplifyArgsWorker :: [TyCoBinder] -> Kind -> TyCoVarSet -> [Role] -> [(Type, Coercion)] -> ([Type], [Coercion], CoercionN)
- splitAppCo_maybe :: Coercion -> Maybe (Coercion, Coercion)
- splitForAllCo_co_maybe :: Coercion -> Maybe (CoVar, Coercion, Coercion)
- splitForAllCo_maybe :: Coercion -> Maybe (TyCoVar, Coercion, Coercion)
- splitForAllCo_ty_maybe :: Coercion -> Maybe (TyVar, Coercion, Coercion)
- splitFunCo_maybe :: Coercion -> Maybe (Coercion, Coercion)
- splitTyConAppCo_maybe :: Coercion -> Maybe (TyCon, [Coercion])
- substForAllCoBndrUsingLC :: Bool -> (Coercion -> Coercion) -> LiftingContext -> TyCoVar -> Coercion -> (LiftingContext, TyCoVar, Coercion)
- substLeftCo :: LiftingContext -> Coercion -> Coercion
- substRightCo :: LiftingContext -> Coercion -> Coercion
- swapLiftCoEnv :: LiftCoEnv -> LiftCoEnv
- tidyCoAxBndrsForUser :: TidyEnv -> [Var] -> (TidyEnv, [Var])
- topNormaliseNewType_maybe :: Type -> Maybe (Coercion, Type)
- topNormaliseTypeX :: NormaliseStepper ev -> (ev -> ev -> ev) -> Type -> Maybe (ev, Type)
- tyConRolesRepresentational :: TyCon -> [Role]
- tyConRolesX :: Role -> TyCon -> [Role]
- unwrapNewTypeStepper :: NormaliseStepper Coercion
- zapLiftingContext :: LiftingContext -> LiftingContext
- type LiftCoEnv = VarEnv Coercion
- data NormaliseStepResult ev- = NS_Done
- | NS_Abort
- | NS_Step RecTcChecker Type ev
 
- type NormaliseStepper ev = RecTcChecker -> TyCon -> [Type] -> NormaliseStepResult ev
- module GHC.Builtin.Types
- module GHC.Driver.Types
- module GHC.Types.Basic
- module GHC.Types.Var.Set
- module GHC.Types.Var.Env
- module GHC.Types.Name.Set
- module GHC.Types.Name.Env
- class Uniquable a where
- data Unique
- module GHC.Types.Unique.Set
- module GHC.Types.Unique.FM
- module GHC.Data.FiniteMap
- module GHC.Utils.Misc
- module GHC.Serialized
- module GHC.Types.SrcLoc
- module GHC.Utils.Outputable
- module GHC.Types.Unique.Supply
- module GHC.Data.FastString
- module GHC.Tc.Errors.Hole.FitTypes
- thNameToGhcName :: Name -> CoreM (Maybe Name)
Documentation
module GHC.Driver.Plugins
module GHC.Types.Name.Reader
Occurrence Name
In this context that means: "classified (i.e. as a type name, value name, etc) but not qualified and not yet resolved"
Instances
emptyFsEnv :: FastStringEnv a #
extendFsEnv :: FastStringEnv a -> FastString -> a -> FastStringEnv a #
lookupFsEnv :: FastStringEnv a -> FastString -> Maybe a #
mkFsEnv :: [(FastString, a)] -> FastStringEnv a #
type FastStringEnv a = UniqFM FastString a #
A non-deterministic set of FastStrings. See Note [Deterministic UniqFM] in GHC.Types.Unique.DFM for explanation why it's not deterministic and why it matters. Use DFastStringEnv if the set eventually gets converted into a list or folded over in a way where the order changes the generated code.
avoidClashesOccEnv :: TidyOccEnv -> [OccName] -> TidyOccEnv #
delFromOccEnv :: OccEnv a -> OccName -> OccEnv a #
delListFromOccEnv :: OccEnv a -> [OccName] -> OccEnv a #
delTidyOccEnvList :: TidyOccEnv -> [FastString] -> TidyOccEnv #
demoteOccName :: OccName -> Maybe OccName #
elemOccEnv :: OccName -> OccEnv a -> Bool #
elemOccSet :: OccName -> OccSet -> Bool #
emptyOccEnv :: OccEnv a #
emptyOccSet :: OccSet #
extendOccEnv :: OccEnv a -> OccName -> a -> OccEnv a #
extendOccEnvList :: OccEnv a -> [(OccName, a)] -> OccEnv a #
extendOccEnv_Acc :: (a -> b -> b) -> (a -> b) -> OccEnv b -> OccName -> a -> OccEnv b #
extendOccEnv_C :: (a -> a -> a) -> OccEnv a -> OccName -> a -> OccEnv a #
extendOccSet :: OccSet -> OccName -> OccSet #
extendOccSetList :: OccSet -> [OccName] -> OccSet #
filterOccEnv :: (elt -> Bool) -> OccEnv elt -> OccEnv elt #
foldOccEnv :: (a -> b -> b) -> b -> OccEnv a -> b #
initTidyOccEnv :: [OccName] -> TidyOccEnv #
intersectOccSet :: OccSet -> OccSet -> OccSet #
isDataConNameSpace :: NameSpace -> Bool #
isDataSymOcc :: OccName -> Bool #
Test if the OccName is a data constructor that starts with
 a symbol (e.g. :, or [])
isDefaultMethodOcc :: OccName -> Bool #
isDerivedOccName :: OccName -> Bool #
Test for definitions internally generated by GHC. This predicate is used to suppress printing of internal definitions in some debug prints
isEmptyOccSet :: OccSet -> Bool #
Test if the OccName is that for any operator (whether
 it is a data constructor or variable or whatever)
isTcClsNameSpace :: NameSpace -> Bool #
isTvNameSpace :: NameSpace -> Bool #
isTypeableBindOcc :: OccName -> Bool #
Is an OccName one of a Typeable TyCon or Module binding?
 This is needed as these bindings are renamed differently.
 See Note [Grand plan for Typeable] in GHC.Tc.Instance.Typeable.
isValNameSpace :: NameSpace -> Bool #
Value OccNamess are those that are either in
 the variable or data constructor namespaces
isVarNameSpace :: NameSpace -> Bool #
lookupOccEnv :: OccEnv a -> OccName -> Maybe a #
minusOccSet :: OccSet -> OccSet -> OccSet #
mkBuilderOcc :: OccName -> OccName #
mkClassDataConOcc :: OccName -> OccName #
mkClassOpAuxOcc :: OccName -> OccName #
mkClsOccFS :: FastString -> OccName #
mkCon2TagOcc :: OccName -> OccName #
mkDataCOcc :: OccName -> OccName #
mkDataConWorkerOcc :: OccName -> OccName #
mkDataConWrapperOcc :: OccName -> OccName #
mkDataOccFS :: FastString -> OccName #
mkDataTOcc :: OccName -> OccName #
mkDefaultMethodOcc :: OccName -> OccName #
mkEqPredCoOcc :: OccName -> OccName #
mkForeignExportOcc :: OccName -> OccName #
mkInstTyCoOcc :: OccName -> OccName #
Derive a name for the representation type constructor of a
 data/newtype instance.
mkMatcherOcc :: OccName -> OccName #
mkMaxTagOcc :: OccName -> OccName #
mkMethodOcc :: OccName -> OccName #
mkNewTyCoOcc :: OccName -> OccName #
mkOccEnv_C :: (a -> a -> a) -> [(OccName, a)] -> OccEnv a #
mkOccNameFS :: NameSpace -> FastString -> OccName #
mkRecFldSelOcc :: String -> OccName #
mkRepEqOcc :: OccName -> OccName #
mkSuperDictAuxOcc :: Int -> OccName -> OccName #
mkTag2ConOcc :: OccName -> OccName #
mkTcOccFS :: FastString -> OccName #
mkTyConRepOcc :: OccName -> OccName #
mkTyVarOcc :: String -> OccName #
mkTyVarOccFS :: FastString -> OccName #
mkVarOccFS :: FastString -> OccName #
mkWorkerOcc :: OccName -> OccName #
nameSpacesRelated :: NameSpace -> NameSpace -> Bool #
occEnvElts :: OccEnv a -> [a] #
occNameString :: OccName -> String #
parenSymOcc :: OccName -> SDoc -> SDoc #
Wrap parens around an operator
plusOccEnv :: OccEnv a -> OccEnv a -> OccEnv a #
plusOccEnv_C :: (a -> a -> a) -> OccEnv a -> OccEnv a -> OccEnv a #
pprNameSpace :: NameSpace -> SDoc #
pprNameSpaceBrief :: NameSpace -> SDoc #
pprNonVarNameSpace :: NameSpace -> SDoc #
pprOccName :: OccName -> SDoc #
setOccNameSpace :: NameSpace -> OccName -> OccName #
startsWithUnderscore :: OccName -> Bool #
Haskell 98 encourages compilers to suppress warnings about unused
 names in a pattern if they start with _: this implements that test
tidyOccName :: TidyOccEnv -> OccName -> (TidyOccEnv, OccName) #
unionManyOccSets :: [OccSet] -> OccSet #
unionOccSets :: OccSet -> OccSet -> OccSet #
unitOccEnv :: OccName -> a -> OccEnv a #
unitOccSet :: OccName -> OccSet #
class HasOccName name where #
Other names in the compiler add additional information to an OccName. This class provides a consistent way to access the underlying OccName.
Instances
| HasOccName IfaceClassOp # | |
| Defined in GHC.Iface.Syntax Methods occName :: IfaceClassOp -> OccName # | |
| HasOccName IfaceConDecl # | |
| Defined in GHC.Iface.Syntax Methods occName :: IfaceConDecl -> OccName # | |
| HasOccName IfaceDecl # | |
| Defined in GHC.Iface.Syntax | |
| HasOccName HoleFitCandidate # | |
| Defined in GHC.Tc.Errors.Hole.FitTypes Methods occName :: HoleFitCandidate -> OccName # | |
| HasOccName TcBinder # | |
| Defined in GHC.Tc.Types | |
| HasOccName Name # | |
| Defined in GHC.Types.Name | |
| HasOccName OccName # | |
| Defined in GHC.Types.Name.Occurrence | |
| HasOccName RdrName # | |
| Defined in GHC.Types.Name.Reader | |
| HasOccName Var # | |
| Defined in GHC.Types.Var | |
| HasOccName name => HasOccName (IEWrappedName name) # | |
| Defined in GHC.Hs.ImpExp Methods occName :: IEWrappedName name -> OccName # | |
Instances
| Binary NameSpace # | |
| Eq NameSpace # | |
| Ord NameSpace # | |
Instances
| Data a => Data (OccEnv a) # | |
| Defined in GHC.Types.Name.Occurrence Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OccEnv a -> c (OccEnv a) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (OccEnv a) Source # toConstr :: OccEnv a -> Constr Source # dataTypeOf :: OccEnv a -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (OccEnv a)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (OccEnv a)) Source # gmapT :: (forall b. Data b => b -> b) -> OccEnv a -> OccEnv a Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OccEnv a -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OccEnv a -> r Source # gmapQ :: (forall d. Data d => d -> u) -> OccEnv a -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> OccEnv a -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> OccEnv a -> m (OccEnv a) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OccEnv a -> m (OccEnv a) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OccEnv a -> m (OccEnv a) Source # | |
| Outputable a => Outputable (OccEnv a) # | |
type TidyOccEnv = UniqFM FastString Int #
A unique, unambiguous name for something, containing information about where that thing originated.
Instances
| Data Name # | |
| Defined in GHC.Types.Name Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Name -> c Name Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Name Source # toConstr :: Name -> Constr Source # dataTypeOf :: Name -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Name) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name) Source # gmapT :: (forall b. Data b => b -> b) -> Name -> Name Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Name -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Name -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Name -> m Name Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Name -> m Name Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Name -> m Name Source # | |
| NFData Name # | |
| Defined in GHC.Types.Name | |
| NamedThing Name # | |
| Defined in GHC.Types.Name | |
| HasOccName Name # | |
| Defined in GHC.Types.Name | |
| Uniquable Name # | |
| Defined in GHC.Types.Name | |
| Binary Name # | Assumes that the  | 
| Outputable Name # | |
| OutputableBndr Name # | |
| Defined in GHC.Types.Name Methods pprBndr :: BindingSite -> Name -> SDoc # pprPrefixOcc :: Name -> SDoc # pprInfixOcc :: Name -> SDoc # bndrIsJoin_maybe :: Name -> Maybe Int # | |
| Eq Name # | |
| Ord Name # | Caution: This instance is implemented via  See  | 
Occurrence Name
In this context that means: "classified (i.e. as a type name, value name, etc) but not qualified and not yet resolved"
Instances
emptyFsEnv :: FastStringEnv a #
extendFsEnv :: FastStringEnv a -> FastString -> a -> FastStringEnv a #
lookupFsEnv :: FastStringEnv a -> FastString -> Maybe a #
mkFsEnv :: [(FastString, a)] -> FastStringEnv a #
type FastStringEnv a = UniqFM FastString a #
A non-deterministic set of FastStrings. See Note [Deterministic UniqFM] in GHC.Types.Unique.DFM for explanation why it's not deterministic and why it matters. Use DFastStringEnv if the set eventually gets converted into a list or folded over in a way where the order changes the generated code.
avoidClashesOccEnv :: TidyOccEnv -> [OccName] -> TidyOccEnv #
delFromOccEnv :: OccEnv a -> OccName -> OccEnv a #
delListFromOccEnv :: OccEnv a -> [OccName] -> OccEnv a #
delTidyOccEnvList :: TidyOccEnv -> [FastString] -> TidyOccEnv #
demoteOccName :: OccName -> Maybe OccName #
elemOccEnv :: OccName -> OccEnv a -> Bool #
elemOccSet :: OccName -> OccSet -> Bool #
emptyOccEnv :: OccEnv a #
emptyOccSet :: OccSet #
extendOccEnv :: OccEnv a -> OccName -> a -> OccEnv a #
extendOccEnvList :: OccEnv a -> [(OccName, a)] -> OccEnv a #
extendOccEnv_Acc :: (a -> b -> b) -> (a -> b) -> OccEnv b -> OccName -> a -> OccEnv b #
extendOccEnv_C :: (a -> a -> a) -> OccEnv a -> OccName -> a -> OccEnv a #
extendOccSet :: OccSet -> OccName -> OccSet #
extendOccSetList :: OccSet -> [OccName] -> OccSet #
filterOccEnv :: (elt -> Bool) -> OccEnv elt -> OccEnv elt #
foldOccEnv :: (a -> b -> b) -> b -> OccEnv a -> b #
initTidyOccEnv :: [OccName] -> TidyOccEnv #
intersectOccSet :: OccSet -> OccSet -> OccSet #
isDataConNameSpace :: NameSpace -> Bool #
isDataSymOcc :: OccName -> Bool #
Test if the OccName is a data constructor that starts with
 a symbol (e.g. :, or [])
isDefaultMethodOcc :: OccName -> Bool #
isDerivedOccName :: OccName -> Bool #
Test for definitions internally generated by GHC. This predicate is used to suppress printing of internal definitions in some debug prints
isEmptyOccSet :: OccSet -> Bool #
Test if the OccName is that for any operator (whether
 it is a data constructor or variable or whatever)
isTcClsNameSpace :: NameSpace -> Bool #
isTvNameSpace :: NameSpace -> Bool #
isTypeableBindOcc :: OccName -> Bool #
Is an OccName one of a Typeable TyCon or Module binding?
 This is needed as these bindings are renamed differently.
 See Note [Grand plan for Typeable] in GHC.Tc.Instance.Typeable.
isValNameSpace :: NameSpace -> Bool #
Value OccNamess are those that are either in
 the variable or data constructor namespaces
isVarNameSpace :: NameSpace -> Bool #
lookupOccEnv :: OccEnv a -> OccName -> Maybe a #
minusOccSet :: OccSet -> OccSet -> OccSet #
mkBuilderOcc :: OccName -> OccName #
mkClassDataConOcc :: OccName -> OccName #
mkClassOpAuxOcc :: OccName -> OccName #
mkClsOccFS :: FastString -> OccName #
mkCon2TagOcc :: OccName -> OccName #
mkDataCOcc :: OccName -> OccName #
mkDataConWorkerOcc :: OccName -> OccName #
mkDataConWrapperOcc :: OccName -> OccName #
mkDataOccFS :: FastString -> OccName #
mkDataTOcc :: OccName -> OccName #
mkDefaultMethodOcc :: OccName -> OccName #
mkEqPredCoOcc :: OccName -> OccName #
mkForeignExportOcc :: OccName -> OccName #
mkInstTyCoOcc :: OccName -> OccName #
Derive a name for the representation type constructor of a
 data/newtype instance.
mkMatcherOcc :: OccName -> OccName #
mkMaxTagOcc :: OccName -> OccName #
mkMethodOcc :: OccName -> OccName #
mkNewTyCoOcc :: OccName -> OccName #
mkOccEnv_C :: (a -> a -> a) -> [(OccName, a)] -> OccEnv a #
mkOccNameFS :: NameSpace -> FastString -> OccName #
mkRecFldSelOcc :: String -> OccName #
mkRepEqOcc :: OccName -> OccName #
mkSuperDictAuxOcc :: Int -> OccName -> OccName #
mkTag2ConOcc :: OccName -> OccName #
mkTcOccFS :: FastString -> OccName #
mkTyConRepOcc :: OccName -> OccName #
mkTyVarOcc :: String -> OccName #
mkTyVarOccFS :: FastString -> OccName #
mkVarOccFS :: FastString -> OccName #
mkWorkerOcc :: OccName -> OccName #
nameSpacesRelated :: NameSpace -> NameSpace -> Bool #
occEnvElts :: OccEnv a -> [a] #
occNameString :: OccName -> String #
parenSymOcc :: OccName -> SDoc -> SDoc #
Wrap parens around an operator
plusOccEnv :: OccEnv a -> OccEnv a -> OccEnv a #
plusOccEnv_C :: (a -> a -> a) -> OccEnv a -> OccEnv a -> OccEnv a #
pprNameSpace :: NameSpace -> SDoc #
pprNameSpaceBrief :: NameSpace -> SDoc #
pprNonVarNameSpace :: NameSpace -> SDoc #
pprOccName :: OccName -> SDoc #
setOccNameSpace :: NameSpace -> OccName -> OccName #
startsWithUnderscore :: OccName -> Bool #
Haskell 98 encourages compilers to suppress warnings about unused
 names in a pattern if they start with _: this implements that test
tidyOccName :: TidyOccEnv -> OccName -> (TidyOccEnv, OccName) #
unionManyOccSets :: [OccSet] -> OccSet #
unionOccSets :: OccSet -> OccSet -> OccSet #
unitOccEnv :: OccName -> a -> OccEnv a #
unitOccSet :: OccName -> OccSet #
class HasOccName name where #
Other names in the compiler add additional information to an OccName. This class provides a consistent way to access the underlying OccName.
Instances
| HasOccName IfaceClassOp # | |
| Defined in GHC.Iface.Syntax Methods occName :: IfaceClassOp -> OccName # | |
| HasOccName IfaceConDecl # | |
| Defined in GHC.Iface.Syntax Methods occName :: IfaceConDecl -> OccName # | |
| HasOccName IfaceDecl # | |
| Defined in GHC.Iface.Syntax | |
| HasOccName HoleFitCandidate # | |
| Defined in GHC.Tc.Errors.Hole.FitTypes Methods occName :: HoleFitCandidate -> OccName # | |
| HasOccName TcBinder # | |
| Defined in GHC.Tc.Types | |
| HasOccName Name # | |
| Defined in GHC.Types.Name | |
| HasOccName OccName # | |
| Defined in GHC.Types.Name.Occurrence | |
| HasOccName RdrName # | |
| Defined in GHC.Types.Name.Reader | |
| HasOccName Var # | |
| Defined in GHC.Types.Var | |
| HasOccName name => HasOccName (IEWrappedName name) # | |
| Defined in GHC.Hs.ImpExp Methods occName :: IEWrappedName name -> OccName # | |
Instances
| Binary NameSpace # | |
| Eq NameSpace # | |
| Ord NameSpace # | |
Instances
| Data a => Data (OccEnv a) # | |
| Defined in GHC.Types.Name.Occurrence Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OccEnv a -> c (OccEnv a) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (OccEnv a) Source # toConstr :: OccEnv a -> Constr Source # dataTypeOf :: OccEnv a -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (OccEnv a)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (OccEnv a)) Source # gmapT :: (forall b. Data b => b -> b) -> OccEnv a -> OccEnv a Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OccEnv a -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OccEnv a -> r Source # gmapQ :: (forall d. Data d => d -> u) -> OccEnv a -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> OccEnv a -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> OccEnv a -> m (OccEnv a) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OccEnv a -> m (OccEnv a) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OccEnv a -> m (OccEnv a) Source # | |
| Outputable a => Outputable (OccEnv a) # | |
type TidyOccEnv = UniqFM FastString Int #
getOccFS :: NamedThing a => a -> FastString #
getOccString :: NamedThing a => a -> String #
getSrcLoc :: NamedThing a => a -> SrcLoc #
getSrcSpan :: NamedThing a => a -> SrcSpan #
isBuiltInSyntax :: Name -> Bool #
isDataConName :: Name -> Bool #
isDynLinkName :: Platform -> Module -> Name -> Bool #
Will the Name come from a dynamically linked package?
isExternalName :: Name -> Bool #
isHoleName :: Name -> Bool #
isInternalName :: Name -> Bool #
isSystemName :: Name -> Bool #
isTyConName :: Name -> Bool #
isTyVarName :: Name -> Bool #
isWiredIn :: NamedThing thing => thing -> Bool #
isWiredInName :: Name -> Bool #
localiseName :: Name -> Name #
Make the Name into an internal name, regardless of what it was to begin with
mkClonedInternalName :: Unique -> Name -> Name #
mkExternalName :: Unique -> Module -> OccName -> SrcSpan -> Name #
Create a name which definitely originates in the given module
mkFCallName :: Unique -> String -> Name #
Make a name for a foreign call
mkSysTvName :: Unique -> FastString -> Name #
mkSystemName :: Unique -> OccName -> Name #
Create a name brought into being by the compiler
mkSystemVarName :: Unique -> FastString -> Name #
mkWiredInName :: Module -> OccName -> Unique -> TyThing -> BuiltInSyntax -> Name #
Create a name which is actually defined by the compiler itself
nameIsFromExternalPackage :: Unit -> Name -> Bool #
Returns True if the Name comes from some other package: neither this package nor the interactive package.
nameIsHomePackage :: Module -> Name -> Bool #
nameIsHomePackageImport :: Module -> Name -> Bool #
nameIsLocalOrFrom :: Module -> Name -> Bool #
Returns True if the name is
   (a) Internal
   (b) External but from the specified module
   (c) External but from the interactive package
The key idea is that False means: the entity is defined in some other module you can find the details (type, fixity, instances) in some interface file those details will be stored in the EPT or HPT
True means: the entity is defined in this module or earlier in the GHCi session you can find details (type, fixity, instances) in the TcGblEnv or TcLclEnv
The isInteractiveModule part is because successive interactions of a GHCi session
 each give rise to a fresh module (Ghci1, Ghci2, etc), but they all come
 from the magic interactive package; and all the details are kept in the
 TcLclEnv, TcGblEnv, NOT in the HPT or EPT.
 See Note [The interactive package] in GHC.Driver.Types
nameModule :: HasDebugCallStack => Name -> Module #
nameModule_maybe :: Name -> Maybe Module #
nameNameSpace :: Name -> NameSpace #
nameOccName :: Name -> OccName #
nameSrcLoc :: Name -> SrcLoc #
nameSrcSpan :: Name -> SrcSpan #
nameStableString :: Name -> String #
Get a string representation of a Name that's unique and stable
 across recompilations. Used for deterministic generation of binds for
 derived instances.
 eg. "$aeson_70dylHtv1FFGeai1IoxcQr$Data.Aeson.Types.Internal$String"
nameUnique :: Name -> Unique #
pprDefinedAt :: Name -> SDoc #
pprInfixName :: (Outputable a, NamedThing a) => a -> SDoc #
pprNameDefnLoc :: Name -> SDoc #
pprNameUnqualified :: Name -> SDoc #
Print the string of Name unqualifiedly directly.
pprPrefixName :: NamedThing a => a -> SDoc #
setNameLoc :: Name -> SrcSpan -> Name #
setNameUnique :: Name -> Unique -> Name #
stableNameCmp :: Name -> Name -> Ordering #
Compare Names lexicographically This only works for Names that originate in the source code or have been tidied.
tidyNameOcc :: Name -> OccName -> Name #
data BuiltInSyntax #
BuiltInSyntax is for things like (:), [] and tuples,
 which have special syntactic forms.  They aren't in scope
 as such.
Constructors
| BuiltInSyntax | |
| UserSyntax | 
class NamedThing a where #
A class allowing convenient access to the Name of various datatypes
Minimal complete definition
Instances
| NamedThing Class # | |
| Defined in GHC.Core.Class | |
| NamedThing ConLike # | |
| Defined in GHC.Core.ConLike | |
| NamedThing DataCon # | |
| Defined in GHC.Core.DataCon | |
| NamedThing FamInst # | |
| Defined in GHC.Core.FamInstEnv | |
| NamedThing ClsInst # | |
| Defined in GHC.Core.InstEnv | |
| NamedThing PatSyn # | |
| Defined in GHC.Core.PatSyn | |
| NamedThing TyThing # | |
| Defined in GHC.Core.TyCo.Rep | |
| NamedThing TyCon # | |
| Defined in GHC.Core.TyCon | |
| NamedThing IfaceClassOp # | |
| Defined in GHC.Iface.Syntax | |
| NamedThing IfaceConDecl # | |
| Defined in GHC.Iface.Syntax | |
| NamedThing IfaceDecl # | |
| Defined in GHC.Iface.Syntax | |
| NamedThing HoleFitCandidate # | |
| Defined in GHC.Tc.Errors.Hole.FitTypes | |
| NamedThing Name # | |
| Defined in GHC.Types.Name | |
| NamedThing Var # | |
| Defined in GHC.Types.Var | |
| NamedThing (CoAxiom br) # | |
| Defined in GHC.Core.Coercion.Axiom | |
| NamedThing e => NamedThing (Located e) # | |
| Defined in GHC.Types.Name | |
| NamedThing (HsTyVarBndr flag GhcRn) # | |
| Defined in GHC.Hs.Type | |
| NamedThing tv => NamedThing (VarBndr tv flag) # | |
| Defined in GHC.Types.Var | |
module GHC.Types.Var
Variable
Essentially a typed Name, that may also contain some additional information
 about the Var and its use sites.
Instances
| Data Var # | |
| Defined in GHC.Types.Var Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Var -> c Var Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Var Source # toConstr :: Var -> Constr Source # dataTypeOf :: Var -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Var) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Var) Source # gmapT :: (forall b. Data b => b -> b) -> Var -> Var Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Var -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Var -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Var -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Var -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Var -> m Var Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Var -> m Var Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Var -> m Var Source # | |
| NamedThing Var # | |
| Defined in GHC.Types.Var | |
| HasOccName Var # | |
| Defined in GHC.Types.Var | |
| Uniquable Var # | |
| Defined in GHC.Types.Var | |
| Outputable Var # | |
| OutputableBndr Var # | |
| Defined in GHC.Core.Ppr Methods pprBndr :: BindingSite -> Var -> SDoc # pprPrefixOcc :: Var -> SDoc # pprInfixOcc :: Var -> SDoc # bndrIsJoin_maybe :: Var -> Maybe Int # | |
| Eq Var # | |
| Ord Var # | |
globaliseId :: Id -> Id #
If it's a local, make it global
idInfo :: HasDebugCallStack => Id -> IdInfo #
isExportedId :: Var -> Bool #
isExportedIdVar means "don't throw this away"
isGlobalId :: Var -> Bool #
Is this a value-level (i.e., computationally relevant) Identifier?
 Satisfies isId = not . isTyVar.
clearOneShotLambda :: Id -> Id #
hasNoBinding :: Id -> Bool #
Returns True of an Id which may not have a
 binding, even though it is defined in this module.
idCallArity :: Id -> Arity #
idCoreRules :: Id -> [CoreRule] #
Get from either the worker or the wrapper Id to the DataCon. Currently used only in the desugarer.
INVARIANT: idDataCon (dataConWrapId d) = d: remember, dataConWrapId can return either the wrapper or the worker
idDemandInfo :: Id -> Demand #
idFunRepArity :: Id -> RepArity #
idHasRules :: Id -> Bool #
idInlineActivation :: Id -> Activation #
idInlinePragma :: Id -> InlinePragma #
idJoinArity :: JoinId -> JoinArity #
idLFInfo_maybe :: Id -> Maybe LambdaFormInfo #
idOneShotInfo :: Id -> OneShotInfo #
idRuleMatchInfo :: Id -> RuleMatchInfo #
idScaledType :: Id -> Scaled Type #
idSpecialisation :: Id -> RuleInfo #
idStateHackOneShotInfo :: Id -> OneShotInfo #
Like idOneShotInfo, but taking the Horrible State Hack in to account
 See Note [The state-transformer hack] in GHC.Core.Opt.Arity
idStrictness :: Id -> StrictSig #
Accesses the Id's strictnessInfo.
idUnfolding :: Id -> Unfolding #
isClassOpId_maybe :: Id -> Maybe Class #
isConLikeId :: Id -> Bool #
isDataConId_maybe :: Id -> Maybe DataCon #
isDataConRecordSelector :: Id -> Bool #
isDataConWorkId :: Id -> Bool #
isDataConWorkId_maybe :: Id -> Maybe DataCon #
isDataConWrapId :: Id -> Bool #
isDataConWrapId_maybe :: Id -> Maybe DataCon #
isDeadBinder :: Id -> Bool #
isDeadEndId :: Var -> Bool #
Returns true if an application to n args diverges or throws an exception See Note [Dead ends] in GHC.Types.Demand.
isFCallId_maybe :: Id -> Maybe ForeignCall #
isImplicitId :: Id -> Bool #
isImplicitId tells whether an Ids info is implied by other
 declarations, so we don't need to put its signature in an interface
 file, even if it's mentioned in some other interface unfolding.
isJoinId_maybe :: Var -> Maybe JoinArity #
isNaughtyRecordSelector :: Id -> Bool #
isNeverLevPolyId :: Id -> Bool #
isOneShotBndr :: Var -> Bool #
Returns whether the lambda associated with the Id is certainly applied at most once
 This one is the "business end", called externally.
 It works on type variables as well as Ids, returning True
 Its main purpose is to encapsulate the Horrible State Hack
 See Note [The state-transformer hack] in GHC.Core.Opt.Arity
isPatSynRecordSelector :: Id -> Bool #
isPrimOpId :: Id -> Bool #
isPrimOpId_maybe :: Id -> Maybe PrimOp #
isProbablyOneShotLambda :: Id -> Bool #
isRecordSelector :: Id -> Bool #
isStateHackType :: Type -> Bool #
isStrictId :: Id -> Bool #
This predicate says whether the Id has a strict demand placed on it or
 has a type such that it can always be evaluated strictly (i.e an
 unlifted type, as of GHC 7.6).  We need to
 check separately whether the Id has a so-called "strict type" because if
 the demand for the given id hasn't been computed yet but id has a strict
 type, we still want isStrictId id to be True.
localiseId :: Id -> Id #
mkExportedLocalId :: IdDetails -> Name -> Type -> Id #
Create a local Id that is marked as exported.
 This prevents things attached to it from being removed as dead code.
 See Note [Exported LocalIds]
mkExportedVanillaId :: Name -> Type -> Id #
mkGlobalId :: IdDetails -> Name -> Type -> IdInfo -> Id #
For an explanation of global vs. local Ids, see GHC.Types.Var.Var
mkLocalCoVar :: Name -> Type -> CoVar #
Make a local CoVar
mkLocalId :: HasDebugCallStack => Name -> Mult -> Type -> Id #
For an explanation of global vs. local Ids, see GHC.Types.Var
mkLocalIdOrCoVar :: Name -> Mult -> Type -> Id #
Like mkLocalId, but checks the type to see if it should make a covar
mkLocalIdWithInfo :: HasDebugCallStack => Name -> Mult -> Type -> IdInfo -> Id #
mkSysLocal :: FastString -> Unique -> Mult -> Type -> Id #
mkSysLocalM :: MonadUnique m => FastString -> Mult -> Type -> m Id #
mkSysLocalOrCoVar :: FastString -> Unique -> Mult -> Type -> Id #
Like mkSysLocal, but checks to see if we have a covar type
mkSysLocalOrCoVarM :: MonadUnique m => FastString -> Mult -> Type -> m Id #
mkTemplateLocal :: Int -> Type -> Id #
Create a template local: a family of system local Ids in bijection with Ints, typically used in unfoldings
mkTemplateLocals :: [Type] -> [Id] #
Create a template local for a series of types
mkTemplateLocalsNum :: Int -> [Type] -> [Id] #
Create a template local for a series of type, but start from a specified template local
mkUserLocal :: OccName -> Unique -> Mult -> Type -> SrcSpan -> Id #
Create a user local Id. These are local Ids (see GHC.Types.Var) with a name and location that the user might recognize
mkUserLocalOrCoVar :: OccName -> Unique -> Mult -> Type -> SrcSpan -> Id #
Like mkUserLocal, but checks if we have a coercion type
mkWorkerId :: Unique -> Id -> Type -> Id #
Workers get local names. CoreTidy will externalise these if necessary
modifyIdInfo :: HasDebugCallStack => (IdInfo -> IdInfo) -> Id -> Id #
modifyInlinePragma :: Id -> (InlinePragma -> InlinePragma) -> Id #
realIdUnfolding :: Id -> Unfolding #
recordSelectorTyCon :: Id -> RecSelParent #
scaleVarBy :: Mult -> Var -> Var #
Like scaleIdBy, but skips non-Ids. Useful for scaling
 a mixed list of ids and tyvars.
setCaseBndrEvald :: StrictnessMark -> Id -> Id #
setIdArity :: Id -> Arity -> Id infixl 1 #
setIdCafInfo :: Id -> CafInfo -> Id #
setIdCallArity :: Id -> Arity -> Id infixl 1 #
setIdCprInfo :: Id -> CprSig -> Id infixl 1 #
setIdDemandInfo :: Id -> Demand -> Id infixl 1 #
setIdLFInfo :: Id -> LambdaFormInfo -> Id #
setIdOccInfo :: Id -> OccInfo -> Id infixl 1 #
setIdOneShotInfo :: Id -> OneShotInfo -> Id infixl 1 #
setIdSpecialisation :: Id -> RuleInfo -> Id infixl 1 #
setIdStrictness :: Id -> StrictSig -> Id infixl 1 #
setIdUnfolding :: Id -> Unfolding -> Id infixl 1 #
setIdUnique :: Id -> Unique -> Id #
setInlineActivation :: Id -> Activation -> Id infixl 1 #
setInlinePragma :: Id -> InlinePragma -> Id infixl 1 #
setOneShotLambda :: Id -> Id #
stateHackOneShot :: OneShotInfo #
Should we apply the state hack to values of this Type?
typeOneShot :: Type -> OneShotInfo #
updOneShotInfo :: Id -> OneShotInfo -> Id #
zapFragileIdInfo :: Id -> Id #
zapIdDemandInfo :: Id -> Id #
zapIdOccInfo :: Id -> Id #
zapIdStrictness :: Id -> Id #
zapIdTailCallInfo :: Id -> Id #
zapIdUsageEnvInfo :: Id -> Id #
zapIdUsageInfo :: Id -> Id #
zapIdUsedOnceInfo :: Id -> Id #
zapLamIdInfo :: Id -> Id #
zapStableUnfolding :: Id -> Id #
module GHC.Types.Id.Info
module GHC.Core.Opt.Monad
module GHC.Core
module GHC.Types.Literal
module GHC.Core.DataCon
module GHC.Core.Utils
module GHC.Core.Make
module GHC.Core.FVs
data InScopeSet #
A set of variables that are in scope at some point "Secrets of the Glasgow Haskell Compiler inliner" Section 3.2 provides the motivation for this abstraction.
Instances
| Outputable InScopeSet # | |
| Defined in GHC.Types.Var.Env | |
addInScopeSet :: Subst -> VarSet -> Subst #
Add the Var to the in-scope set, but do not remove
 any existing substitutions for it
cloneBndrs :: Subst -> UniqSupply -> [Var] -> (Subst, [Var]) #
cloneIdBndr :: Subst -> UniqSupply -> Id -> (Subst, Id) #
cloneIdBndrs :: Subst -> UniqSupply -> [Id] -> (Subst, [Id]) #
Applies cloneIdBndr to a number of Ids, accumulating a final
 substitution from left to right
cloneRecIdBndrs :: Subst -> UniqSupply -> [Id] -> (Subst, [Id]) #
Clone a mutually recursive group of Ids
deShadowBinds :: CoreProgram -> CoreProgram #
De-shadowing the program is sometimes a useful pre-pass. It can be done simply by running over the bindings with an empty substitution, because substitution returns a result that has no-shadowing guaranteed.
(Actually, within a single type there might still be shadowing, because
 substTy is a no-op for the empty substitution, but that's probably OK.)
- Aug 09
- This function is not used in GHC at the moment, but seems so short and simple that I'm going to leave it here
emptySubst :: Subst #
extendIdSubstList :: Subst -> [(Id, CoreExpr)] -> Subst #
Adds multiple Id substitutions to the Subst: see also extendIdSubst
extendInScope :: Subst -> Var -> Subst #
Add the Var to the in-scope set: as a side effect,
 and remove any existing substitutions for it
extendInScopeIds :: Subst -> [Id] -> Subst #
Optimized version of extendInScopeList that can be used if you are certain
 all the things being added are Ids and hence none are TyVars or CoVars
extendInScopeList :: Subst -> [Var] -> Subst #
Add the Vars to the in-scope set: see also extendInScope
extendSubst :: Subst -> Var -> CoreArg -> Subst #
Add a substitution appropriate to the thing being substituted
   (whether an expression, type, or coercion). See also
   extendIdSubst, extendTvSubst, extendCvSubst
extendSubstList :: Subst -> [(Var, CoreArg)] -> Subst #
Add a substitution as appropriate to each of the terms being
   substituted (whether expressions, types, or coercions). See also
   extendSubst.
extendTvSubst :: Subst -> TyVar -> Type -> Subst #
Add a substitution for a TyVar to the Subst
 The TyVar *must* be a real TyVar, and not a CoVar
 You must ensure that the in-scope set is such that
 GHC.Core.TyCo.Subst Note [The substitution invariant] holds
 after extending the substitution like this.
extendTvSubstList :: Subst -> [(TyVar, Type)] -> Subst #
Adds multiple TyVar substitutions to the Subst: see also extendTvSubst
getTCvSubst :: Subst -> TCvSubst #
isEmptySubst :: Subst -> Bool #
lookupIdSubst :: HasDebugCallStack => Subst -> Id -> CoreExpr #
mkEmptySubst :: InScopeSet -> Subst #
mkOpenSubst :: InScopeSet -> [(Var, CoreArg)] -> Subst #
Simultaneously substitute for a bunch of variables No left-right shadowing ie the substitution for (x y. e) a1 a2 so neither x nor y scope over a1 a2
mkSubst :: InScopeSet -> TvSubstEnv -> CvSubstEnv -> IdSubstEnv -> Subst #
setInScope :: Subst -> InScopeSet -> Subst #
substBindSC :: HasDebugCallStack => Subst -> CoreBind -> (Subst, CoreBind) #
substDVarSet :: Subst -> DVarSet -> DVarSet #
substExpr :: HasDebugCallStack => Subst -> CoreExpr -> CoreExpr #
substExpr applies a substitution to an entire CoreExpr. Remember,
 you may only apply the substitution once:
 See Note [Substitutions apply only once] in GHC.Core.TyCo.Subst
Do *not* attempt to short-cut in the case of an empty substitution! See Note [Extending the Subst]
substExprSC :: HasDebugCallStack => Subst -> CoreExpr -> CoreExpr #
substIdOcc :: Subst -> Id -> Id #
substIdType :: Subst -> Id -> Id #
substInScope :: Subst -> InScopeSet #
Find the in-scope set: see GHC.Core.TyCo.Subst Note [The substitution invariant]
substRulesForImportedIds :: Subst -> [CoreRule] -> [CoreRule] #
zapSubstEnv :: Subst -> Subst #
type IdSubstEnv = IdEnv CoreExpr #
An environment for substituting for Ids
A substitution environment, containing Id, TyVar, and CoVar
 substitutions.
Some invariants apply to how you use the substitution:
- Note [The substitution invariant] in GHC.Core.TyCo.Subst
- Note [Substitutions apply only once] in GHC.Core.TyCo.Subst
Constructors
| Subst InScopeSet IdSubstEnv TvSubstEnv CvSubstEnv | 
module GHC.Core.Rules
module GHC.Types.Annotations
module GHC.Driver.Session
module GHC.Unit.State
module GHC.Unit.Module
data AnonArgFlag #
The non-dependent version of ArgFlag.
 See Note [AnonArgFlag]
 Appears here partly so that it's together with its friends ArgFlag
 and ForallVisFlag, but also because it is used in IfaceType, rather
 early in the compilation chain
Constructors
| VisArg | Used for  | 
| InvisArg | Used for  | 
Instances
Argument Flag
Is something required to appear in source Haskell (Required),
 permitted by request (Specified) (visible type application), or
 prohibited entirely from appearing in source Haskell (Inferred)?
 See Note [VarBndrs, TyCoVarBinders, TyConBinders, and visibility] in GHC.Core.TyCo.Rep
Constructors
| Invisible Specificity | |
| Required | 
Instances
| Data ArgFlag # | |
| Defined in GHC.Types.Var Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ArgFlag -> c ArgFlag Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ArgFlag Source # toConstr :: ArgFlag -> Constr Source # dataTypeOf :: ArgFlag -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ArgFlag) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ArgFlag) Source # gmapT :: (forall b. Data b => b -> b) -> ArgFlag -> ArgFlag Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ArgFlag -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ArgFlag -> r Source # gmapQ :: (forall d. Data d => d -> u) -> ArgFlag -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> ArgFlag -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ArgFlag -> m ArgFlag Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ArgFlag -> m ArgFlag Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ArgFlag -> m ArgFlag Source # | |
| Binary ArgFlag # | |
| Outputable ArgFlag # | |
| Eq ArgFlag # | |
| Ord ArgFlag # | |
| Outputable tv => Outputable (VarBndr tv ArgFlag) # | |
Variable
Essentially a typed Name, that may also contain some additional information
 about the Var and its use sites.
Instances
| Data Var # | |
| Defined in GHC.Types.Var Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Var -> c Var Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Var Source # toConstr :: Var -> Constr Source # dataTypeOf :: Var -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Var) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Var) Source # gmapT :: (forall b. Data b => b -> b) -> Var -> Var Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Var -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Var -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Var -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Var -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Var -> m Var Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Var -> m Var Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Var -> m Var Source # | |
| NamedThing Var # | |
| Defined in GHC.Types.Var | |
| HasOccName Var # | |
| Defined in GHC.Types.Var | |
| Uniquable Var # | |
| Defined in GHC.Types.Var | |
| Outputable Var # | |
| OutputableBndr Var # | |
| Defined in GHC.Core.Ppr Methods pprBndr :: BindingSite -> Var -> SDoc # pprPrefixOcc :: Var -> SDoc # pprInfixOcc :: Var -> SDoc # bndrIsJoin_maybe :: Var -> Maybe Int # | |
| Eq Var # | |
| Ord Var # | |
mkForAllTy :: TyCoVar -> ArgFlag -> Type -> Type #
Like mkTyCoForAllTy, but does not check the occurrence of the binder
 See Note [Unused coercion variable in ForAllTy]
Mult is a type alias for Type.
Mult must contain Type because multiplicity variables are mere type variables (of kind Multiplicity) in Haskell. So the simplest implementation is to make Mult be Type.
Multiplicities can be formed with: - One: GHC.Types.One (= oneDataCon) - Many: GHC.Types.Many (= manyDataCon) - Multiplication: GHC.Types.MultMul (= multMulTyCon)
So that Mult feels a bit more structured, we provide pattern synonyms and smart constructors for these.
A type of the form p of constraint kind represents a value whose type is
 the Haskell predicate p, where a predicate is what occurs before
 the => in a Haskell type.
We use PredType as documentation to mark those types that we guarantee to
 have this kind.
It can be expanded into its representation, but:
- The type checker must treat it as opaque
- The rest of the compiler treats it as transparent
Consider these examples:
f :: (Eq a) => a -> Int
g :: (?x :: Int -> Int) => a -> Int
h :: (r\l) => {r} => {l::Int | r}Here the Eq a and ?x :: Int -> Int and rl are all called "predicates"
A shorthand for data with an attached Mult element (the multiplicity).
Instances
| Data a => Data (Scaled a) # | |
| Defined in GHC.Core.TyCo.Rep Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Scaled a -> c (Scaled a) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Scaled a) Source # toConstr :: Scaled a -> Constr Source # dataTypeOf :: Scaled a -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Scaled a)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Scaled a)) Source # gmapT :: (forall b. Data b => b -> b) -> Scaled a -> Scaled a Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Scaled a -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Scaled a -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Scaled a -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Scaled a -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Scaled a -> m (Scaled a) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Scaled a -> m (Scaled a) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Scaled a -> m (Scaled a) Source # | |
| Outputable a => Outputable (Scaled a) # | |
data TyCoBinder #
A TyCoBinder represents an argument to a function. TyCoBinders can be
 dependent (Named) or nondependent (Anon). They may also be visible or
 not. See Note [TyCoBinders]
Instances
| Data TyCoBinder # | |
| Defined in GHC.Core.TyCo.Rep Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyCoBinder -> c TyCoBinder Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TyCoBinder Source # toConstr :: TyCoBinder -> Constr Source # dataTypeOf :: TyCoBinder -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TyCoBinder) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyCoBinder) Source # gmapT :: (forall b. Data b => b -> b) -> TyCoBinder -> TyCoBinder Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyCoBinder -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyCoBinder -> r Source # gmapQ :: (forall d. Data d => d -> u) -> TyCoBinder -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> TyCoBinder -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyCoBinder -> m TyCoBinder Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyCoBinder -> m TyCoBinder Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyCoBinder -> m TyCoBinder Source # | |
| Outputable TyCoBinder # | |
| Defined in GHC.Core.TyCo.Rep | |
A global typecheckable-thing, essentially anything that has a name.
 Not to be confused with a TcTyThing, which is also a typecheckable
 thing but in the *local* context.  See GHC.Tc.Utils.Env for how to retrieve
 a TyThing given a Name.
Instances
| NamedThing TyThing # | |
| Defined in GHC.Core.TyCo.Rep | |
| Outputable TyThing # | |
Instances
| Data Type # | |
| Defined in GHC.Core.TyCo.Rep Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Type -> c Type Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Type Source # toConstr :: Type -> Constr Source # dataTypeOf :: Type -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Type) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Type) Source # gmapT :: (forall b. Data b => b -> b) -> Type -> Type Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Type -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Type -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Type -> m Type Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Type -> m Type Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Type -> m Type Source # | |
| Outputable Type # | |
coreView :: Type -> Maybe Type #
This function Strips off the top layer only of a type synonym
 application (if any) its underlying representation type.
 Returns Nothing if there is nothing to look through.
 This function considers Constraint to be a synonym of TYPE LiftedRep.
By being non-recursive and inlined, this case analysis gets efficiently joined onto the case analysis that the caller is already doing
isCoercionTy :: Type -> Bool #
isLiftedTypeKind :: Kind -> Bool #
This version considers Constraint to be the same as *. Returns True if the argument is equivalent to Type/Constraint and False otherwise. See Note [Kind Constraint and kind Type]
isMultiplicityTy :: Type -> Bool #
Is this the type Multiplicity?
isPredTy :: HasDebugCallStack => Type -> Bool #
isRuntimeRepTy :: Type -> Bool #
Is this the type RuntimeRep?
mkCastTy :: Type -> Coercion -> Type #
Make a CastTy. The Coercion must be nominal. Checks the
 Coercion for reflexivity, dropping it if it's reflexive.
 See Note [Respecting definitional equality] in GHC.Core.TyCo.Rep
piResultTy :: HasDebugCallStack => Type -> Type -> Type #
splitTyConApp_maybe :: HasDebugCallStack => Type -> Maybe (TyCon, [Type]) #
Attempts to tease a type apart into a type constructor and the application of a number of arguments to that constructor
tcView :: Type -> Maybe Type #
Gives the typechecker view of a type. This unwraps synonyms but
 leaves Constraint alone. c.f. coreView, which turns Constraint into
 TYPE LiftedRep. Returns Nothing if no unwrapping happens.
 See also Note [coreView vs tcView]
tyConAppTyCon_maybe :: Type -> Maybe TyCon #
The same as fst . splitTyConApp
liftedTypeKind :: Kind #
binderArgFlag :: VarBndr tv argf -> argf #
binderType :: VarBndr TyCoVar argf -> Type #
binderVars :: [VarBndr tv argf] -> [tv] #
isInvisibleArgFlag :: ArgFlag -> Bool #
Does this ArgFlag classify an argument that is not written in Haskell?
Is this a type-level (i.e., computationally irrelevant, thus erasable)
 variable? Satisfies isTyVar = not . isId.
isVisibleArgFlag :: ArgFlag -> Bool #
Does this ArgFlag classify an argument that is written in Haskell?
mkTyCoVarBinder :: vis -> TyCoVar -> VarBndr TyCoVar vis #
Make a named binder
mkTyCoVarBinders :: vis -> [TyCoVar] -> [VarBndr TyCoVar vis] #
Make many named binders
mkTyVarBinder :: vis -> TyVar -> VarBndr TyVar vis #
Make a named binder
 var should be a type variable
mkTyVarBinders :: vis -> [TyVar] -> [VarBndr TyVar vis] #
Make many named binders Input vars should be type variables
tyVarSpecToBinders :: [VarBndr a Specificity] -> [VarBndr a ArgFlag] #
data Specificity #
Whether an Invisible argument may appear in source Haskell.
Constructors
| InferredSpec | the argument may not appear in source Haskell, it is only inferred. | 
| SpecifiedSpec | the argument may appear in source Haskell, but isn't required. | 
Instances
type TyCoVarBinder = VarBndr TyCoVar ArgFlag #
Variable Binder
A TyCoVarBinder is the binder of a ForAllTy
 It's convenient to define this synonym here rather its natural
 home in GHC.Core.TyCo.Rep, because it's used in GHC.Core.DataCon.hs-boot
A TyVarBinder is a binder with only TyVar
type TyVarBinder = VarBndr TyVar ArgFlag #
isConstraintKindCon :: TyCon -> Bool #
Returns True for the TyCon of the Constraint kind.
foldTyCo :: Monoid a => TyCoFolder env a -> env -> (Type -> a, [Type] -> a, Coercion -> a, [Coercion] -> a) #
isInvisibleBinder :: TyCoBinder -> Bool #
Does this binder bind an invisible argument?
isNamedBinder :: TyCoBinder -> Bool #
isVisibleBinder :: TyCoBinder -> Bool #
Does this binder bind a visible argument?
mkForAllTys :: [TyCoVarBinder] -> Type -> Type #
Wraps foralls over the type using the provided TyCoVars from left to right
mkInvisForAllTys :: [InvisTVBinder] -> Type -> Type #
Wraps foralls over the type using the provided InvisTVBinders from left to right
mkInvisFunTyMany :: Type -> Type -> Type infixr 3 #
mkInvisFunTysMany :: [Type] -> Type -> Type #
mkPiTy :: TyCoBinder -> Type -> Type #
mkPiTys :: [TyCoBinder] -> Type -> Type #
mkTyConApp :: TyCon -> [Type] -> Type #
Create the plain type constructor type which has been applied to no type arguments at all.
mkTyVarTys :: [TyVar] -> [Type] #
mkVisFunTyMany :: Type -> Type -> Type infixr 3 #
Special, common, case: Arrow type with mult Many
mkVisFunTysMany :: [Type] -> Type -> Type #
type KindOrType = Type #
The key representation of types within the compiler
A type labeled KnotTied might have knot-tied tycons in it. See
 Note [Type checking recursive type and class declarations] in
 GHC.Tc.TyCl
data TyCoFolder env a #
Constructors
| TyCoFolder | |
| Fields 
 | |
closeOverKinds :: TyCoVarSet -> TyCoVarSet #
closeOverKindsDSet :: DTyVarSet -> DTyVarSet #
Add the kind variables free in the kinds of the tyvars in the given set. Returns a deterministic set.
closeOverKindsList :: [TyVar] -> [TyVar] #
Add the kind variables free in the kinds of the tyvars in the given set. Returns a deterministically ordered list.
coVarsOfType :: Type -> CoVarSet #
coVarsOfTypes :: [Type] -> CoVarSet #
noFreeVarsOfType :: Type -> Bool #
scopedSort :: [TyCoVar] -> [TyCoVar] #
Do a topological sort on a list of tyvars, so that binders occur before occurrences E.g. given [ a::k, k::*, b::k ] it'll return a well-scoped list [ k::*, a::k, b::k ]
This is a deterministic sorting operation (that is, doesn't depend on Uniques).
It is also meant to be stable: that is, variables should not be reordered unnecessarily. This is specified in Note [ScopedSort] See also Note [Ordering of implicit variables] in GHC.Rename.HsType
tyCoFVsBndr :: TyCoVarBinder -> FV -> FV #
tyCoFVsOfType :: Type -> FV #
The worker for tyCoFVsOfType and tyCoFVsOfTypeList.
 The previous implementation used unionVarSet which is O(n+m) and can
 make the function quadratic.
 It's exported, so that it can be composed with
 other functions that compute free variables.
 See Note [FV naming conventions] in GHC.Utils.FV.
Eta-expanded because that makes it run faster (apparently) See Note [FV eta expansion] in GHC.Utils.FV for explanation.
tyCoFVsVarBndr :: Var -> FV -> FV #
tyCoFVsVarBndrs :: [Var] -> FV -> FV #
tyCoVarsOfType :: Type -> TyCoVarSet #
tyCoVarsOfTypeDSet :: Type -> DTyCoVarSet #
tyCoFVsOfType that returns free variables of a type in a deterministic
 set. For explanation of why using VarSet is not deterministic see
 Note [Deterministic FV] in GHC.Utils.FV.
tyCoVarsOfTypeWellScoped :: Type -> [TyVar] #
Get the free vars of a type in scoped order
tyCoVarsOfTypes :: [Type] -> TyCoVarSet #
tyCoVarsOfTypesWellScoped :: [Type] -> [TyVar] #
Get the free vars of types in scoped order
tidyFreeTyCoVars :: TidyEnv -> [TyCoVar] -> TidyEnv #
Add the free TyVars to the env in tidy form,
 so that we can tidy the type they are free in
tidyOpenTyCoVar :: TidyEnv -> TyCoVar -> (TidyEnv, TyCoVar) #
Treat a new TyCoVar as a binder, and give it a fresh tidy name
 using the environment if one has not already been allocated. See
 also tidyVarBndr
tidyOpenTypes :: TidyEnv -> [Type] -> (TidyEnv, [Type]) #
Grabs the free type variables, tidies them
 and then uses tidyType to work over the type itself
tidyTopType :: Type -> Type #
Calls tidyType on a top-level type (i.e. with an empty tidying environment)
tidyTyCoVarOcc :: TidyEnv -> TyCoVar -> TyCoVar #
tidyVarBndrs :: TidyEnv -> [TyCoVar] -> (TidyEnv, [TyCoVar]) #
This tidies up a type for printing in an error message, or in an interface file.
It doesn't change the uniques at all, just the print names.
cloneTyVarBndrs :: TCvSubst -> [TyVar] -> UniqSupply -> (TCvSubst, [TyVar]) #
composeTCvSubst :: TCvSubst -> TCvSubst -> TCvSubst #
Composes two substitutions, applying the second one provided first, like in function composition.
composeTCvSubstEnv :: InScopeSet -> (TvSubstEnv, CvSubstEnv) -> (TvSubstEnv, CvSubstEnv) -> (TvSubstEnv, CvSubstEnv) #
(compose env1 env2)(x) is env1(env2(x)); i.e. apply env2 then env1.
 It assumes that both are idempotent.
 Typically, env1 is the refinement to a base substitution env2
extendTCvInScope :: TCvSubst -> Var -> TCvSubst #
extendTCvInScopeList :: TCvSubst -> [Var] -> TCvSubst #
extendTCvInScopeSet :: TCvSubst -> VarSet -> TCvSubst #
extendTvSubstBinderAndInScope :: TCvSubst -> TyCoBinder -> Type -> TCvSubst #
getTCvInScope :: TCvSubst -> InScopeSet #
getTCvSubstRangeFVs :: TCvSubst -> VarSet #
Returns the free variables of the types in the range of a substitution as a non-deterministic set.
getTvSubstEnv :: TCvSubst -> TvSubstEnv #
isEmptyTCvSubst :: TCvSubst -> Bool #
mkEmptyTCvSubst :: InScopeSet -> TCvSubst #
mkTCvSubst :: InScopeSet -> (TvSubstEnv, CvSubstEnv) -> TCvSubst #
mkTvSubstPrs :: [(TyVar, Type)] -> TCvSubst #
Generates the in-scope set for the TCvSubst from the types in the
 incoming environment. No CoVars, please!
notElemTCvSubst :: Var -> TCvSubst -> Bool #
setTvSubstEnv :: TCvSubst -> TvSubstEnv -> TCvSubst #
substCoUnchecked :: TCvSubst -> Coercion -> Coercion #
Substitute within a Coercion disabling sanity checks.
 The problems that the sanity checks in substCo catch are described in
 Note [The substitution invariant].
 The goal of #11371 is to migrate all the calls of substCoUnchecked to
 substCo and remove this function. Please don't use in new code.
substCoWithUnchecked :: [TyVar] -> [Type] -> Coercion -> Coercion #
Coercion substitution, see zipTvSubst. Disables sanity checks.
 The problems that the sanity checks in substCo catch are described in
 Note [The substitution invariant].
 The goal of #11371 is to migrate all the calls of substCoUnchecked to
 substCo and remove this function. Please don't use in new code.
substScaledTy :: HasCallStack => TCvSubst -> Scaled Type -> Scaled Type #
substScaledTyUnchecked :: HasCallStack => TCvSubst -> Scaled Type -> Scaled Type #
substScaledTys :: HasCallStack => TCvSubst -> [Scaled Type] -> [Scaled Type] #
substTheta :: HasCallStack => TCvSubst -> ThetaType -> ThetaType #
Substitute within a ThetaType
 The substitution has to satisfy the invariants described in
 Note [The substitution invariant].
substThetaUnchecked :: TCvSubst -> ThetaType -> ThetaType #
Substitute within a ThetaType disabling the sanity checks.
 The problems that the sanity checks in substTys catch are described in
 Note [The substitution invariant].
 The goal of #11371 is to migrate all the calls of substThetaUnchecked to
 substTheta and remove this function. Please don't use in new code.
substTyAddInScope :: TCvSubst -> Type -> Type #
Substitute within a Type after adding the free variables of the type
 to the in-scope set. This is useful for the case when the free variables
 aren't already in the in-scope set or easily available.
 See also Note [The substitution invariant].
substTyUnchecked :: TCvSubst -> Type -> Type #
Substitute within a Type disabling the sanity checks.
 The problems that the sanity checks in substTy catch are described in
 Note [The substitution invariant].
 The goal of #11371 is to migrate all the calls of substTyUnchecked to
 substTy and remove this function. Please don't use in new code.
substTyVar :: TCvSubst -> TyVar -> Type #
substTyVarBndr :: HasCallStack => TCvSubst -> TyVar -> (TCvSubst, TyVar) #
substTyVarBndrs :: HasCallStack => TCvSubst -> [TyVar] -> (TCvSubst, [TyVar]) #
substTyVars :: TCvSubst -> [TyVar] -> [Type] #
substTyWith :: HasCallStack => [TyVar] -> [Type] -> Type -> Type #
Type substitution, see zipTvSubst
substTyWithUnchecked :: [TyVar] -> [Type] -> Type -> Type #
Type substitution, see zipTvSubst. Disables sanity checks.
 The problems that the sanity checks in substTy catch are described in
 Note [The substitution invariant].
 The goal of #11371 is to migrate all the calls of substTyUnchecked to
 substTy and remove this function. Please don't use in new code.
substTys :: HasCallStack => TCvSubst -> [Type] -> [Type] #
Substitute within several Types
 The substitution has to satisfy the invariants described in
 Note [The substitution invariant].
substTysUnchecked :: TCvSubst -> [Type] -> [Type] #
Substitute within several Types disabling the sanity checks.
 The problems that the sanity checks in substTys catch are described in
 Note [The substitution invariant].
 The goal of #11371 is to migrate all the calls of substTysUnchecked to
 substTys and remove this function. Please don't use in new code.
substTysWith :: [TyVar] -> [Type] -> [Type] -> [Type] #
Type substitution, see zipTvSubst
substVarBndr :: HasCallStack => TCvSubst -> TyCoVar -> (TCvSubst, TyCoVar) #
substVarBndrs :: HasCallStack => TCvSubst -> [TyCoVar] -> (TCvSubst, [TyCoVar]) #
unionTCvSubst :: TCvSubst -> TCvSubst -> TCvSubst #
zapTCvSubst :: TCvSubst -> TCvSubst #
zipCoEnv :: HasDebugCallStack => [CoVar] -> [Coercion] -> CvSubstEnv #
zipTCvSubst :: HasDebugCallStack => [TyCoVar] -> [Type] -> TCvSubst #
zipTvSubst :: HasDebugCallStack => [TyVar] -> [Type] -> TCvSubst #
Generates the in-scope set for the TCvSubst from the types in the incoming
 environment. No CoVars, please!
zipTyEnv :: HasDebugCallStack => [TyVar] -> [Type] -> TvSubstEnv #
Type & coercion substitution
 The following invariants must hold of a TCvSubst:
- The in-scope set is needed only to guide the generation of fresh uniques
- In particular, the kind of the type variables in the in-scope set is not relevant
- The substitution is only applied ONCE! This is because in general such application will not reach a fixed point.
Constructors
| TCvSubst InScopeSet TvSubstEnv CvSubstEnv | 
The FUN type constructor.
FUN :: forall {m :: Multiplicity} {rep1 :: RuntimeRep} {rep2 :: RuntimeRep}.
        TYPE rep1 -> TYPE rep2 -> *
The runtime representations quantification is left inferred. This
 means they cannot be specified with -XTypeApplications.
This is a deliberate choice to allow future extensions to the function arrow. To allow visible application a type synonym can be defined:
type Arr :: forall (rep1 :: RuntimeRep) (rep2 :: RuntimeRep).
            TYPE rep1 -> TYPE rep2 -> Type
type Arr = FUN
appTyArgFlags :: Type -> [Type] -> [ArgFlag] #
Given a Type and a list of argument types to which the Type is
 applied, determine each argument's visibility
 (Inferred, Specified, or Required).
Most of the time, the arguments will be Required, but not always. Consider
 f :: forall a. a -> Type. In f Type Bool, the first argument (Type) is
 Specified and the second argument (Bool) is Required. It is precisely
 this sort of higher-rank situation in which appTyArgFlags comes in handy,
 since f Type Bool would be represented in Core using AppTys.
 (See also #15792).
binderRelevantType_maybe :: TyCoBinder -> Maybe Type #
Extract a relevant type, if there is one.
classifiesTypeWithValues :: Kind -> Bool #
Does this classify a type allowed to have values? Responds True to things like *, #, TYPE Lifted, TYPE v, Constraint.
True of any sub-kind of OpenTypeKind
coAxNthLHS :: CoAxiom br -> Int -> Type #
Get the type on the LHS of a coercion induced by a type/data family instance.
dropForAlls :: Type -> Type #
Drops all ForAllTys
dropRuntimeRepArgs :: [Type] -> [Type] #
Drops prefix of RuntimeRep constructors in TyConApps. Useful for e.g.
 dropping 'LiftedRep arguments of unboxed tuple TyCon applications:
dropRuntimeRepArgs [ 'LiftedRep, 'IntRep , String, Int# ] == [String, Int#]
eqType :: Type -> Type -> Bool #
Type equality on source types. Does not look through newtypes or
 PredTypes, but it does look through type synonyms.
 This first checks that the kinds of the types are equal and then
 checks whether the types are equal, ignoring casts and coercions.
 (The kind check is a recursive call, but since all kinds have type
 Type, there is no need to check the types of kinds.)
 See also Note [Non-trivial definitional equality] in GHC.Core.TyCo.Rep.
eqTypeX :: RnEnv2 -> Type -> Type -> Bool #
Compare types with respect to a (presumably) non-empty RnEnv2.
eqTypes :: [Type] -> [Type] -> Bool #
Type equality on lists of types, looking through type synonyms but not newtypes.
expandTypeSynonyms :: Type -> Type #
Expand out all type synonyms. Actually, it'd suffice to expand out just the ones that discard type variables (e.g. type Funny a = Int) But we don't know which those are currently, so we just expand all.
expandTypeSynonyms only expands out type synonyms mentioned in the type,
 not in the kinds of any TyCon or TyVar mentioned in the type.
Keep this synchronized with synonymTyConsOfType
filterOutInferredTypes :: TyCon -> [Type] -> [Type] #
filterOutInvisibleTypes :: TyCon -> [Type] -> [Type] #
Just like piResultTys but for a single argument
 Try not to iterate piResultTy, because it's inefficient to substitute
 one variable at a time; instead use 'piResultTys"
Extract the function argument type and panic if that is not possible
funResultTy :: Type -> Type #
Extract the function result type and panic if that is not possible
getCastedTyVar_maybe :: Type -> Maybe (TyVar, CoercionN) #
If the type is a tyvar, possibly under a cast, returns it, along with the coercion. Thus, the co is :: kind tv ~N kind ty
getRuntimeRep :: HasDebugCallStack => Type -> Type #
Extract the RuntimeRep classifier of a type. For instance,
 getRuntimeRep_maybe Int = LiftedRep. Panics if this is not possible.
getRuntimeRep_maybe :: HasDebugCallStack => Type -> Maybe Type #
Extract the RuntimeRep classifier of a type. For instance,
 getRuntimeRep_maybe Int = LiftedRep. Returns Nothing if this is not
 possible.
getTyVar :: String -> Type -> TyVar #
Attempts to obtain the type variable underlying a Type, and panics with the
 given message if this is not a type variable type. See also getTyVar_maybe
invisibleTyBndrCount :: Type -> Int #
irrelevantMult :: Scaled a -> a #
See Type for what an algebraic type is. Should only be applied to types, as opposed to e.g. partially saturated type constructors
isAnonTyCoBinder :: TyCoBinder -> Bool #
Does this binder bind a variable that is not erased? Returns
 True for anonymous binders.
isAtomicTy :: Type -> Bool #
isCoVarType :: Type -> Bool #
Does this type classify a core (unlifted) Coercion? At either role nominal or representational (t1 ~# t2) or (t1 ~R# t2) See Note [Types for coercions, predicates, and evidence] in GHC.Core.TyCo.Rep
isCoercionTy_maybe :: Type -> Maybe Coercion #
isDataFamilyAppType :: Type -> Bool #
Check whether a type is a data family type
isFamFreeTy :: Type -> Bool #
isForAllTy :: Type -> Bool #
Checks whether this is a proper forall (with a named binder)
isForAllTy_co :: Type -> Bool #
Like isForAllTy, but returns True only if it is a covar binder
isForAllTy_ty :: Type -> Bool #
Like isForAllTy, but returns True only if it is a tyvar binder
isKindLevPoly :: Kind -> Bool #
Tests whether the given kind (which should look like TYPE x)
 is something other than a constructor tree (that is, constructors at every node).
 E.g.  True of   TYPE k, TYPE (F Int)
       False of  TYPE 'LiftedRep
isLiftedRuntimeRep :: Type -> Bool #
isLiftedType_maybe :: HasDebugCallStack => Type -> Maybe Bool #
Returns Just True if this type is surely lifted, Just False if it is surely unlifted, Nothing if we can't be sure (i.e., it is levity polymorphic), and panics if the kind does not have the shape TYPE r.
isLinearType :: Type -> Bool #
isManyDataConTy :: Mult -> Bool #
isMultiplicityVar :: TyVar -> Bool #
Is a tyvar of type Multiplicity?
isNumLitTy :: Type -> Maybe Integer #
Is this a numeric literal. We also look through type synonyms.
isOneDataConTy :: Mult -> Bool #
isPrimitiveType :: Type -> Bool #
Returns true of types that are opaque to Haskell.
isRuntimeRepKindedTy :: Type -> Bool #
Is this a type of kind RuntimeRep? (e.g. LiftedRep)
isRuntimeRepVar :: TyVar -> Bool #
Is a tyvar of type RuntimeRep?
isStrLitTy :: Type -> Maybe FastString #
Is this a symbol literal. We also look through type synonyms.
isStrictType :: HasDebugCallStack => Type -> Bool #
Computes whether an argument (or let right hand side) should
 be computed strictly or lazily, based only on its type.
 Currently, it's just isUnliftedType. Panics on levity-polymorphic types.
isTypeLevPoly :: Type -> Bool #
Returns True if a type is levity polymorphic. Should be the same as (isKindLevPoly . typeKind) but much faster. Precondition: The type has kind (TYPE blah)
isUnboxedSumType :: Type -> Bool #
isUnboxedTupleType :: Type -> Bool #
isUnliftedRuntimeRep :: Type -> Bool #
isUnliftedType :: HasDebugCallStack => Type -> Bool #
See Type for what an unlifted type is.
 Panics on levity polymorphic types; See mightBeUnliftedType for
 a more approximate predicate that behaves better in the presence of
 levity polymorphism.
isUnliftedTypeKind :: Kind -> Bool #
Returns True if the kind classifies unlifted types and False otherwise. Note that this returns False for levity-polymorphic kinds, which may be specialized to a kind that classifies unlifted types.
isValidJoinPointType :: JoinArity -> Type -> Bool #
Determine whether a type could be the type of a join point of given total
 arity, according to the polymorphism rule. A join point cannot be polymorphic
 in its return type, since given
   join j a b x y z = e1 in e2,
 the types of e1 and e2 must be the same, and a and b are not in scope for e2.
 (See Note [The polymorphism rule of join points] in GHC.Core.) Returns False
 also if the type simply doesn't have enough arguments.
Note that we need to know how many arguments (type *and* value) the putative join point takes; for instance, if j :: forall a. a -> Int then j could be a binary join point returning an Int, but it could *not* be a unary join point returning a -> Int.
TODO: See Note [Excess polymorphism and join points]
kindRep :: HasDebugCallStack => Kind -> Type #
Extract the RuntimeRep classifier of a type from its kind. For example,
 kindRep * = LiftedRep; Panics if this is not possible.
 Treats * and Constraint as the same
kindRep_maybe :: HasDebugCallStack => Kind -> Maybe Type #
Given a kind (TYPE rr), extract its RuntimeRep classifier rr.
 For example, kindRep_maybe * = Just LiftedRep
 Returns Nothing if the kind is not of form (TYPE rr)
 Treats * and Constraint as the same
mapTyCo :: Monad m => TyCoMapper () m -> (Type -> m Type, [Type] -> m [Type], Coercion -> m Coercion, [Coercion] -> m [Coercion]) #
mapTyCoX :: Monad m => TyCoMapper env m -> (env -> Type -> m Type, env -> [Type] -> m [Type], env -> Coercion -> m Coercion, env -> [Coercion] -> m [Coercion]) #
mightBeUnliftedType :: Type -> Bool #
mkAnonBinder :: AnonArgFlag -> Scaled Type -> TyCoBinder #
Make an anonymous binder
mkCoercionTy :: Coercion -> Type #
mkFamilyTyConApp :: TyCon -> [Type] -> Type #
Given a family instance TyCon and its arg types, return the corresponding family type. E.g:
data family T a data instance T (Maybe b) = MkT b
Where the instance tycon is :RTL, so:
mkFamilyTyConApp :RTL Int = T (Maybe Int)
mkInfForAllTy :: TyVar -> Type -> Type #
Like mkTyCoInvForAllTy, but tv should be a tyvar
mkInfForAllTys :: [TyVar] -> Type -> Type #
Like mkTyCoInvForAllTys, but tvs should be a list of tyvar
mkNumLitTy :: Integer -> Type #
mkSpecForAllTy :: TyVar -> Type -> Type #
Like mkForAllTy, but assumes the variable is dependent and Specified,
 a common case
mkSpecForAllTys :: [TyVar] -> Type -> Type #
Like mkForAllTys, but assumes all variables are dependent and
 Specified, a common case
mkStrLitTy :: FastString -> Type #
mkTyCoInvForAllTys :: [TyCoVar] -> Type -> Type #
Like mkForAllTys, but assumes all variables are dependent and
 Inferred, a common case
Arguments
| :: [TyVar] | binders | 
| -> TyCoVarSet | free variables of result | 
| -> [TyConBinder] | 
Given a list of type-level vars and the free vars of a result kind, makes TyCoBinders, preferring anonymous binders if the variable is, in fact, not dependent. e.g. mkTyConBindersPreferAnon (k:*),(b:k),(c:k) We want (k:*) Named, (b:k) Anon, (c:k) Anon
All non-coercion binders are visible.
mkVisForAllTys :: [TyVar] -> Type -> Type #
Like mkForAllTys, but assumes all variables are dependent and visible
newTyConInstRhs :: TyCon -> [Type] -> Type #
Unwrap one layer of newtype on a type constructor and its
 arguments, using an eta-reduced version of the newtype if possible.
 This requires tys to have at least newTyConInstArity tycon elements.
nonDetCmpTc :: TyCon -> TyCon -> Ordering #
Compare two TyCons. NB: This should never see Constraint (as
 recognized by Kind.isConstraintKindCon) which is considered a synonym for
 Type in Core.
 See Note [Kind Constraint and kind Type] in GHC.Core.Type.
 See Note [nonDetCmpType nondeterminism]
nonDetCmpType :: Type -> Type -> Ordering #
nonDetCmpTypes :: [Type] -> [Type] -> Ordering #
partitionInvisibles :: [(a, ArgFlag)] -> ([a], [a]) #
Given a list of things paired with their visibilities, partition the things into (invisible things, visible things).
piResultTys :: HasDebugCallStack => Type -> [Type] -> Type #
(piResultTys f_ty [ty1, .., tyn]) gives the type of (f ty1 .. tyn)
   where f :: f_ty
 piResultTys is interesting because:
      1. f_ty may have more for-alls than there are args
      2. Less obviously, it may have fewer for-alls
 For case 2. think of:
   piResultTys (forall a.a) [forall b.b, Int]
 This really can happen, but only (I think) in situations involving
 undefined.  For example:
       undefined :: forall a. a
 Term: undefined (forall b. b->b) Int
 This term should have type (Int -> Int), but notice that
 there are more type args than foralls in undefineds type.
pprUserTypeErrorTy :: Type -> SDoc #
Render a type corresponding to a user type error into a SDoc.
repGetTyVar_maybe :: Type -> Maybe TyVar #
Attempts to obtain the type variable underlying a Type, without
 any expansion
repSplitAppTy_maybe :: HasDebugCallStack => Type -> Maybe (Type, Type) #
Does the AppTy split as in splitAppTy_maybe, but assumes that
 any Core view stuff is already done
repSplitAppTys :: HasDebugCallStack => Type -> (Type, [Type]) #
Like splitAppTys, but doesn't look through type synonyms
repSplitTyConApp_maybe :: HasDebugCallStack => Type -> Maybe (TyCon, [Type]) #
Like splitTyConApp_maybe, but doesn't look through synonyms. This
 assumes the synonyms have already been dealt with.
Moreover, for a FunTy, it only succeeds if the argument types have enough info to extract the runtime-rep arguments that the funTyCon requires. This will usually be true; but may be temporarily false during canonicalization: see Note [FunTy and decomposing tycon applications] in GHC.Tc.Solver.Canonical
resultIsLevPoly :: Type -> Bool #
Looking past all pi-types, is the end result potentially levity polymorphic? Example: True for (forall r (a :: TYPE r). String -> a) Example: False for (forall r1 r2 (a :: TYPE r1) (b :: TYPE r2). a -> b -> Type)
splitAppTy :: Type -> (Type, Type) #
Attempts to take a type application apart, as in splitAppTy_maybe,
 and panics if this is not possible
splitAppTy_maybe :: Type -> Maybe (Type, Type) #
Attempt to take a type application apart, whether it is a function, type constructor, or plain type application. Note that type family applications are NEVER unsaturated by this!
splitAppTys :: Type -> (Type, [Type]) #
Recursively splits a type as far as is possible, leaving a residual type being applied to and the type arguments applied to it. Never fails, even if that means returning an empty list of type applications.
splitForAllTy :: Type -> (TyCoVar, Type) #
Take a forall type apart, or panics if that is not possible.
splitForAllTy_co_maybe :: Type -> Maybe (TyCoVar, Type) #
Like splitForAllTy_maybe, but only returns Just if it is a covar binder.
splitForAllTy_maybe :: Type -> Maybe (TyCoVar, Type) #
Attempts to take a forall type apart, but only if it's a proper forall, with a named binder
splitForAllTy_ty_maybe :: Type -> Maybe (TyCoVar, Type) #
Like splitForAllTy_maybe, but only returns Just if it is a tyvar binder.
splitForAllTys :: Type -> ([TyCoVar], Type) #
Take a ForAllTy apart, returning the list of tycovars and the result type. This always succeeds, even if it returns only an empty list. Note that the result type returned may have free variables that were bound by a forall.
splitForAllTysInvis :: Type -> ([InvisTVBinder], Type) #
Like splitForAllTys, but only splits ForAllTys with Invisible type
 variable binders. Furthermore, each returned tyvar is annotated with its
 Specificity.
splitForAllTysReq :: Type -> ([ReqTVBinder], Type) #
Like splitForAllTys, but only splits ForAllTys with Required type
 variable binders. Furthermore, each returned tyvar is annotated with ().
splitForAllVarBndrs :: Type -> ([TyCoVarBinder], Type) #
Like splitPiTys but split off only named binders
   and returns TyCoVarBinders rather than TyCoBinders
splitFunTy :: Type -> (Type, Type, Type) #
Attempts to extract the argument and result types from a type, and
 panics if that is not possible. See also splitFunTy_maybe
splitFunTy_maybe :: Type -> Maybe (Type, Type, Type) #
Attempts to extract the argument and result types from a type
splitListTyConApp_maybe :: Type -> Maybe Type #
Attempts to tease a list type apart and gives the type of the elements if successful (looks through type synonyms)
splitPiTy :: Type -> (TyCoBinder, Type) #
Takes a forall type apart, or panics
splitPiTy_maybe :: Type -> Maybe (TyCoBinder, Type) #
Attempts to take a forall type apart; works with proper foralls and functions
splitPiTys :: Type -> ([TyCoBinder], Type) #
Split off all TyCoBinders to a type, splitting both proper foralls and functions
splitPiTysInvisible :: Type -> ([TyCoBinder], Type) #
splitPiTysInvisibleN :: Int -> Type -> ([TyCoBinder], Type) #
splitTyConApp :: Type -> (TyCon, [Type]) #
Attempts to tease a type apart into a type constructor and the application
 of a number of arguments to that constructor. Panics if that is not possible.
 See also splitTyConApp_maybe
splitVisVarsOfType :: Type -> Pair TyCoVarSet #
Retrieve the free variables in this type, splitting them based on whether they are used visibly or invisibly. Invisible ones come first.
splitVisVarsOfTypes :: [Type] -> Pair TyCoVarSet #
stripCoercionTy :: Type -> Coercion #
synTyConResKind :: TyCon -> Kind #
tcIsConstraintKind :: Kind -> Bool #
tcIsLiftedTypeKind :: Kind -> Bool #
Is this kind equivalent to *?
This considers Constraint to be distinct from *. For a version that
 treats them as the same type, see isLiftedTypeKind.
tcIsRuntimeTypeKind :: Kind -> Bool #
Is this kind equivalent to TYPE r (for some unknown r)?
This considers Constraint to be distinct from *.
tcRepSplitAppTy_maybe :: Type -> Maybe (Type, Type) #
Does the AppTy split as in tcSplitAppTy_maybe, but assumes that
 any coreView stuff is already done. Refuses to look through (c => t)
tcReturnsConstraintKind :: Kind -> Bool #
tcSplitTyConApp_maybe :: HasCallStack => Type -> Maybe (TyCon, [Type]) #
Split a type constructor application into its type constructor and
 applied types. Note that this may fail in the case of a FunTy with an
 argument of unknown kind FunTy (e.g. FunTy (a :: k) Int. since the kind
 of a isn't of the form TYPE rep). Consequently, you may need to zonk your
 type before using this function.
If you only need the TyCon, consider using tcTyConAppTyCon_maybe.
tcTypeKind :: HasDebugCallStack => Type -> Kind #
tyBinderType :: TyBinder -> Type #
tyCoBinderType :: TyCoBinder -> Type #
tyConAppArgN :: Int -> Type -> Type #
tyConAppArgs :: Type -> [Type] #
tyConAppArgs_maybe :: Type -> Maybe [Type] #
The same as snd . splitTyConApp
Arguments
| :: Bool | Should specified binders count towards injective positions in the kind of the TyCon? (If you're using visible kind applications, then you want True here. | 
| -> TyCon | |
| -> Int | The number of args the  | 
| -> Bool | Does  | 
Does a TyCon (that is applied to some number of arguments) need to be
 ascribed with an explicit kind signature to resolve ambiguity if rendered as
 a source-syntax type?
 (See Note [When does a tycon application need an explicit kind signature?]
 for a full explanation of what this function checks for.)
tyConAppTyCon :: Type -> TyCon #
tyConAppTyConPicky_maybe :: Type -> Maybe TyCon #
Retrieve the tycon heading this type, if there is one. Does not look through synonyms.
tyConArgFlags :: TyCon -> [Type] -> [ArgFlag] #
Given a TyCon and a list of argument types to which the TyCon is
 applied, determine each argument's visibility
 (Inferred, Specified, or Required).
Wrinkle: consider the following scenario:
T :: forall k. k -> k tyConArgFlags T [forall m. m -> m -> m, S, R, Q]
After substituting, we get
T (forall m. m -> m -> m) :: (forall m. m -> m -> m) -> forall n. n -> n -> n
Thus, the first argument is invisible, S is visible, R is invisible again,
 and Q is visible.
tyConBindersTyCoBinders :: [TyConBinder] -> [TyCoBinder] #
tyConsOfType :: Type -> UniqSet TyCon #
All type constructors occurring in the type; looking through type synonyms, but not newtypes. When it finds a Class, it returns the class TyCon.
typeKind :: HasDebugCallStack => Type -> Kind #
unrestricted :: a -> Scaled a #
Scale a payload by Many
userTypeError_maybe :: Type -> Maybe Type #
Is this type a custom user error? If so, give us the kind and the error message.
data TyCoMapper env m #
This describes how a "map" operation over a type/coercion should behave
Constructors
| TyCoMapper | |
| Fields 
 | |
module GHC.Core.TyCon
Variable
Essentially a typed Name, that may also contain some additional information
 about the Var and its use sites.
Instances
| Data Var # | |
| Defined in GHC.Types.Var Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Var -> c Var Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Var Source # toConstr :: Var -> Constr Source # dataTypeOf :: Var -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Var) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Var) Source # gmapT :: (forall b. Data b => b -> b) -> Var -> Var Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Var -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Var -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Var -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Var -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Var -> m Var Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Var -> m Var Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Var -> m Var Source # | |
| NamedThing Var # | |
| Defined in GHC.Types.Var | |
| HasOccName Var # | |
| Defined in GHC.Types.Var | |
| Uniquable Var # | |
| Defined in GHC.Types.Var | |
| Outputable Var # | |
| OutputableBndr Var # | |
| Defined in GHC.Core.Ppr Methods pprBndr :: BindingSite -> Var -> SDoc # pprPrefixOcc :: Var -> SDoc # pprInfixOcc :: Var -> SDoc # bndrIsJoin_maybe :: Var -> Maybe Int # | |
| Eq Var # | |
| Ord Var # | |
pickLR :: LeftOrRight -> (a, a) -> a #
data LeftOrRight #
Instances
| Data LeftOrRight # | |
| Defined in GHC.Types.Basic Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LeftOrRight -> c LeftOrRight Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c LeftOrRight Source # toConstr :: LeftOrRight -> Constr Source # dataTypeOf :: LeftOrRight -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c LeftOrRight) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LeftOrRight) Source # gmapT :: (forall b. Data b => b -> b) -> LeftOrRight -> LeftOrRight Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LeftOrRight -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LeftOrRight -> r Source # gmapQ :: (forall d. Data d => d -> u) -> LeftOrRight -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> LeftOrRight -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> LeftOrRight -> m LeftOrRight Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LeftOrRight -> m LeftOrRight Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LeftOrRight -> m LeftOrRight Source # | |
| Binary LeftOrRight # | |
| Defined in GHC.Utils.Binary Methods put_ :: BinHandle -> LeftOrRight -> IO () # put :: BinHandle -> LeftOrRight -> IO (Bin LeftOrRight) # get :: BinHandle -> IO LeftOrRight # | |
| Outputable LeftOrRight # | |
| Defined in GHC.Types.Basic | |
| Eq LeftOrRight # | |
| Defined in GHC.Types.Basic | |
A Coercion is concrete evidence of the equality/convertibility
 of two types.
Instances
| Data Coercion # | |
| Defined in GHC.Core.TyCo.Rep Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Coercion -> c Coercion Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Coercion Source # toConstr :: Coercion -> Constr Source # dataTypeOf :: Coercion -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Coercion) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Coercion) Source # gmapT :: (forall b. Data b => b -> b) -> Coercion -> Coercion Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Coercion -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Coercion -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Coercion -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Coercion -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Coercion -> m Coercion Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Coercion -> m Coercion Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Coercion -> m Coercion Source # | |
| Outputable Coercion # | |
A semantically more meaningful type to represent what may or may not be a
 useful Coercion.
Instances
| Data MCoercion # | |
| Defined in GHC.Core.TyCo.Rep Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MCoercion -> c MCoercion Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c MCoercion Source # toConstr :: MCoercion -> Constr Source # dataTypeOf :: MCoercion -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c MCoercion) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MCoercion) Source # gmapT :: (forall b. Data b => b -> b) -> MCoercion -> MCoercion Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MCoercion -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MCoercion -> r Source # gmapQ :: (forall d. Data d => d -> u) -> MCoercion -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> MCoercion -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> MCoercion -> m MCoercion Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MCoercion -> m MCoercion Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MCoercion -> m MCoercion Source # | |
| Outputable MCoercion # | |
data UnivCoProvenance #
For simplicity, we have just one UnivCo that represents a coercion from
 some type to some other type, with (in general) no restrictions on the
 type. The UnivCoProvenance specifies more exactly what the coercion really
 is and why a program should (or shouldn't!) trust the coercion.
 It is reasonable to consider each constructor of UnivCoProvenance
 as a totally independent coercion form; their only commonality is
 that they don't tell you what types they coercion between. (That info
 is in the UnivCo constructor of Coercion.
Instances
| Data UnivCoProvenance # | |
| Defined in GHC.Core.TyCo.Rep Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UnivCoProvenance -> c UnivCoProvenance Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c UnivCoProvenance Source # toConstr :: UnivCoProvenance -> Constr Source # dataTypeOf :: UnivCoProvenance -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c UnivCoProvenance) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UnivCoProvenance) Source # gmapT :: (forall b. Data b => b -> b) -> UnivCoProvenance -> UnivCoProvenance Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UnivCoProvenance -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UnivCoProvenance -> r Source # gmapQ :: (forall d. Data d => d -> u) -> UnivCoProvenance -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> UnivCoProvenance -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> UnivCoProvenance -> m UnivCoProvenance Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UnivCoProvenance -> m UnivCoProvenance Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UnivCoProvenance -> m UnivCoProvenance Source # | |
| Outputable UnivCoProvenance # | |
| Defined in GHC.Core.TyCo.Rep | |
Is this a coercion variable?
 Satisfies isId v ==> isCoVar v == not (isNonCoVarId v)
Constructors
| Nominal | |
| Representational | |
| Phantom | 
Instances
| Data Role # | |
| Defined in GHC.Core.Coercion.Axiom Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Role -> c Role Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Role Source # toConstr :: Role -> Constr Source # dataTypeOf :: Role -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Role) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Role) Source # gmapT :: (forall b. Data b => b -> b) -> Role -> Role Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Role -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Role -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Role -> m Role Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Role -> m Role Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Role -> m Role Source # | |
| Binary Role # | |
| Outputable Role # | |
| Eq Role # | |
| Ord Role # | |
coVarKindsTypesRole :: HasDebugCallStack => CoVar -> (Kind, Kind, Type, Type, Role) #
coercionKind :: Coercion -> Pair Type #
If it is the case that
c :: (t1 ~ t2)
i.e. the kind of c relates t1 and t2, then coercionKind c = Pair t1 t2.
coercionLKind :: Coercion -> Type #
coercionRKind :: Coercion -> Type #
coercionType :: Coercion -> Type #
decomposePiCos :: HasDebugCallStack => CoercionN -> Pair Type -> [Type] -> ([CoercionN], CoercionN) #
isGReflCo :: Coercion -> Bool #
Tests if this coercion is obviously a generalized reflexive coercion. Guaranteed to work very quickly.
isReflCo :: Coercion -> Bool #
Tests if this coercion is obviously reflexive. Guaranteed to work
 very quickly. Sometimes a coercion can be reflexive, but not obviously
 so. c.f. isReflexiveCo
isReflexiveCo :: Coercion -> Bool #
Slowly checks if the coercion is reflexive. Don't call this in a loop, as it walks over the entire coercion.
liftCoSubst :: HasDebugCallStack => Role -> LiftingContext -> Type -> Coercion #
liftCoSubst role lc ty produces a coercion (at role role)
 that coerces between lc_left(ty) and lc_right(ty), where
 lc_left is a substitution mapping type variables to the left-hand
 types of the mapped coercions in lc, and similar for lc_right.
mkAxiomInstCo :: CoAxiom Branched -> BranchIndex -> [Coercion] -> Coercion #
mkAxiomRuleCo :: CoAxiomRule -> [Coercion] -> Coercion #
mkCoercionType :: Role -> Type -> Type -> Type #
Makes a coercion type from two types: the types whose equality
 is proven by the relevant Coercion
mkForAllCo :: TyCoVar -> CoercionN -> Coercion -> Coercion #
Make a Coercion from a tycovar, a kind coercion, and a body coercion. The kind of the tycovar should be the left-hand kind of the kind coercion. See Note [Unused coercion variable in ForAllCo]
mkLRCo :: LeftOrRight -> Coercion -> Coercion #
mkNomReflCo :: Type -> Coercion #
Make a nominal reflexive coercion
mkPhantomCo :: Coercion -> Type -> Type -> Coercion #
Make a phantom coercion between two types. The coercion passed in must be a nominal coercion between the kinds of the types.
Arguments
| :: Role | role of the created coercion, "r" | 
| -> Coercion | :: phi1 ~N phi2 | 
| -> Coercion | g1 :: phi1 | 
| -> Coercion | g2 :: phi2 | 
| -> Coercion | :: g1 ~r g2 | 
Make a "coercion between coercions".
mkSymCo :: Coercion -> Coercion #
Create a symmetric version of the given Coercion that asserts
   equality between the same types but in the other "direction", so
   a kind of t1 ~ t2 becomes the kind t2 ~ t1.
mkTyConAppCo :: HasDebugCallStack => Role -> TyCon -> [Coercion] -> Coercion #
Apply a type constructor to a list of coercions. It is the caller's responsibility to get the roles correct on argument coercions.
Arguments
| :: UnivCoProvenance | |
| -> Role | role of the built coercion, "r" | 
| -> Type | t1 :: k1 | 
| -> Type | t2 :: k2 | 
| -> Coercion | :: t1 ~r t2 | 
Make a universal coercion between two arbitrary types.
data LiftingContext #
Instances
| Outputable LiftingContext # | |
| Defined in GHC.Core.Coercion | |
coHoleCoVar :: CoercionHole -> CoVar #
coercionSize :: Coercion -> Int #
setCoHoleCoVar :: CoercionHole -> CoVar -> CoercionHole #
data BlockSubstFlag #
Constructors
| YesBlockSubst | |
| NoBlockSubst | 
Instances
| Outputable BlockSubstFlag # | |
| Defined in GHC.Core.TyCo.Rep | |
data CoercionHole #
A coercion to be filled in by the type-checker. See Note [Coercion holes]
Constructors
| CoercionHole | |
| Fields 
 | |
Instances
| Data CoercionHole # | |
| Defined in GHC.Core.TyCo.Rep Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CoercionHole -> c CoercionHole Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CoercionHole Source # toConstr :: CoercionHole -> Constr Source # dataTypeOf :: CoercionHole -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c CoercionHole) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CoercionHole) Source # gmapT :: (forall b. Data b => b -> b) -> CoercionHole -> CoercionHole Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CoercionHole -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CoercionHole -> r Source # gmapQ :: (forall d. Data d => d -> u) -> CoercionHole -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> CoercionHole -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CoercionHole -> m CoercionHole Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CoercionHole -> m CoercionHole Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CoercionHole -> m CoercionHole Source # | |
| Outputable CoercionHole # | |
| Defined in GHC.Core.TyCo.Rep | |
type MCoercionR = MCoercion #
coVarsOfCo :: Coercion -> CoVarSet #
tyCoFVsOfCo :: Coercion -> FV #
tyCoFVsOfCos :: [Coercion] -> FV #
tyCoVarsOfCo :: Coercion -> TyCoVarSet #
tyCoVarsOfCoDSet :: Coercion -> DTyCoVarSet #
Get a deterministic set of the vars free in a coercion
tyCoVarsOfCos :: [Coercion] -> TyCoVarSet #
getCvSubstEnv :: TCvSubst -> CvSubstEnv #
substCoVar :: TCvSubst -> CoVar -> Coercion #
substCoVarBndr :: HasCallStack => TCvSubst -> CoVar -> (TCvSubst, CoVar) #
substCoVars :: TCvSubst -> [CoVar] -> [Coercion] #
substCoWith :: HasCallStack => [TyVar] -> [Type] -> Coercion -> Coercion #
Coercion substitution, see zipTvSubst
substCos :: HasCallStack => TCvSubst -> [Coercion] -> [Coercion] #
Substitute within several Coercions
 The substitution has to satisfy the invariants described in
 Note [The substitution invariant].
pprParendCo :: Coercion -> SDoc #
badCoercionHole :: Type -> Bool #
Is there a blocking coercion hole in this type? See GHC.Tc.Solver.Canonical Note [Equalities with incompatible kinds]
badCoercionHoleCo :: Coercion -> Bool #
Is there a blocking coercion hole in this coercion? See GHC.Tc.Solver.Canonical Note [Equalities with incompatible kinds]
buildCoercion :: Type -> Type -> CoercionN #
Assuming that two types are the same, ignoring coercions, find a nominal coercion between the types. This is useful when optimizing transitivity over coercion applications, where splitting two AppCos might yield different kinds. See Note [EtaAppCo] in GHC.Core.Coercion.Opt.
castCoercionKind :: Coercion -> CoercionN -> CoercionN -> Coercion #
Creates a new coercion with both of its types casted by different casts
 castCoercionKind g h1 h2, where g :: t1 ~r t2,
 has type (t1 |> h1) ~r (t2 |> h2).
 h1 and h2 must be nominal.
 It calls coercionKindRole, so it's quite inefficient (which I stands for)
 Use castCoercionKind2 instead if t1, t2, and r are known beforehand.
castCoercionKind1 :: Coercion -> Role -> Type -> Type -> CoercionN -> Coercion #
castCoercionKind1 g r t1 t2 h = coercionKind g r t1 t2 h h
 That is, it's a specialised form of castCoercionKind, where the two
          kind coercions are identical
 castCoercionKind1 g r t1 t2 h, where g :: t1 ~r t2,
 has type (t1 |> h) ~r (t2 |> h).
 h must be nominal.
 See Note [castCoercionKind1]
castCoercionKind2 :: Coercion -> Role -> Type -> Type -> CoercionN -> CoercionN -> Coercion #
Creates a new coercion with both of its types casted by different casts
 castCoercionKind2 g r t1 t2 h1 h2, where g :: t1 ~r t2,
 has type (t1 |> h1) ~r (t2 |> h2).
 h1 and h2 must be nominal.
coVarTypes :: HasDebugCallStack => CoVar -> Pair Type #
coercionKinds :: [Coercion] -> Pair [Type] #
Apply coercionKind to multiple Coercions
coercionRole :: Coercion -> Role #
Retrieve the role from a coercion.
composeSteppers :: NormaliseStepper ev -> NormaliseStepper ev -> NormaliseStepper ev #
Try one stepper and then try the next, if the first doesn't make progress. So if it returns NS_Done, it means that both steppers are satisfied
decomposeFunCo :: HasDebugCallStack => Role -> Coercion -> (CoercionN, Coercion, Coercion) #
downgradeRole :: Role -> Role -> Coercion -> Coercion #
Like downgradeRole_maybe, but panics if the change isn't a downgrade.
 See Note [Role twiddling functions]
eqCoercion :: Coercion -> Coercion -> Bool #
Syntactic equality of coercions
eqCoercionX :: RnEnv2 -> Coercion -> Coercion -> Bool #
Compare two Coercions, with respect to an RnEnv2
etaExpandCoAxBranch :: CoAxBranch -> ([TyVar], [Type], Type) #
Arguments
| :: LiftingContext | original LC | 
| -> TyCoVar | new variable to map... | 
| -> Coercion | ...to this lifted version | 
| -> LiftingContext | 
Extend a lifting context with a new mapping.
extendLiftingContextAndInScope #
Arguments
| :: LiftingContext | Original LC | 
| -> TyCoVar | new variable to map... | 
| -> Coercion | to this coercion | 
| -> LiftingContext | 
Extend a lifting context with a new mapping, and extend the in-scope set
getCoVar_maybe :: Coercion -> Maybe CoVar #
Attempts to obtain the type variable underlying a Coercion
instNewTyCon_maybe :: TyCon -> [Type] -> Maybe (Type, Coercion) #
If co :: T ts ~ rep_ty then:
instNewTyCon_maybe T ts = Just (rep_ty, co)
Checks for a newtype, and for being saturated
isCoVar_maybe :: Coercion -> Maybe CoVar #
Extract a covar, if possible. This check is dirty. Be ashamed of yourself. (It's dirty because it cares about the structure of a coercion, which is morally reprehensible.)
isGReflCo_maybe :: Coercion -> Maybe (Type, Role) #
Returns the type coerced if this coercion is a generalized reflexive coercion. Guaranteed to work very quickly.
isGReflMCo :: MCoercion -> Bool #
Tests if this MCoercion is obviously generalized reflexive Guaranteed to work very quickly.
isMappedByLC :: TyCoVar -> LiftingContext -> Bool #
Is a var in the domain of a lifting context?
isReflCoVar_maybe :: Var -> Maybe Coercion #
isReflCo_maybe :: Coercion -> Maybe (Type, Role) #
Returns the type coerced if this coercion is reflexive. Guaranteed
 to work very quickly. Sometimes a coercion can be reflexive, but not
 obviously so. c.f. isReflexiveCo_maybe
isReflexiveCo_maybe :: Coercion -> Maybe (Type, Role) #
Extracts the coerced type from a reflexive coercion. This potentially walks over the entire coercion, so avoid doing this in a loop.
lcInScopeSet :: LiftingContext -> InScopeSet #
Get the InScopeSet from a LiftingContext
lcSubstLeft :: LiftingContext -> TCvSubst #
lcSubstRight :: LiftingContext -> TCvSubst #
lcTCvSubst :: LiftingContext -> TCvSubst #
Extract the underlying substitution from the LiftingContext
liftCoSubstTyVar :: LiftingContext -> Role -> TyVar -> Maybe Coercion #
liftCoSubstVarBndrUsing :: (LiftingContext -> Type -> (CoercionN, a)) -> LiftingContext -> TyCoVar -> (LiftingContext, TyCoVar, CoercionN, a) #
liftCoSubstWithEx :: Role -> [TyVar] -> [Coercion] -> [TyCoVar] -> [Type] -> (Type -> Coercion, [Type]) #
liftEnvSubstLeft :: TCvSubst -> LiftCoEnv -> TCvSubst #
liftEnvSubstRight :: TCvSubst -> LiftCoEnv -> TCvSubst #
mapStepResult :: (ev1 -> ev2) -> NormaliseStepResult ev1 -> NormaliseStepResult ev2 #
mkAxInstCo :: Role -> CoAxiom br -> BranchIndex -> [Type] -> [Coercion] -> Coercion #
mkAxInstLHS :: CoAxiom br -> BranchIndex -> [Type] -> [Coercion] -> Type #
Return the left-hand type of the axiom, when the axiom is instantiated at the types given.
mkAxInstRHS :: CoAxiom br -> BranchIndex -> [Type] -> [Coercion] -> Type #
mkCoVarCos :: [CoVar] -> [Coercion] #
mkCoherenceLeftCo :: Role -> Type -> CoercionN -> Coercion -> Coercion #
Given ty :: k1, co :: k1 ~ k2, co2:: ty ~r ty',
 produces @co' :: (ty |> co) ~r ty'
 It is not only a utility function, but it saves allocation when co
 is a GRefl coercion.
mkCoherenceRightCo :: Role -> Type -> CoercionN -> Coercion -> Coercion #
Given ty :: k1, co :: k1 ~ k2, co2:: ty' ~r ty,
 produces @co' :: ty' ~r (ty |> co)
 It is not only a utility function, but it saves allocation when co
 is a GRefl coercion.
mkFamilyTyConAppCo :: TyCon -> [CoercionN] -> CoercionN #
Given a family instance TyCon and its arg Coercions, return the
 corresponding family Coercion.  E.g:
data family T a data instance T (Maybe b) = MkT b
Where the instance TyCon is :RTL, so:
mkFamilyTyConAppCo :RTL (co :: a ~# Int) = T (Maybe a) ~# T (Maybe Int)
cf. mkFamilyTyConApp
mkGReflLeftCo :: Role -> Type -> CoercionN -> Coercion #
Given ty :: k1, co :: k1 ~ k2,
 produces co' :: (ty |> co) ~r ty
mkGReflRightCo :: Role -> Type -> CoercionN -> Coercion #
Given ty :: k1, co :: k1 ~ k2,
 produces co' :: ty ~r (ty |> co)
mkHeteroPrimEqPred :: Kind -> Kind -> Type -> Type -> Type #
Creates a primitive type equality predicate with explicit kinds
mkHeteroReprPrimEqPred :: Kind -> Kind -> Type -> Type -> Type #
Creates a primitive representational type equality predicate with explicit kinds
mkHoleCo :: CoercionHole -> Coercion #
Make a coercion from a coercion hole
mkHomoForAllCos :: [TyCoVar] -> Coercion -> Coercion #
Make a Coercion quantified over a type/coercion variable; the variable has the same type in both sides of the coercion
mkPiCo :: Role -> Var -> Coercion -> Coercion #
Make a forall Coercion, where both types related by the coercion
 are quantified over the same variable.
mkPrimEqPred :: Type -> Type -> Type #
Creates a primitive type equality predicate. Invariant: the types are not Coercions
mkPrimEqPredRole :: Role -> Type -> Type -> PredType #
Makes a lifted equality predicate at the given role
mkRepReflCo :: Type -> Coercion #
Make a representational reflexive coercion
mkReprPrimEqPred :: Type -> Type -> Type #
mkTransMCo :: MCoercion -> MCoercion -> MCoercion #
Compose two MCoercions via transitivity
mkUnbranchedAxInstCo :: Role -> CoAxiom Unbranched -> [Type] -> [Coercion] -> Coercion #
mkUnbranchedAxInstLHS :: CoAxiom Unbranched -> [Type] -> [Coercion] -> Type #
Instantiate the left-hand side of an unbranched axiom
mkUnbranchedAxInstRHS :: CoAxiom Unbranched -> [Type] -> [Coercion] -> Type #
nthCoRole :: Int -> Coercion -> Role #
If you're about to call mkNthCo r n co, then r should be
 whatever nthCoRole n co returns.
pprCoAxBranch :: TyCon -> CoAxBranch -> SDoc #
pprCoAxBranchLHS :: TyCon -> CoAxBranch -> SDoc #
pprCoAxBranchUser :: TyCon -> CoAxBranch -> SDoc #
pprCoAxiom :: CoAxiom br -> SDoc #
promoteCoercion :: Coercion -> CoercionN #
like mkKindCo, but aggressively & recursively optimizes to avoid using a KindCo constructor. The output role is nominal.
setCoVarName :: CoVar -> Name -> CoVar #
setCoVarUnique :: CoVar -> Unique -> CoVar #
setNominalRole_maybe :: Role -> Coercion -> Maybe Coercion #
Converts a coercion to be nominal, if possible. See Note [Role twiddling functions]
simplifyArgsWorker :: [TyCoBinder] -> Kind -> TyCoVarSet -> [Role] -> [(Type, Coercion)] -> ([Type], [Coercion], CoercionN) #
splitAppCo_maybe :: Coercion -> Maybe (Coercion, Coercion) #
Attempt to take a coercion application apart.
splitForAllCo_co_maybe :: Coercion -> Maybe (CoVar, Coercion, Coercion) #
Like splitForAllCo_maybe, but only returns Just for covar binder
splitForAllCo_ty_maybe :: Coercion -> Maybe (TyVar, Coercion, Coercion) #
Like splitForAllCo_maybe, but only returns Just for tyvar binder
splitTyConAppCo_maybe :: Coercion -> Maybe (TyCon, [Coercion]) #
Attempts to tease a coercion apart into a type constructor and the application of a number of coercion arguments to that constructor
substForAllCoBndrUsingLC :: Bool -> (Coercion -> Coercion) -> LiftingContext -> TyCoVar -> Coercion -> (LiftingContext, TyCoVar, Coercion) #
Like substForAllCoBndr, but works on a lifting context
substLeftCo :: LiftingContext -> Coercion -> Coercion #
substRightCo :: LiftingContext -> Coercion -> Coercion #
swapLiftCoEnv :: LiftCoEnv -> LiftCoEnv #
Apply "sym" to all coercions in a LiftCoEnv
topNormaliseNewType_maybe :: Type -> Maybe (Coercion, Type) #
Sometimes we want to look through a newtype and get its associated coercion.
 This function strips off newtype layers enough to reveal something that isn't
 a newtype.  Specifically, here's the invariant:
topNormaliseNewType_maybe rec_nts ty = Just (co, ty')
then (a)  co : ty0 ~ ty'.
      (b)  ty' is not a newtype.
The function returns Nothing for non-newtypes,
 or unsaturated applications
This function does *not* look through type families, because it has no access to the type family environment. If you do have that at hand, consider to use topNormaliseType_maybe, which should be a drop-in replacement for topNormaliseNewType_maybe If topNormliseNewType_maybe ty = Just (co, ty'), then co : ty ~R ty'
topNormaliseTypeX :: NormaliseStepper ev -> (ev -> ev -> ev) -> Type -> Maybe (ev, Type) #
A general function for normalising the top-level of a type. It continues
 to use the provided NormaliseStepper until that function fails, and then
 this function returns. The roles of the coercions produced by the
 NormaliseStepper must all be the same, which is the role returned from
 the call to topNormaliseTypeX.
Typically ev is Coercion.
If topNormaliseTypeX step plus ty = Just (ev, ty')
 then ty ~ev1~ t1 ~ev2~ t2 ... ~evn~ ty'
 and ev = ev1 plus ev2 plus ... plus evn
 If it returns Nothing then no newtype unwrapping could happen
tyConRolesRepresentational :: TyCon -> [Role] #
tyConRolesX :: Role -> TyCon -> [Role] #
unwrapNewTypeStepper :: NormaliseStepper Coercion #
A NormaliseStepper that unwraps newtypes, careful not to fall into
 a loop. If it would fall into a loop, it produces NS_Abort.
zapLiftingContext :: LiftingContext -> LiftingContext #
Erase the environments in a lifting context
data NormaliseStepResult ev #
The result of stepping in a normalisation function.
 See topNormaliseTypeX.
Constructors
| NS_Done | Nothing more to do | 
| NS_Abort | Utter failure. The outer function should fail too. | 
| NS_Step RecTcChecker Type ev | We stepped, yielding new bits; ^ ev is evidence; Usually a co :: old type ~ new type | 
type NormaliseStepper ev = RecTcChecker -> TyCon -> [Type] -> NormaliseStepResult ev #
A function to check if we can reduce a type by one step. Used
 with topNormaliseTypeX.
module GHC.Builtin.Types
module GHC.Driver.Types
module GHC.Types.Basic
module GHC.Types.Var.Set
module GHC.Types.Var.Env
module GHC.Types.Name.Set
module GHC.Types.Name.Env
Class of things that we can obtain a Unique from
Instances
Unique identifier.
The type of unique identifiers that are used in many places in GHC
 for fast ordering and equality tests. You should generate these with
 the functions from the UniqSupply module
These are sometimes also referred to as "keys" in comments in GHC.
module GHC.Types.Unique.Set
module GHC.Types.Unique.FM
module GHC.Data.FiniteMap
module GHC.Utils.Misc
module GHC.Serialized
module GHC.Types.SrcLoc
module GHC.Utils.Outputable
module GHC.Types.Unique.Supply
module GHC.Data.FastString
module GHC.Tc.Errors.Hole.FitTypes
Getting Names
thNameToGhcName :: Name -> CoreM (Maybe Name) #
Attempt to convert a Template Haskell name to one that GHC can
 understand. Original TH names such as those you get when you use
 the 'foo syntax will be translated to their equivalent GHC name
 exactly. Qualified or unqualified TH names will be dynamically bound
 to names in the module being compiled, if possible. Exact TH names
 will be bound to the name they represent, exactly.