Safe Haskell	None
Language	Haskell2010

GhcApi.GhcPlugins

Synopsis

trace :: String -> a -> a
data Plugin = Plugin {
- installCoreToDos :: CorePlugin
- tcPlugin :: TcPlugin
- holeFitPlugin :: HoleFitPlugin
- dynflagsPlugin :: [CommandLineOption] -> DynFlags -> IO DynFlags
- pluginRecompile :: [CommandLineOption] -> IO PluginRecompile
- parsedResultAction :: [CommandLineOption] -> ModSummary -> HsParsedModule -> Hsc HsParsedModule
- renamedResultAction :: [CommandLineOption] -> TcGblEnv -> HsGroup GhcRn -> TcM (TcGblEnv, HsGroup GhcRn)
- typeCheckResultAction :: [CommandLineOption] -> ModSummary -> TcGblEnv -> TcM TcGblEnv
- spliceRunAction :: [CommandLineOption] -> LHsExpr GhcTc -> TcM (LHsExpr GhcTc)
- interfaceLoadAction :: forall lcl. [CommandLineOption] -> ModIface -> IfM lcl ModIface
}
data FrontendPlugin = FrontendPlugin {
- frontend :: FrontendPluginAction
}
sortWith :: Ord b => (a -> b) -> [a] -> [a]
mkNoRepType :: String -> DataType
liftIO :: MonadIO m => IO a -> m a
data Version = Version {
- versionBranch :: [Int]
- versionTags :: [String]
}
foldl1' :: (a -> a -> a) -> [a] -> a
type HasCallStack = ?callStack :: CallStack
data Serialized = Serialized TypeRep [Word8]
toSerialized :: Typeable a => (a -> [Word8]) -> a -> Serialized
fromSerialized :: Typeable a => ([Word8] -> a) -> Serialized -> Maybe a
serializeWithData :: Data a => a -> [Word8]
deserializeWithData :: Data a => [Word8] -> a
thNameToGhcName :: Name -> CoreM (Maybe Name)
defaultFrontendPlugin :: FrontendPlugin
withPlugins_ :: Monad m => DynFlags -> ConstPluginOperation m a -> a -> m ()
mapPlugins :: DynFlags -> (Plugin -> [CommandLineOption] -> a) -> [a]
withPlugins :: Monad m => DynFlags -> PluginOperation m a -> a -> m a
plugins :: DynFlags -> [PluginWithArgs]
keepRenamedSource :: [CommandLineOption] -> TcGblEnv -> HsGroup GhcRn -> TcM (TcGblEnv, HsGroup GhcRn)
defaultPlugin :: Plugin
flagRecompile :: [CommandLineOption] -> IO PluginRecompile
impurePlugin :: [CommandLineOption] -> IO PluginRecompile
purePlugin :: [CommandLineOption] -> IO PluginRecompile
pluginRecompile' :: PluginWithArgs -> IO PluginRecompile
lpModuleName :: LoadedPlugin -> ModuleName
type CommandLineOption = String
data PluginWithArgs = PluginWithArgs {
- paPlugin :: Plugin
- paArguments :: [CommandLineOption]
}
data PluginRecompile
- = ForceRecompile
- | NoForceRecompile
- | MaybeRecompile Fingerprint
type CorePlugin = [CommandLineOption] -> [CoreToDo] -> CoreM [CoreToDo]
type FrontendPluginAction = [String] -> [(String, Maybe Phase)] -> Ghc ()
data HoleFitPluginR
ruleCheckProgram :: CompilerPhase -> String -> (Id -> [CoreRule]) -> CoreProgram -> SDoc
lookupRule :: DynFlags -> InScopeEnv -> (Activation -> Bool) -> Id -> [CoreExpr] -> [CoreRule] -> Maybe (CoreRule, CoreExpr)
pprRuleBase :: RuleBase -> SDoc
unionRuleBase :: RuleBase -> RuleBase -> RuleBase
extendRuleBaseList :: RuleBase -> [CoreRule] -> RuleBase
mkRuleBase :: [CoreRule] -> RuleBase
emptyRuleBase :: RuleBase
getRules :: RuleEnv -> Id -> [CoreRule]
rulesOfBinds :: [CoreBind] -> [CoreRule]
addIdSpecialisations :: Id -> [CoreRule] -> Id
addRuleInfo :: RuleInfo -> RuleInfo -> RuleInfo
extendRuleInfo :: RuleInfo -> [CoreRule] -> RuleInfo
mkRuleInfo :: [CoreRule] -> RuleInfo
pprRulesForUser :: DynFlags -> [CoreRule] -> SDoc
roughTopNames :: [CoreExpr] -> [Maybe Name]
mkRule :: Module -> Bool -> Bool -> RuleName -> Activation -> Name -> [CoreBndr] -> [CoreExpr] -> CoreExpr -> CoreRule
substTickish :: Subst -> Tickish Id -> Tickish Id
substDVarSet :: Subst -> DVarSet -> DVarSet
substRulesForImportedIds :: Subst -> [CoreRule] -> [CoreRule]
substSpec :: Subst -> Id -> RuleInfo -> RuleInfo
substIdOcc :: Subst -> Id -> Id
substUnfolding :: Subst -> Unfolding -> Unfolding
substUnfoldingSC :: Subst -> Unfolding -> Unfolding
substIdInfo :: Subst -> Id -> IdInfo -> Maybe IdInfo
substIdType :: Subst -> Id -> Id
substCo :: HasCallStack => Subst -> Coercion -> Coercion
getTCvSubst :: Subst -> TCvSubst
substTy :: Subst -> Type -> Type
cloneRecIdBndrs :: Subst -> UniqSupply -> [Id] -> (Subst, [Id])
cloneBndr :: Subst -> Unique -> Var -> (Subst, Var)
cloneBndrs :: Subst -> UniqSupply -> [Var] -> (Subst, [Var])
cloneIdBndrs :: Subst -> UniqSupply -> [Id] -> (Subst, [Id])
cloneIdBndr :: Subst -> UniqSupply -> Id -> (Subst, Id)
substRecBndrs :: Subst -> [Id] -> (Subst, [Id])
substBndrs :: Subst -> [Var] -> (Subst, [Var])
substBndr :: Subst -> Var -> (Subst, Var)
deShadowBinds :: CoreProgram -> CoreProgram
substBind :: Subst -> CoreBind -> (Subst, CoreBind)
substBindSC :: Subst -> CoreBind -> (Subst, CoreBind)
substExpr :: SDoc -> Subst -> CoreExpr -> CoreExpr
substExprSC :: SDoc -> Subst -> CoreExpr -> CoreExpr
setInScope :: Subst -> InScopeSet -> Subst
extendInScopeIds :: Subst -> [Id] -> Subst
extendInScopeList :: Subst -> [Var] -> Subst
extendInScope :: Subst -> Var -> Subst
addInScopeSet :: Subst -> VarSet -> Subst
isInScope :: Var -> Subst -> Bool
mkOpenSubst :: InScopeSet -> [(Var, CoreArg)] -> Subst
delBndrs :: Subst -> [Var] -> Subst
delBndr :: Subst -> Var -> Subst
lookupTCvSubst :: Subst -> TyVar -> Type
lookupIdSubst :: SDoc -> Subst -> Id -> CoreExpr
extendSubstList :: Subst -> [(Var, CoreArg)] -> Subst
extendSubstWithVar :: Subst -> Var -> Var -> Subst
extendSubst :: Subst -> Var -> CoreArg -> Subst
extendTvSubstList :: Subst -> [(TyVar, Type)] -> Subst
extendTvSubst :: Subst -> TyVar -> Type -> Subst
extendIdSubstList :: Subst -> [(Id, CoreExpr)] -> Subst
extendIdSubst :: Subst -> Id -> CoreExpr -> Subst
zapSubstEnv :: Subst -> Subst
substInScope :: Subst -> InScopeSet
mkEmptySubst :: InScopeSet -> Subst
emptySubst :: Subst
isEmptySubst :: Subst -> Bool
data Subst = Subst InScopeSet IdSubstEnv TvSubstEnv CvSubstEnv
type IdSubstEnv = IdEnv CoreExpr
mkAbsentErrorApp :: Type -> String -> CoreExpr
aBSENT_ERROR_ID :: Id
aBSENT_SUM_FIELD_ERROR_ID :: Id
tYPE_ERROR_ID :: Id
nON_EXHAUSTIVE_GUARDS_ERROR_ID :: Id
nO_METHOD_BINDING_ERROR_ID :: Id
pAT_ERROR_ID :: Id
rEC_CON_ERROR_ID :: Id
rUNTIME_ERROR_ID :: Id
rEC_SEL_ERROR_ID :: Id
errorIds :: [Id]
mkImpossibleExpr :: Type -> CoreExpr
mkRuntimeErrorApp :: Id -> Type -> String -> CoreExpr
mkJustExpr :: Type -> CoreExpr -> CoreExpr
mkNothingExpr :: Type -> CoreExpr
mkBuildExpr :: (MonadFail m, MonadThings m, MonadUnique m) => Type -> ((Id, Type) -> (Id, Type) -> m CoreExpr) -> m CoreExpr
mkFoldrExpr :: MonadThings m => Type -> Type -> CoreExpr -> CoreExpr -> CoreExpr -> m CoreExpr
mkListExpr :: Type -> [CoreExpr] -> CoreExpr
mkConsExpr :: Type -> CoreExpr -> CoreExpr -> CoreExpr
mkNilExpr :: Type -> CoreExpr
floatBindings :: FloatBind -> [Var]
wrapFloats :: [FloatBind] -> CoreExpr -> CoreExpr
wrapFloat :: FloatBind -> CoreExpr -> CoreExpr
mkSmallTupleCase :: [Id] -> CoreExpr -> Id -> CoreExpr -> CoreExpr
mkTupleCase :: UniqSupply -> [Id] -> CoreExpr -> Id -> CoreExpr -> CoreExpr
mkSmallTupleSelector :: [Id] -> Id -> Id -> CoreExpr -> CoreExpr
mkTupleSelector1 :: [Id] -> Id -> Id -> CoreExpr -> CoreExpr
mkTupleSelector :: [Id] -> Id -> Id -> CoreExpr -> CoreExpr
unitExpr :: CoreExpr
mkBigCoreTupTy :: [Type] -> Type
mkBigCoreTup :: [CoreExpr] -> CoreExpr
mkBigCoreVarTupTy :: [Id] -> Type
mkBigCoreVarTup1 :: [Id] -> CoreExpr
mkBigCoreVarTup :: [Id] -> CoreExpr
mkCoreTupBoxity :: Boxity -> [CoreExpr] -> CoreExpr
mkCoreUbxTup :: [Type] -> [CoreExpr] -> CoreExpr
mkCoreTup :: [CoreExpr] -> CoreExpr
mkCoreVarTupTy :: [Id] -> Type
mkStringExprFSWith :: Monad m => (Name -> m Id) -> FastString -> m CoreExpr
mkStringExprFS :: MonadThings m => FastString -> m CoreExpr
mkStringExpr :: MonadThings m => String -> m CoreExpr
mkCharExpr :: Char -> CoreExpr
mkDoubleExpr :: Double -> CoreExpr
mkFloatExpr :: Float -> CoreExpr
mkNaturalExpr :: MonadThings m => Integer -> m CoreExpr
mkIntegerExpr :: MonadThings m => Integer -> m CoreExpr
mkWordExprWord :: DynFlags -> Word -> CoreExpr
mkWordExpr :: DynFlags -> Integer -> CoreExpr
mkIntExprInt :: DynFlags -> Int -> CoreExpr
mkIntExpr :: DynFlags -> Integer -> CoreExpr
castBottomExpr :: CoreExpr -> Type -> CoreExpr
mkIfThenElse :: CoreExpr -> CoreExpr -> CoreExpr -> CoreExpr
mkWildCase :: CoreExpr -> Type -> Type -> [CoreAlt] -> CoreExpr
mkWildValBinder :: Type -> Id
mkWildEvBinder :: PredType -> EvVar
mkCoreApp :: SDoc -> CoreExpr -> CoreExpr -> CoreExpr
mkCoreApps :: CoreExpr -> [CoreExpr] -> CoreExpr
mkCoreConApps :: DataCon -> [CoreExpr] -> CoreExpr
mkCoreLets :: [CoreBind] -> CoreExpr -> CoreExpr
mkCoreLams :: [CoreBndr] -> CoreExpr -> CoreExpr
mkCoreLet :: CoreBind -> CoreExpr -> CoreExpr
sortQuantVars :: [Var] -> [Var]
data FloatBind
- = FloatLet CoreBind
- | FloatCase CoreExpr Id AltCon [Var]
isJoinBind :: CoreBind -> Bool
collectMakeStaticArgs :: CoreExpr -> Maybe (CoreExpr, Type, CoreExpr, CoreExpr)
isEmptyTy :: Type -> Bool
rhsIsStatic :: Platform -> (Name -> Bool) -> (LitNumType -> Integer -> Maybe CoreExpr) -> CoreExpr -> Bool
tryEtaReduce :: [Var] -> CoreExpr -> Maybe CoreExpr
diffBinds :: Bool -> RnEnv2 -> [(Var, CoreExpr)] -> [(Var, CoreExpr)] -> ([SDoc], RnEnv2)
diffExpr :: Bool -> RnEnv2 -> CoreExpr -> CoreExpr -> [SDoc]
eqExpr :: InScopeSet -> CoreExpr -> CoreExpr -> Bool
exprIsBig :: Expr b -> Bool
cheapEqExpr' :: (Tickish Id -> Bool) -> Expr b -> Expr b -> Bool
cheapEqExpr :: Expr b -> Expr b -> Bool
dataConRepFSInstPat :: [FastString] -> [Unique] -> DataCon -> [Type] -> ([TyCoVar], [Id])
dataConRepInstPat :: [Unique] -> DataCon -> [Type] -> ([TyCoVar], [Id])
exprIsTickedString_maybe :: CoreExpr -> Maybe ByteString
exprIsTickedString :: CoreExpr -> Bool
exprIsTopLevelBindable :: CoreExpr -> Type -> Bool
exprIsConLike :: CoreExpr -> Bool
exprIsHNF :: CoreExpr -> Bool
altsAreExhaustive :: [Alt b] -> Bool
exprOkForSideEffects :: CoreExpr -> Bool
exprOkForSpeculation :: CoreExpr -> Bool
isExpandableApp :: CheapAppFun
isCheapApp :: CheapAppFun
exprIsExpandable :: CoreExpr -> Bool
exprIsCheapX :: CheapAppFun -> CoreExpr -> Bool
exprIsCheap :: CoreExpr -> Bool
exprIsWorkFree :: CoreExpr -> Bool
exprIsDupable :: DynFlags -> CoreExpr -> Bool
exprIsBottom :: CoreExpr -> Bool
getIdFromTrivialExpr_maybe :: CoreExpr -> Maybe Id
getIdFromTrivialExpr :: HasDebugCallStack => CoreExpr -> Id
exprIsTrivial :: CoreExpr -> Bool
combineIdenticalAlts :: [AltCon] -> [CoreAlt] -> (Bool, [AltCon], [CoreAlt])
refineDefaultAlt :: [Unique] -> TyCon -> [Type] -> [AltCon] -> [CoreAlt] -> (Bool, [CoreAlt])
filterAlts :: TyCon -> [Type] -> [AltCon] -> [(AltCon, [Var], a)] -> ([AltCon], [(AltCon, [Var], a)])
trimConArgs :: AltCon -> [CoreArg] -> [CoreArg]
mergeAlts :: [(AltCon, a, b)] -> [(AltCon, a, b)] -> [(AltCon, a, b)]
findAlt :: AltCon -> [(AltCon, a, b)] -> Maybe (AltCon, a, b)
isDefaultAlt :: (AltCon, a, b) -> Bool
addDefault :: [(AltCon, [a], b)] -> Maybe b -> [(AltCon, [a], b)]
findDefault :: [(AltCon, [a], b)] -> ([(AltCon, [a], b)], Maybe b)
mkSingleAltCase :: CoreExpr -> Id -> AltCon -> [Var] -> CoreExpr -> CoreExpr
mkDefaultCase :: CoreExpr -> Id -> CoreExpr -> CoreExpr
mkAltExpr :: AltCon -> [CoreBndr] -> [Type] -> CoreExpr
needsCaseBinding :: Type -> CoreExpr -> Bool
bindNonRec :: Id -> CoreExpr -> CoreExpr -> CoreExpr
stripTicksT :: (Tickish Id -> Bool) -> Expr b -> [Tickish Id]
stripTicksE :: (Tickish Id -> Bool) -> Expr b -> Expr b
stripTicksTopT :: (Tickish Id -> Bool) -> Expr b -> [Tickish Id]
stripTicksTopE :: (Tickish Id -> Bool) -> Expr b -> Expr b
stripTicksTop :: (Tickish Id -> Bool) -> Expr b -> ([Tickish Id], Expr b)
tickHNFArgs :: Tickish Id -> CoreExpr -> CoreExpr
mkTickNoHNF :: Tickish Id -> CoreExpr -> CoreExpr
mkTicks :: [Tickish Id] -> CoreExpr -> CoreExpr
mkTick :: Tickish Id -> CoreExpr -> CoreExpr
mkCast :: CoreExpr -> CoercionR -> CoreExpr
applyTypeToArgs :: CoreExpr -> Type -> [CoreExpr] -> Type
isExprLevPoly :: CoreExpr -> Bool
coreAltsType :: [CoreAlt] -> Type
coreAltType :: CoreAlt -> Type
exprType :: CoreExpr -> Type
type CheapAppFun = Id -> Arity -> Bool
dumpIfSet_dyn :: DumpFlag -> String -> SDoc -> CoreM ()
debugTraceMsg :: SDoc -> CoreM ()
debugTraceMsgS :: String -> CoreM ()
fatalErrorMsg :: SDoc -> CoreM ()
fatalErrorMsgS :: String -> CoreM ()
warnMsg :: WarnReason -> SDoc -> CoreM ()
errorMsg :: SDoc -> CoreM ()
errorMsgS :: String -> CoreM ()
putMsg :: SDoc -> CoreM ()
putMsgS :: String -> CoreM ()
getFirstAnnotations :: Typeable a => ([Word8] -> a) -> ModGuts -> CoreM (UniqFM a)
getAnnotations :: Typeable a => ([Word8] -> a) -> ModGuts -> CoreM (UniqFM [a])
getPackageFamInstEnv :: CoreM PackageFamInstEnv
getOrigNameCache :: CoreM OrigNameCache
getUniqMask :: CoreM Char
addSimplCount :: SimplCount -> CoreM ()
getSrcSpanM :: CoreM SrcSpan
getPrintUnqualified :: CoreM PrintUnqualified
getVisibleOrphanMods :: CoreM ModuleSet
getRuleBase :: CoreM RuleBase
getHscEnv :: CoreM HscEnv
liftIOWithCount :: IO (SimplCount, a) -> CoreM a
runCoreM :: HscEnv -> RuleBase -> Char -> Module -> ModuleSet -> PrintUnqualified -> SrcSpan -> CoreM a -> IO (a, SimplCount)
pprSimplCount :: SimplCount -> SDoc
plusSimplCount :: SimplCount -> SimplCount -> SimplCount
doSimplTick :: DynFlags -> Tick -> SimplCount -> SimplCount
doFreeSimplTick :: Tick -> SimplCount -> SimplCount
hasDetailedCounts :: SimplCount -> Bool
isZeroSimplCount :: SimplCount -> Bool
zeroSimplCount :: DynFlags -> SimplCount
simplCountN :: SimplCount -> Int
bindsOnlyPass :: (CoreProgram -> CoreM CoreProgram) -> ModGuts -> CoreM ModGuts
runMaybe :: Maybe a -> (a -> CoreToDo) -> CoreToDo
runWhen :: Bool -> CoreToDo -> CoreToDo
pprPassDetails :: CoreToDo -> SDoc
data SimplMode = SimplMode {
- sm_names :: [String]
- sm_phase :: CompilerPhase
- sm_dflags :: DynFlags
- sm_rules :: Bool
- sm_inline :: Bool
- sm_case_case :: Bool
- sm_eta_expand :: Bool
}
data FloatOutSwitches = FloatOutSwitches {
- floatOutLambdas :: Maybe Int
- floatOutConstants :: Bool
- floatOutOverSatApps :: Bool
- floatToTopLevelOnly :: Bool
}
type CorePluginPass = ModGuts -> CoreM ModGuts
data Tick
- = PreInlineUnconditionally Id
- | PostInlineUnconditionally Id
- | UnfoldingDone Id
- | RuleFired FastString
- | LetFloatFromLet
- | EtaExpansion Id
- | EtaReduction Id
- | BetaReduction Id
- | CaseOfCase Id
- | KnownBranch Id
- | CaseMerge Id
- | AltMerge Id
- | CaseElim Id
- | CaseIdentity Id
- | FillInCaseDefault Id
- | SimplifierDone
phaseForeignLanguage :: Phase -> Maybe ForeignSrcLang
extendCompleteMatchMap :: CompleteMatchMap -> [CompleteMatch] -> CompleteMatchMap
mkCompleteMatchMap :: [CompleteMatch] -> CompleteMatchMap
byteCodeOfObject :: Unlinked -> CompiledByteCode
nameOfObject :: Unlinked -> FilePath
isInterpretable :: Unlinked -> Bool
isObject :: Unlinked -> Bool
linkableObjs :: Linkable -> [FilePath]
isObjectLinkable :: Linkable -> Bool
numToTrustInfo :: Word8 -> IfaceTrustInfo
trustInfoToNum :: IfaceTrustInfo -> Word8
noIfaceTrustInfo :: IfaceTrustInfo
setSafeMode :: SafeHaskellMode -> IfaceTrustInfo
getSafeMode :: IfaceTrustInfo -> SafeHaskellMode
isHpcUsed :: HpcInfo -> AnyHpcUsage
emptyHpcInfo :: AnyHpcUsage -> HpcInfo
showModMsg :: DynFlags -> HscTarget -> Bool -> ModSummary -> String
isBootSummary :: ModSummary -> Bool
msObjFilePath :: ModSummary -> FilePath
msHiFilePath :: ModSummary -> FilePath
msHsFilePath :: ModSummary -> FilePath
ms_home_imps :: ModSummary -> [Located ModuleName]
ms_home_srcimps :: ModSummary -> [Located ModuleName]
ms_home_allimps :: ModSummary -> [ModuleName]
home_imps :: [(Maybe FastString, Located ModuleName)] -> [Located ModuleName]
ms_imps :: ModSummary -> [(Maybe FastString, Located ModuleName)]
ms_mod_name :: ModSummary -> ModuleName
ms_installed_mod :: ModSummary -> InstalledModule
mkModuleGraph :: [ModSummary] -> ModuleGraph
extendMG :: ModuleGraph -> ModSummary -> ModuleGraph
isTemplateHaskellOrQQNonBoot :: ModSummary -> Bool
emptyMG :: ModuleGraph
mgLookupModule :: ModuleGraph -> Module -> Maybe ModSummary
mgElemModule :: ModuleGraph -> Module -> Bool
mgModSummaries :: ModuleGraph -> [ModSummary]
mgBootModules :: ModuleGraph -> ModuleSet
mapMG :: (ModSummary -> ModSummary) -> ModuleGraph -> ModuleGraph
needsTemplateHaskellOrQQ :: ModuleGraph -> Bool
soExt :: Platform -> FilePath
mkHsSOName :: Platform -> FilePath -> FilePath
mkSOName :: Platform -> FilePath -> FilePath
updNameCache :: IORef NameCache -> (NameCache -> (NameCache, c)) -> IO c
addEpsInStats :: EpsStats -> Int -> Int -> Int -> EpsStats
noDependencies :: Dependencies
lookupFixity :: FixityEnv -> Name -> Fixity
emptyFixityEnv :: FixityEnv
mkIfaceFixCache :: [(OccName, Fixity)] -> OccName -> Maybe Fixity
plusWarns :: Warnings -> Warnings -> Warnings
emptyIfaceWarnCache :: OccName -> Maybe WarningTxt
mkIfaceWarnCache :: Warnings -> OccName -> Maybe WarningTxt
tyThingId :: TyThing -> Id
tyThingConLike :: TyThing -> ConLike
tyThingDataCon :: TyThing -> DataCon
tyThingCoAxiom :: TyThing -> CoAxiom Branched
tyThingTyCon :: TyThing -> TyCon
lookupTypeHscEnv :: HscEnv -> Name -> IO (Maybe TyThing)
lookupType :: DynFlags -> HomePackageTable -> PackageTypeEnv -> Name -> Maybe TyThing
plusTypeEnv :: TypeEnv -> TypeEnv -> TypeEnv
extendTypeEnvWithIds :: TypeEnv -> [Id] -> TypeEnv
extendTypeEnvList :: TypeEnv -> [TyThing] -> TypeEnv
extendTypeEnv :: TypeEnv -> TyThing -> TypeEnv
lookupTypeEnv :: TypeEnv -> Name -> Maybe TyThing
typeEnvFromEntities :: [Id] -> [TyCon] -> [FamInst] -> TypeEnv
mkTypeEnvWithImplicits :: [TyThing] -> TypeEnv
mkTypeEnv :: [TyThing] -> TypeEnv
typeEnvClasses :: TypeEnv -> [Class]
typeEnvDataCons :: TypeEnv -> [DataCon]
typeEnvPatSyns :: TypeEnv -> [PatSyn]
typeEnvIds :: TypeEnv -> [Id]
typeEnvCoAxioms :: TypeEnv -> [CoAxiom Branched]
typeEnvTyCons :: TypeEnv -> [TyCon]
typeEnvElts :: TypeEnv -> [TyThing]
emptyTypeEnv :: TypeEnv
tyThingAvailInfo :: TyThing -> [AvailInfo]
tyThingsTyCoVars :: [TyThing] -> TyCoVarSet
tyThingParent_maybe :: TyThing -> Maybe TyThing
isImplicitTyThing :: TyThing -> Bool
implicitTyConThings :: TyCon -> [TyThing]
implicitClassThings :: Class -> [TyThing]
implicitTyThings :: TyThing -> [TyThing]
pkgQual :: DynFlags -> PrintUnqualified
mkQualPackage :: DynFlags -> QueryQualifyPackage
mkQualModule :: DynFlags -> QueryQualifyModule
mkPrintUnqualified :: DynFlags -> GlobalRdrEnv -> PrintUnqualified
substInteractiveContext :: InteractiveContext -> TCvSubst -> InteractiveContext
icExtendGblRdrEnv :: GlobalRdrEnv -> [TyThing] -> GlobalRdrEnv
setInteractivePrintName :: InteractiveContext -> Name -> InteractiveContext
setInteractivePackage :: HscEnv -> HscEnv
extendInteractiveContextWithIds :: InteractiveContext -> [Id] -> InteractiveContext
extendInteractiveContext :: InteractiveContext -> [TyThing] -> [ClsInst] -> [FamInst] -> Maybe [Type] -> FixityEnv -> InteractiveContext
icPrintUnqual :: DynFlags -> InteractiveContext -> PrintUnqualified
icInScopeTTs :: InteractiveContext -> [TyThing]
icInteractiveModule :: InteractiveContext -> Module
emptyInteractiveContext :: DynFlags -> InteractiveContext
appendStubC :: ForeignStubs -> SDoc -> ForeignStubs
importedByUser :: [ImportedBy] -> [ImportedModsVal]
emptyModDetails :: ModDetails
mkIfaceHashCache :: [(Fingerprint, IfaceDecl)] -> OccName -> Maybe (OccName, Fingerprint)
emptyFullModIface :: Module -> ModIface
emptyPartialModIface :: Module -> PartialModIface
renameFreeHoles :: UniqDSet ModuleName -> [(ModuleName, Module)] -> UniqDSet ModuleName
mi_free_holes :: ModIface -> UniqDSet ModuleName
mi_semantic_module :: forall (a :: ModIfacePhase). ModIface_ a -> Module
mi_fix :: ModIface -> OccName -> Fixity
mi_boot :: ModIface -> Bool
prepareAnnotations :: HscEnv -> Maybe ModGuts -> IO AnnEnv
metaRequestAW :: Functor f => MetaHook f -> LHsExpr GhcTc -> f Serialized
metaRequestD :: Functor f => MetaHook f -> LHsExpr GhcTc -> f [LHsDecl GhcPs]
metaRequestT :: Functor f => MetaHook f -> LHsExpr GhcTc -> f (LHsType GhcPs)
metaRequestP :: Functor f => MetaHook f -> LHsExpr GhcTc -> f (LPat GhcPs)
metaRequestE :: Functor f => MetaHook f -> LHsExpr GhcTc -> f (LHsExpr GhcPs)
hptRules :: HscEnv -> [(ModuleName, IsBootInterface)] -> [CoreRule]
hptInstances :: HscEnv -> (ModuleName -> Bool) -> ([ClsInst], [FamInst])
hptCompleteSigs :: HscEnv -> [CompleteMatch]
lookupIfaceByModule :: HomePackageTable -> PackageIfaceTable -> Module -> Maybe ModIface
lookupHptByModule :: HomePackageTable -> Module -> Maybe HomeModInfo
listToHpt :: [(ModuleName, HomeModInfo)] -> HomePackageTable
addListToHpt :: HomePackageTable -> [(ModuleName, HomeModInfo)] -> HomePackageTable
addToHpt :: HomePackageTable -> ModuleName -> HomeModInfo -> HomePackageTable
delFromHpt :: HomePackageTable -> ModuleName -> HomePackageTable
mapHpt :: (HomeModInfo -> HomeModInfo) -> HomePackageTable -> HomePackageTable
allHpt :: (HomeModInfo -> Bool) -> HomePackageTable -> Bool
filterHpt :: (HomeModInfo -> Bool) -> HomePackageTable -> HomePackageTable
eltsHpt :: HomePackageTable -> [HomeModInfo]
lookupHptDirectly :: HomePackageTable -> Unique -> Maybe HomeModInfo
lookupHpt :: HomePackageTable -> ModuleName -> Maybe HomeModInfo
pprHPT :: HomePackageTable -> SDoc
emptyPackageIfaceTable :: PackageIfaceTable
emptyHomePackageTable :: HomePackageTable
pprTargetId :: TargetId -> SDoc
pprTarget :: Target -> SDoc
hscEPS :: HscEnv -> IO ExternalPackageState
handleFlagWarnings :: DynFlags -> [Warn] -> IO ()
printOrThrowWarnings :: DynFlags -> Bag WarnMsg -> IO ()
handleSourceError :: ExceptionMonad m => (SourceError -> m a) -> m a -> m a
throwOneError :: MonadIO io => ErrMsg -> io a
throwErrors :: MonadIO io => ErrorMessages -> io a
mkApiErr :: DynFlags -> SDoc -> GhcApiError
srcErrorMessages :: SourceError -> ErrorMessages
mkSrcErr :: ErrorMessages -> SourceError
runInteractiveHsc :: HscEnv -> Hsc a -> IO a
mkInteractiveHscEnv :: HscEnv -> HscEnv
runHsc :: HscEnv -> Hsc a -> IO a
data HscStatus
- = HscNotGeneratingCode ModIface
- | HscUpToDate ModIface
- | HscUpdateBoot ModIface
- | HscUpdateSig ModIface
- | HscRecomp {
  - hscs_guts :: CgGuts
  - hscs_mod_location :: !ModLocation
  - hscs_partial_iface :: !PartialModIface
  - hscs_old_iface_hash :: !(Maybe Fingerprint)
  - hscs_iface_dflags :: !DynFlags
  }
newtype Hsc a = Hsc (HscEnv -> WarningMessages -> IO (a, WarningMessages))
data SourceError
data GhcApiError
data HscEnv = HscEnv {
- hsc_dflags :: DynFlags
- hsc_targets :: [Target]
- hsc_mod_graph :: ModuleGraph
- hsc_IC :: InteractiveContext
- hsc_HPT :: HomePackageTable
- hsc_EPS :: !(IORef ExternalPackageState)
- hsc_NC :: !(IORef NameCache)
- hsc_FC :: !(IORef FinderCache)
- hsc_type_env_var :: Maybe (Module, IORef TypeEnv)
- hsc_iserv :: MVar (Maybe IServ)
- hsc_dynLinker :: DynLinker
}
data IServ = IServ {
- iservPipe :: Pipe
- iservProcess :: ProcessHandle
- iservLookupSymbolCache :: IORef (UniqFM (Ptr ()))
- iservPendingFrees :: [HValueRef]
}
data Target = Target {
- targetId :: TargetId
- targetAllowObjCode :: Bool
- targetContents :: Maybe (InputFileBuffer, UTCTime)
}
data TargetId
- = TargetModule ModuleName
- | TargetFile FilePath (Maybe Phase)
type InputFileBuffer = StringBuffer
type HomePackageTable = DModuleNameEnv HomeModInfo
type PackageIfaceTable = ModuleEnv ModIface
data HomeModInfo = HomeModInfo {
- hm_iface :: !ModIface
- hm_details :: !ModDetails
- hm_linkable :: !(Maybe Linkable)
}
data MetaRequest
- = MetaE (LHsExpr GhcPs -> MetaResult)
- | MetaP (LPat GhcPs -> MetaResult)
- | MetaT (LHsType GhcPs -> MetaResult)
- | MetaD ([LHsDecl GhcPs] -> MetaResult)
- | MetaAW (Serialized -> MetaResult)
data MetaResult
type MetaHook (f :: Type -> Type) = MetaRequest -> LHsExpr GhcTc -> f MetaResult
type FinderCache = InstalledModuleEnv InstalledFindResult
data InstalledFindResult
- = InstalledFound ModLocation InstalledModule
- | InstalledNoPackage InstalledUnitId
- | InstalledNotFound [FilePath] (Maybe InstalledUnitId)
data FindResult
- = Found ModLocation Module
- | NoPackage UnitId
- | FoundMultiple [(Module, ModuleOrigin)]
- | NotFound {
  - fr_paths :: [FilePath]
  - fr_pkg :: Maybe UnitId
  - fr_mods_hidden :: [UnitId]
  - fr_pkgs_hidden :: [UnitId]
  - fr_unusables :: [(UnitId, UnusablePackageReason)]
  - fr_suggestions :: [ModuleSuggestion]
  }
type PartialModIface = ModIface_ 'ModIfaceCore
type ModIface = ModIface_ 'ModIfaceFinal
data ModIfaceBackend = ModIfaceBackend {
- mi_iface_hash :: !Fingerprint
- mi_mod_hash :: !Fingerprint
- mi_flag_hash :: !Fingerprint
- mi_opt_hash :: !Fingerprint
- mi_hpc_hash :: !Fingerprint
- mi_plugin_hash :: !Fingerprint
- mi_orphan :: !WhetherHasOrphans
- mi_finsts :: !WhetherHasFamInst
- mi_exp_hash :: !Fingerprint
- mi_orphan_hash :: !Fingerprint
- mi_warn_fn :: !(OccName -> Maybe WarningTxt)
- mi_fix_fn :: !(OccName -> Maybe Fixity)
- mi_hash_fn :: !(OccName -> Maybe (OccName, Fingerprint))
}
data ModIface_ (phase :: ModIfacePhase) = ModIface {
- mi_module :: !Module
- mi_sig_of :: !(Maybe Module)
- mi_hsc_src :: !HscSource
- mi_deps :: Dependencies
- mi_usages :: [Usage]
- mi_exports :: ![IfaceExport]
- mi_used_th :: !Bool
- mi_fixities :: [(OccName, Fixity)]
- mi_warns :: Warnings
- mi_anns :: [IfaceAnnotation]
- mi_decls :: [IfaceDeclExts phase]
- mi_globals :: !(Maybe GlobalRdrEnv)
- mi_insts :: [IfaceClsInst]
- mi_fam_insts :: [IfaceFamInst]
- mi_rules :: [IfaceRule]
- mi_hpc :: !AnyHpcUsage
- mi_trust :: !IfaceTrustInfo
- mi_trust_pkg :: !Bool
- mi_complete_sigs :: [IfaceCompleteMatch]
- mi_doc_hdr :: Maybe HsDocString
- mi_decl_docs :: DeclDocMap
- mi_arg_docs :: ArgDocMap
- mi_final_exts :: !(IfaceBackendExts phase)
}
type IfaceExport = AvailInfo
data ModDetails = ModDetails {
- md_exports :: [AvailInfo]
- md_types :: !TypeEnv
- md_insts :: ![ClsInst]
- md_fam_insts :: ![FamInst]
- md_rules :: ![CoreRule]
- md_anns :: ![Annotation]
- md_complete_sigs :: [CompleteMatch]
}
type ImportedMods = ModuleEnv [ImportedBy]
data ImportedBy
- = ImportedByUser ImportedModsVal
- | ImportedBySystem
data ImportedModsVal = ImportedModsVal {
- imv_name :: ModuleName
- imv_span :: SrcSpan
- imv_is_safe :: IsSafeImport
- imv_is_hiding :: Bool
- imv_all_exports :: !GlobalRdrEnv
- imv_qualified :: Bool
}
data ModGuts = ModGuts {
- mg_module :: !Module
- mg_hsc_src :: HscSource
- mg_loc :: SrcSpan
- mg_exports :: ![AvailInfo]
- mg_deps :: !Dependencies
- mg_usages :: ![Usage]
- mg_used_th :: !Bool
- mg_rdr_env :: !GlobalRdrEnv
- mg_fix_env :: !FixityEnv
- mg_tcs :: ![TyCon]
- mg_insts :: ![ClsInst]
- mg_fam_insts :: ![FamInst]
- mg_patsyns :: ![PatSyn]
- mg_rules :: ![CoreRule]
- mg_binds :: !CoreProgram
- mg_foreign :: !ForeignStubs
- mg_foreign_files :: ![(ForeignSrcLang, FilePath)]
- mg_warns :: !Warnings
- mg_anns :: [Annotation]
- mg_complete_sigs :: [CompleteMatch]
- mg_hpc_info :: !HpcInfo
- mg_modBreaks :: !(Maybe ModBreaks)
- mg_inst_env :: InstEnv
- mg_fam_inst_env :: FamInstEnv
- mg_safe_haskell :: SafeHaskellMode
- mg_trust_pkg :: Bool
- mg_doc_hdr :: !(Maybe HsDocString)
- mg_decl_docs :: !DeclDocMap
- mg_arg_docs :: !ArgDocMap
}
data CgGuts = CgGuts {
- cg_module :: !Module
- cg_tycons :: [TyCon]
- cg_binds :: CoreProgram
- cg_foreign :: !ForeignStubs
- cg_foreign_files :: ![(ForeignSrcLang, FilePath)]
- cg_dep_pkgs :: ![InstalledUnitId]
- cg_hpc_info :: !HpcInfo
- cg_modBreaks :: !(Maybe ModBreaks)
- cg_spt_entries :: [SptEntry]
}
data ForeignStubs
- = NoStubs
- | ForeignStubs SDoc SDoc
data InteractiveContext = InteractiveContext {
- ic_dflags :: DynFlags
- ic_mod_index :: Int
- ic_imports :: [InteractiveImport]
- ic_tythings :: [TyThing]
- ic_rn_gbl_env :: GlobalRdrEnv
- ic_instances :: ([ClsInst], [FamInst])
- ic_fix_env :: FixityEnv
- ic_default :: Maybe [Type]
- ic_resume :: [Resume]
- ic_monad :: Name
- ic_int_print :: Name
- ic_cwd :: Maybe FilePath
}
data InteractiveImport
- = IIDecl (ImportDecl GhcPs)
- | IIModule ModuleName
type TypeEnv = NameEnv TyThing
class Monad m => MonadThings (m :: Type -> Type) where
- lookupThing :: Name -> m TyThing
- lookupId :: Name -> m Id
- lookupDataCon :: Name -> m DataCon
- lookupTyCon :: Name -> m TyCon
data Warnings
- = NoWarnings
- | WarnAll WarningTxt
- | WarnSome [(OccName, WarningTxt)]
type FixityEnv = NameEnv FixItem
data FixItem = FixItem OccName Fixity
type WhetherHasOrphans = Bool
type IsBootInterface = Bool
data Dependencies = Deps {
- dep_mods :: [(ModuleName, IsBootInterface)]
- dep_pkgs :: [(InstalledUnitId, Bool)]
- dep_orphs :: [Module]
- dep_finsts :: [Module]
- dep_plgins :: [ModuleName]
}
data Usage
- = UsagePackageModule {
  - usg_mod :: Module
  - usg_mod_hash :: Fingerprint
  - usg_safe :: IsSafeImport
  }
- | UsageHomeModule {
  - usg_mod_name :: ModuleName
  - usg_mod_hash :: Fingerprint
  - usg_entities :: [(OccName, Fingerprint)]
  - usg_exports :: Maybe Fingerprint
  - usg_safe :: IsSafeImport
  }
- | UsageFile {
  - usg_file_path :: FilePath
  - usg_file_hash :: Fingerprint
  }
- | UsageMergedRequirement {
  - usg_mod :: Module
  - usg_mod_hash :: Fingerprint
  }
type PackageTypeEnv = TypeEnv
type PackageRuleBase = RuleBase
type PackageInstEnv = InstEnv
type PackageFamInstEnv = FamInstEnv
type PackageCompleteMatchMap = CompleteMatchMap
data ExternalPackageState = EPS {
- eps_is_boot :: !(ModuleNameEnv (ModuleName, IsBootInterface))
- eps_PIT :: !PackageIfaceTable
- eps_free_holes :: InstalledModuleEnv (UniqDSet ModuleName)
- eps_PTE :: !PackageTypeEnv
- eps_inst_env :: !PackageInstEnv
- eps_fam_inst_env :: !PackageFamInstEnv
- eps_rule_base :: !PackageRuleBase
- eps_ann_env :: !PackageAnnEnv
- eps_complete_matches :: !PackageCompleteMatchMap
- eps_mod_fam_inst_env :: !(ModuleEnv FamInstEnv)
- eps_stats :: !EpsStats
}
data EpsStats = EpsStats {
- n_ifaces_in :: !Int
- n_decls_in :: !Int
- n_decls_out :: !Int
- n_rules_in :: !Int
- n_rules_out :: !Int
- n_insts_in :: !Int
- n_insts_out :: !Int
}
data ModuleGraph
data ModSummary = ModSummary {
- ms_mod :: Module
- ms_hsc_src :: HscSource
- ms_location :: ModLocation
- ms_hs_date :: UTCTime
- ms_obj_date :: Maybe UTCTime
- ms_iface_date :: Maybe UTCTime
- ms_hie_date :: Maybe UTCTime
- ms_srcimps :: [(Maybe FastString, Located ModuleName)]
- ms_textual_imps :: [(Maybe FastString, Located ModuleName)]
- ms_parsed_mod :: Maybe HsParsedModule
- ms_hspp_file :: FilePath
- ms_hspp_opts :: DynFlags
- ms_hspp_buf :: Maybe StringBuffer
}
data SourceModified
- = SourceModified
- | SourceUnmodified
- | SourceUnmodifiedAndStable
data HpcInfo
- = HpcInfo {
  - hpcInfoTickCount :: Int
  - hpcInfoHash :: Int
  }
- | NoHpcInfo {
  - hpcUsed :: AnyHpcUsage
  }
type AnyHpcUsage = Bool
type IsSafeImport = Bool
data IfaceTrustInfo
data HsParsedModule = HsParsedModule {
- hpm_module :: Located (HsModule GhcPs)
- hpm_src_files :: [FilePath]
- hpm_annotations :: ApiAnns
}
data CompleteMatch = CompleteMatch {
- completeMatchConLikes :: [Name]
- completeMatchTyCon :: Name
}
type CompleteMatchMap = UniqFM [CompleteMatch]
freeVars :: CoreExpr -> CoreExprWithFVs
freeVarsBind :: CoreBind -> DVarSet -> (CoreBindWithFVs, DVarSet)
stableUnfoldingVars :: Unfolding -> Maybe VarSet
idUnfoldingVars :: Id -> VarSet
idRuleVars :: Id -> VarSet
bndrRuleAndUnfoldingVarsDSet :: Id -> DVarSet
idFVs :: Id -> FV
dIdFreeVars :: Id -> DVarSet
idFreeVars :: Id -> VarSet
varTypeTyCoFVs :: Var -> FV
varTypeTyCoVars :: Var -> TyCoVarSet
freeVarsOfAnn :: FVAnn -> DIdSet
freeVarsOf :: CoreExprWithFVs -> DIdSet
ruleLhsFreeIdsList :: CoreRule -> [Var]
ruleLhsFreeIds :: CoreRule -> VarSet
rulesFreeVars :: [CoreRule] -> VarSet
idRuleRhsVars :: (Activation -> Bool) -> Id -> VarSet
rulesFreeVarsDSet :: [CoreRule] -> DVarSet
ruleFreeVars :: CoreRule -> VarSet
ruleRhsFreeVars :: CoreRule -> VarSet
orphNamesOfFamInst :: FamInst -> NameSet
orphNamesOfAxiom :: forall (br :: BranchFlag). CoAxiom br -> NameSet
orphNamesOfCoCon :: forall (br :: BranchFlag). CoAxiom br -> NameSet
orphNamesOfCo :: Coercion -> NameSet
orphNamesOfTypes :: [Type] -> NameSet
orphNamesOfType :: Type -> NameSet
exprsOrphNames :: [CoreExpr] -> NameSet
expr_fvs :: CoreExpr -> FV
exprsSomeFreeVarsList :: InterestingVarFun -> [CoreExpr] -> [Var]
exprsSomeFreeVars :: InterestingVarFun -> [CoreExpr] -> VarSet
exprSomeFreeVarsList :: InterestingVarFun -> CoreExpr -> [Var]
exprSomeFreeVars :: InterestingVarFun -> CoreExpr -> VarSet
bindFreeVars :: CoreBind -> VarSet
exprsFreeVarsList :: [CoreExpr] -> [Var]
exprsFreeVars :: [CoreExpr] -> VarSet
exprsFreeIdsList :: [CoreExpr] -> [Id]
exprsFreeIdsDSet :: [CoreExpr] -> DIdSet
exprFreeIdsList :: CoreExpr -> [Id]
exprFreeIdsDSet :: CoreExpr -> DIdSet
exprFreeIds :: CoreExpr -> IdSet
exprFreeVarsList :: CoreExpr -> [Var]
exprFreeVarsDSet :: CoreExpr -> DVarSet
exprFreeVars :: CoreExpr -> VarSet
type FVAnn = DVarSet
type CoreBindWithFVs = AnnBind Id FVAnn
type CoreExprWithFVs = AnnExpr Id FVAnn
type CoreExprWithFVs' = AnnExpr' Id FVAnn
type CoreAltWithFVs = AnnAlt Id FVAnn
data Linkable = LM {
- linkableTime :: UTCTime
- linkableModule :: Module
- linkableUnlinked :: [Unlinked]
}
data Unlinked
- = DotO FilePath
- | DotA FilePath
- | DotDLL FilePath
- | BCOs CompiledByteCode [SptEntry]
data SptEntry = SptEntry Id Fingerprint
emptyModBreaks :: ModBreaks
data CompiledByteCode
data ModBreaks = ModBreaks {
- modBreaks_flags :: ForeignRef BreakArray
- modBreaks_locs :: !(Array BreakIndex SrcSpan)
- modBreaks_vars :: !(Array BreakIndex [OccName])
- modBreaks_decls :: !(Array BreakIndex [String])
- modBreaks_ccs :: !(Array BreakIndex (RemotePtr CostCentre))
- modBreaks_breakInfo :: IntMap CgBreakInfo
}
promotedNilDataCon :: TyCon
promotedConsDataCon :: TyCon
promotedGTDataCon :: TyCon
promotedEQDataCon :: TyCon
promotedLTDataCon :: TyCon
promotedJustDataCon :: TyCon
promotedNothingDataCon :: TyCon
promotedFalseDataCon :: TyCon
promotedTrueDataCon :: TyCon
mkSumTy :: [Type] -> Type
mkTupleTy1 :: Boxity -> [Type] -> Type
mkTupleTy :: Boxity -> [Type] -> Type
justDataCon :: DataCon
nothingDataCon :: DataCon
maybeTyCon :: TyCon
consDataCon :: DataCon
nilDataCon :: DataCon
mkListTy :: Type -> Type
ordGTDataConId :: Id
ordEQDataConId :: Id
ordLTDataConId :: Id
ordGTDataCon :: DataCon
ordEQDataCon :: DataCon
ordLTDataCon :: DataCon
orderingTyCon :: TyCon
trueDataConId :: Id
falseDataConId :: Id
trueDataCon :: DataCon
falseDataCon :: DataCon
boolTyCon :: TyCon
boolTy :: Type
doubleDataCon :: DataCon
doubleTyCon :: TyCon
doubleTy :: Type
floatDataCon :: DataCon
floatTyCon :: TyCon
floatTy :: Type
word8DataCon :: DataCon
word8TyCon :: TyCon
word8Ty :: Type
wordDataCon :: DataCon
wordTyCon :: TyCon
wordTy :: Type
intDataCon :: DataCon
intTyCon :: TyCon
intTy :: Type
stringTy :: Type
charDataCon :: DataCon
charTyCon :: TyCon
charTy :: Type
boxingDataCon_maybe :: TyCon -> Maybe DataCon
liftedRepTy :: Type
liftedRepDataCon :: DataCon
sumRepDataConTyCon :: TyCon
liftedTypeKindTyCon :: TyCon
coercibleDataCon :: DataCon
coercibleClass :: Class
heqDataCon :: DataCon
heqClass :: Class
eqDataCon :: DataCon
eqClass :: Class
eqTyCon :: TyCon
unboxedSumKind :: [Type] -> Kind
sumDataCon :: ConTag -> Arity -> DataCon
sumTyCon :: Arity -> TyCon
unboxedUnitDataCon :: DataCon
unboxedUnitTyCon :: TyCon
pairTyCon :: TyCon
unitDataConId :: Id
unitDataCon :: DataCon
unitTyConKey :: Unique
unitTyCon :: TyCon
tupleDataConName :: Boxity -> Arity -> Name
tupleDataCon :: Boxity -> Arity -> DataCon
promotedTupleDataCon :: Boxity -> Arity -> TyCon
tupleTyCon :: Boxity -> Arity -> TyCon
cTupleDataConNames :: [Name]
cTupleDataConName :: Arity -> Name
cTupleTyConNameArity_maybe :: Name -> Maybe Arity
isCTupleTyConName :: Name -> Bool
cTupleTyConNames :: [Name]
cTupleTyConName :: Arity -> Name
mkTupleStr :: Boxity -> Arity -> String
isBuiltInOcc_maybe :: OccName -> Maybe Name
typeToTypeKind :: Kind
constraintKindTyCon :: TyCon
typeSymbolKindCon :: TyCon
typeNatKindCon :: TyCon
consDataCon_RDR :: RdrName
listTyCon_RDR :: RdrName
intDataCon_RDR :: RdrName
charTyCon_RDR :: RdrName
intTyCon_RDR :: RdrName
true_RDR :: RdrName
false_RDR :: RdrName
boolTyCon_RDR :: RdrName
liftedTypeKindTyConName :: Name
constraintKindTyConName :: Name
makeRecoveryTyCon :: TyCon -> TyCon
anyTy :: Type
anyTyCon :: TyCon
doubleTyConName :: Name
floatTyConName :: Name
word8TyConName :: Name
wordTyConName :: Name
justDataConName :: Name
nothingDataConName :: Name
maybeTyConName :: Name
consDataConName :: Name
nilDataConName :: Name
listTyConName :: Name
boolTyConName :: Name
intTyConName :: Name
charTyConName :: Name
coercibleTyConName :: Name
heqTyConName :: Name
eqTyCon_RDR :: RdrName
eqTyConName :: Name
mkWiredInIdName :: Module -> FastString -> Unique -> Id -> Name
mkWiredInTyConName :: BuiltInSyntax -> Module -> FastString -> Unique -> TyCon -> Name
wiredInTyCons :: [TyCon]
isNeverLevPolyId :: Id -> Bool
transferPolyIdInfo :: Id -> [Var] -> Id -> Id
zapStableUnfolding :: Id -> Id
zapIdTailCallInfo :: Id -> Id
zapIdUsedOnceInfo :: Id -> Id
zapIdUsageEnvInfo :: Id -> Id
zapIdUsageInfo :: Id -> Id
zapIdDemandInfo :: Id -> Id
zapFragileIdInfo :: Id -> Id
zapLamIdInfo :: Id -> Id
updOneShotInfo :: Id -> OneShotInfo -> Id
setIdOneShotInfo :: Id -> OneShotInfo -> Id
clearOneShotLambda :: Id -> Id
setOneShotLambda :: Id -> Id
isProbablyOneShotLambda :: Id -> Bool
isStateHackType :: Type -> Bool
typeOneShot :: Type -> OneShotInfo
stateHackOneShot :: OneShotInfo
isOneShotBndr :: Var -> Bool
idStateHackOneShotInfo :: Id -> OneShotInfo
idOneShotInfo :: Id -> OneShotInfo
isConLikeId :: Id -> Bool
idRuleMatchInfo :: Id -> RuleMatchInfo
setInlineActivation :: Id -> Activation -> Id
idInlineActivation :: Id -> Activation
modifyInlinePragma :: Id -> (InlinePragma -> InlinePragma) -> Id
setInlinePragma :: Id -> InlinePragma -> Id
idInlinePragma :: Id -> InlinePragma
zapIdOccInfo :: Id -> Id
setIdOccInfo :: Id -> OccInfo -> Id
idOccInfo :: Id -> OccInfo
setIdCafInfo :: Id -> CafInfo -> Id
idCafInfo :: Id -> CafInfo
setIdSpecialisation :: Id -> RuleInfo -> Id
idHasRules :: Id -> Bool
idCoreRules :: Id -> [CoreRule]
idSpecialisation :: Id -> RuleInfo
setCaseBndrEvald :: StrictnessMark -> Id -> Id
setIdDemandInfo :: Id -> Demand -> Id
idDemandInfo :: Id -> Demand
setIdUnfolding :: Id -> Unfolding -> Id
realIdUnfolding :: Id -> Unfolding
idUnfolding :: Id -> Unfolding
isStrictId :: Id -> Bool
zapIdStrictness :: Id -> Id
setIdStrictness :: Id -> StrictSig -> Id
idStrictness :: Id -> StrictSig
isBottomingId :: Var -> Bool
idFunRepArity :: Id -> RepArity
setIdCallArity :: Id -> Arity -> Id
idCallArity :: Id -> Arity
setIdArity :: Id -> Arity -> Id
idArity :: Id -> Arity
asJoinId_maybe :: Id -> Maybe JoinArity -> Id
zapJoinId :: Id -> Id
asJoinId :: Id -> JoinArity -> JoinId
idJoinArity :: JoinId -> JoinArity
isDeadBinder :: Id -> Bool
idIsFrom :: Module -> Id -> Bool
isImplicitId :: Id -> Bool
hasNoBinding :: Id -> Bool
idDataCon :: Id -> DataCon
isJoinId_maybe :: Var -> Maybe JoinArity
isJoinId :: Var -> Bool
isDataConId_maybe :: Id -> Maybe DataCon
isDataConWrapId_maybe :: Id -> Maybe DataCon
isDataConWrapId :: Id -> Bool
isDataConWorkId_maybe :: Id -> Maybe DataCon
isDataConWorkId :: Id -> Bool
isFCallId_maybe :: Id -> Maybe ForeignCall
isFCallId :: Id -> Bool
isPrimOpId_maybe :: Id -> Maybe PrimOp
isDFunId :: Id -> Bool
isPrimOpId :: Id -> Bool
isClassOpId_maybe :: Id -> Maybe Class
isNaughtyRecordSelector :: Id -> Bool
isPatSynRecordSelector :: Id -> Bool
isDataConRecordSelector :: Id -> Bool
isRecordSelector :: Id -> Bool
recordSelectorTyCon :: Id -> RecSelParent
mkTemplateLocalsNum :: Int -> [Type] -> [Id]
mkTemplateLocals :: [Type] -> [Id]
mkTemplateLocal :: Int -> Type -> Id
mkWorkerId :: Unique -> Id -> Type -> Id
mkUserLocalOrCoVar :: OccName -> Unique -> Type -> SrcSpan -> Id
mkUserLocal :: OccName -> Unique -> Type -> SrcSpan -> Id
mkSysLocalOrCoVarM :: MonadUnique m => FastString -> Type -> m Id
mkSysLocalM :: MonadUnique m => FastString -> Type -> m Id
mkSysLocalOrCoVar :: FastString -> Unique -> Type -> Id
mkSysLocal :: FastString -> Unique -> Type -> Id
mkExportedVanillaId :: Name -> Type -> Id
mkExportedLocalId :: IdDetails -> Name -> Type -> Id
mkLocalIdWithInfo :: Name -> Type -> IdInfo -> Id
mkLocalIdOrCoVarWithInfo :: Name -> Type -> IdInfo -> Id
mkLocalIdOrCoVar :: Name -> Type -> Id
mkLocalCoVar :: Name -> Type -> CoVar
mkLocalId :: Name -> Type -> Id
mkVanillaGlobalWithInfo :: Name -> Type -> IdInfo -> Id
mkVanillaGlobal :: Name -> Type -> Id
mkGlobalId :: IdDetails -> Name -> Type -> IdInfo -> Id
maybeModifyIdInfo :: Maybe IdInfo -> Id -> Id
modifyIdInfo :: HasDebugCallStack => (IdInfo -> IdInfo) -> Id -> Id
setIdInfo :: Id -> IdInfo -> Id
localiseId :: Id -> Id
setIdType :: Id -> Type -> Id
setIdUnique :: Id -> Unique -> Id
setIdName :: Id -> Name -> Id
idType :: Id -> Kind
idUnique :: Id -> Unique
idName :: Id -> Name
isNeverLevPolyIdInfo :: IdInfo -> Bool
setLevityInfoWithType :: IdInfo -> Type -> IdInfo
setNeverLevPoly :: HasDebugCallStack => IdInfo -> Type -> IdInfo
zapCallArityInfo :: IdInfo -> IdInfo
zapTailCallInfo :: IdInfo -> Maybe IdInfo
zapUnfolding :: Unfolding -> Unfolding
zapFragileInfo :: IdInfo -> Maybe IdInfo
zapUsedOnceInfo :: IdInfo -> Maybe IdInfo
zapUsageEnvInfo :: IdInfo -> Maybe IdInfo
zapUsageInfo :: IdInfo -> Maybe IdInfo
zapDemandInfo :: IdInfo -> Maybe IdInfo
zapLamInfo :: IdInfo -> Maybe IdInfo
ppCafInfo :: CafInfo -> SDoc
mayHaveCafRefs :: CafInfo -> Bool
setRuleInfoHead :: Name -> RuleInfo -> RuleInfo
ruleInfoRules :: RuleInfo -> [CoreRule]
ruleInfoFreeVars :: RuleInfo -> DVarSet
isEmptyRuleInfo :: RuleInfo -> Bool
emptyRuleInfo :: RuleInfo
pprStrictness :: StrictSig -> SDoc
ppArityInfo :: Int -> SDoc
unknownArity :: Arity
noCafIdInfo :: IdInfo
setStrictnessInfo :: IdInfo -> StrictSig -> IdInfo
setDemandInfo :: IdInfo -> Demand -> IdInfo
setOneShotInfo :: IdInfo -> OneShotInfo -> IdInfo
setCafInfo :: IdInfo -> CafInfo -> IdInfo
setCallArityInfo :: IdInfo -> ArityInfo -> IdInfo
setArityInfo :: IdInfo -> ArityInfo -> IdInfo
setUnfoldingInfo :: IdInfo -> Unfolding -> IdInfo
setOccInfo :: IdInfo -> OccInfo -> IdInfo
setInlinePragInfo :: IdInfo -> InlinePragma -> IdInfo
setRuleInfo :: IdInfo -> RuleInfo -> IdInfo
isJoinIdDetails_maybe :: IdDetails -> Maybe JoinArity
data RecSelParent
- = RecSelData TyCon
- | RecSelPatSyn PatSyn
type ArityInfo = Arity
type InlinePragInfo = InlinePragma
data RuleInfo = RuleInfo [CoreRule] DVarSet
data CafInfo
- = MayHaveCafRefs
- | NoCafRefs
type TickBoxId = Int
data TickBoxOp = TickBox Module !TickBoxId
data LevityInfo
collectNAnnBndrs :: Int -> AnnExpr bndr annot -> ([bndr], AnnExpr bndr annot)
collectAnnBndrs :: AnnExpr bndr annot -> ([bndr], AnnExpr bndr annot)
deAnnBind :: AnnBind b annot -> Bind b
deAnnAlt :: AnnAlt bndr annot -> Alt bndr
deAnnotate' :: AnnExpr' bndr annot -> Expr bndr
deAnnotate :: AnnExpr bndr annot -> Expr bndr
collectAnnArgsTicks :: (Tickish Var -> Bool) -> AnnExpr b a -> (AnnExpr b a, [AnnExpr b a], [Tickish Var])
collectAnnArgs :: AnnExpr b a -> (AnnExpr b a, [AnnExpr b a])
valArgCount :: [Arg b] -> Int
valBndrCount :: [CoreBndr] -> Int
isTypeArg :: Expr b -> Bool
isCoArg :: Expr b -> Bool
isTyCoArg :: Expr b -> Bool
isValArg :: Expr b -> Bool
isRuntimeArg :: CoreExpr -> Bool
isRuntimeVar :: Var -> Bool
collectArgsTicks :: (Tickish Id -> Bool) -> Expr b -> (Expr b, [Arg b], [Tickish Id])
stripNArgs :: Word -> Expr a -> Maybe (Expr a)
collectArgs :: Expr b -> (Expr b, [Arg b])
collectNBinders :: Int -> Expr b -> ([b], Expr b)
collectTyAndValBinders :: CoreExpr -> ([TyVar], [Id], CoreExpr)
collectTyBinders :: CoreExpr -> ([TyVar], CoreExpr)
collectBinders :: Expr b -> ([b], Expr b)
flattenBinds :: [Bind b] -> [(b, Expr b)]
rhssOfAlts :: [Alt b] -> [Expr b]
rhssOfBind :: Bind b -> [Expr b]
bindersOfBinds :: [Bind b] -> [b]
bindersOf :: Bind b -> [b]
exprToCoercion_maybe :: CoreExpr -> Maybe Coercion
exprToType :: CoreExpr -> Type
applyTypeToArg :: Type -> CoreExpr -> Type
varsToCoreExprs :: [CoreBndr] -> [Expr b]
varToCoreExpr :: CoreBndr -> Expr b
mkCoBind :: CoVar -> Coercion -> CoreBind
mkTyBind :: TyVar -> Type -> CoreBind
mkLetRec :: [(b, Expr b)] -> Expr b -> Expr b
mkLetNonRec :: b -> Expr b -> Expr b -> Expr b
mkLet :: Bind b -> Expr b -> Expr b
mkLets :: [Bind b] -> Expr b -> Expr b
mkLams :: [b] -> Expr b -> Expr b
mkDoubleLitDouble :: Double -> Expr b
mkDoubleLit :: Rational -> Expr b
mkFloatLitFloat :: Float -> Expr b
mkFloatLit :: Rational -> Expr b
mkStringLit :: String -> Expr b
mkCharLit :: Char -> Expr b
mkInt64LitInt64 :: Int64 -> Expr b
mkWord64LitWord64 :: Word64 -> Expr b
mkWordLitWord :: DynFlags -> Word -> Expr b
mkWordLit :: DynFlags -> Integer -> Expr b
mkIntLitInt :: DynFlags -> Int -> Expr b
mkIntLit :: DynFlags -> Integer -> Expr b
mkTyArg :: Type -> Expr b
mkConApp2 :: DataCon -> [Type] -> [Var] -> Expr b
mkTyApps :: Expr b -> [Type] -> Expr b
mkConApp :: DataCon -> [Arg b] -> Expr b
mkVarApps :: Expr b -> [Var] -> Expr b
mkCoApps :: Expr b -> [Coercion] -> Expr b
mkApps :: Expr b -> [Arg b] -> Expr b
deTagExpr :: TaggedExpr t -> CoreExpr
cmpAltCon :: AltCon -> AltCon -> Ordering
ltAlt :: (AltCon, a, b) -> (AltCon, a, b) -> Bool
cmpAlt :: (AltCon, a, b) -> (AltCon, a, b) -> Ordering
canUnfold :: Unfolding -> Bool
isFragileUnfolding :: Unfolding -> Bool
neverUnfoldGuidance :: UnfoldingGuidance -> Bool
isBootUnfolding :: Unfolding -> Bool
hasSomeUnfolding :: Unfolding -> Bool
isStableUnfolding :: Unfolding -> Bool
isCompulsoryUnfolding :: Unfolding -> Bool
expandUnfolding_maybe :: Unfolding -> Maybe CoreExpr
isExpandableUnfolding :: Unfolding -> Bool
isCheapUnfolding :: Unfolding -> Bool
isConLikeUnfolding :: Unfolding -> Bool
isEvaldUnfolding :: Unfolding -> Bool
isValueUnfolding :: Unfolding -> Bool
otherCons :: Unfolding -> [AltCon]
maybeUnfoldingTemplate :: Unfolding -> Maybe CoreExpr
unfoldingTemplate :: Unfolding -> CoreExpr
isStableSource :: UnfoldingSource -> Bool
mkOtherCon :: [AltCon] -> Unfolding
bootUnfolding :: Unfolding
evaldUnfolding :: Unfolding
noUnfolding :: Unfolding
boringCxtNotOk :: Bool
boringCxtOk :: Bool
unSaturatedOk :: Bool
needSaturated :: Bool
setRuleIdName :: Name -> CoreRule -> CoreRule
isLocalRule :: CoreRule -> Bool
ruleIdName :: CoreRule -> Name
ruleActivation :: CoreRule -> Activation
ruleModule :: CoreRule -> Maybe Module
ruleName :: CoreRule -> RuleName
ruleArity :: CoreRule -> Int
isAutoRule :: CoreRule -> Bool
isBuiltinRule :: CoreRule -> Bool
emptyRuleEnv :: RuleEnv
mkRuleEnv :: RuleBase -> [Module] -> RuleEnv
chooseOrphanAnchor :: NameSet -> IsOrphan
notOrphan :: IsOrphan -> Bool
isOrphan :: IsOrphan -> Bool
tickishContains :: Eq b => Tickish b -> Tickish b -> Bool
tickishPlace :: Tickish id -> TickishPlacement
tickishIsCode :: Tickish id -> Bool
mkNoScope :: Tickish id -> Tickish id
mkNoCount :: Tickish id -> Tickish id
tickishCanSplit :: Tickish id -> Bool
tickishFloatable :: Tickish id -> Bool
tickishScopesLike :: Tickish id -> TickishScoping -> Bool
tickishScoped :: Tickish id -> TickishScoping
tickishCounts :: Tickish id -> Bool
data Expr b
- = Var Id
- | Lit Literal
- | App (Expr b) (Arg b)
- | Lam b (Expr b)
- | Let (Bind b) (Expr b)
- | Case (Expr b) b Type [Alt b]
- | Cast (Expr b) Coercion
- | Tick (Tickish Id) (Expr b)
- | Type Type
- | Coercion Coercion
type Arg b = Expr b
type Alt b = (AltCon, [b], Expr b)
data AltCon
- = DataAlt DataCon
- | LitAlt Literal
- | DEFAULT
data Bind b
- = NonRec b (Expr b)
- | Rec [(b, Expr b)]
type InBndr = CoreBndr
type InType = Type
type InKind = Kind
type InBind = CoreBind
type InExpr = CoreExpr
type InAlt = CoreAlt
type InArg = CoreArg
type InCoercion = Coercion
type OutBndr = CoreBndr
type OutType = Type
type OutKind = Kind
type OutCoercion = Coercion
type OutBind = CoreBind
type OutExpr = CoreExpr
type OutAlt = CoreAlt
type OutArg = CoreArg
type MOutCoercion = MCoercion
data Tickish id
- = ProfNote {
  - profNoteCC :: CostCentre
  - profNoteCount :: !Bool
  - profNoteScope :: !Bool
  }
- | HpcTick {
  - tickModule :: Module
  - tickId :: !Int
  }
- | Breakpoint {
  - breakpointId :: !Int
  - breakpointFVs :: [id]
  }
- | SourceNote {
  - sourceSpan :: RealSrcSpan
  - sourceName :: String
  }
data TickishScoping
- = NoScope
- | SoftScope
- | CostCentreScope
data TickishPlacement
- = PlaceRuntime
- | PlaceNonLam
- | PlaceCostCentre
data IsOrphan
- = IsOrphan
- | NotOrphan OccName
type RuleBase = NameEnv [CoreRule]
data RuleEnv = RuleEnv {
- re_base :: RuleBase
- re_visible_orphs :: ModuleSet
}
data CoreRule
- = Rule {
  - ru_name :: RuleName
  - ru_act :: Activation
  - ru_fn :: Name
  - ru_rough :: [Maybe Name]
  - ru_bndrs :: [CoreBndr]
  - ru_args :: [CoreExpr]
  - ru_rhs :: CoreExpr
  - ru_auto :: Bool
  - ru_origin :: !Module
  - ru_orphan :: !IsOrphan
  - ru_local :: Bool
  }
- | BuiltinRule {
  - ru_name :: RuleName
  - ru_fn :: Name
  - ru_nargs :: Int
  - ru_try :: RuleFun
  }
type RuleFun = DynFlags -> InScopeEnv -> Id -> [CoreExpr] -> Maybe CoreExpr
type InScopeEnv = (InScopeSet, IdUnfoldingFun)
type IdUnfoldingFun = Id -> Unfolding
data Unfolding
- = NoUnfolding
- | BootUnfolding
- | OtherCon [AltCon]
- | DFunUnfolding {
  - df_bndrs :: [Var]
  - df_con :: DataCon
  - df_args :: [CoreExpr]
  }
- | CoreUnfolding {
  - uf_tmpl :: CoreExpr
  - uf_src :: UnfoldingSource
  - uf_is_top :: Bool
  - uf_is_value :: Bool
  - uf_is_conlike :: Bool
  - uf_is_work_free :: Bool
  - uf_expandable :: Bool
  - uf_guidance :: UnfoldingGuidance
  }
data UnfoldingSource
- = InlineRhs
- | InlineStable
- | InlineCompulsory
data UnfoldingGuidance
- = UnfWhen {
  - ug_arity :: Arity
  - ug_unsat_ok :: Bool
  - ug_boring_ok :: Bool
  }
- | UnfIfGoodArgs {
  - ug_args :: [Int]
  - ug_size :: Int
  - ug_res :: Int
  }
- | UnfNever
type CoreProgram = [CoreBind]
type CoreBndr = Var
type CoreExpr = Expr CoreBndr
type CoreArg = Arg CoreBndr
type CoreBind = Bind CoreBndr
type CoreAlt = Alt CoreBndr
data TaggedBndr t = TB CoreBndr t
type TaggedBind t = Bind (TaggedBndr t)
type TaggedExpr t = Expr (TaggedBndr t)
type TaggedArg t = Arg (TaggedBndr t)
type TaggedAlt t = Alt (TaggedBndr t)
type AnnExpr bndr annot = (annot, AnnExpr' bndr annot)
data AnnExpr' bndr annot
- = AnnVar Id
- | AnnLit Literal
- | AnnLam bndr (AnnExpr bndr annot)
- | AnnApp (AnnExpr bndr annot) (AnnExpr bndr annot)
- | AnnCase (AnnExpr bndr annot) bndr Type [AnnAlt bndr annot]
- | AnnLet (AnnBind bndr annot) (AnnExpr bndr annot)
- | AnnCast (AnnExpr bndr annot) (annot, Coercion)
- | AnnTick (Tickish Id) (AnnExpr bndr annot)
- | AnnType Type
- | AnnCoercion Coercion
type AnnAlt bndr annot = (AltCon, [bndr], AnnExpr bndr annot)
data AnnBind bndr annot
- = AnnNonRec bndr (AnnExpr bndr annot)
- | AnnRec [(bndr, AnnExpr bndr annot)]
buildSynTyCon :: Name -> [KnotTied TyConBinder] -> Kind -> [Role] -> KnotTied Type -> TyCon
buildAlgTyCon :: Name -> [TyVar] -> [Role] -> Maybe CType -> ThetaType -> AlgTyConRhs -> Bool -> AlgTyConFlav -> TyCon
splitDataProductType_maybe :: Type -> Maybe (TyCon, [Type], DataCon, [Type])
promoteDataCon :: DataCon -> TyCon
dataConUserTyVarsArePermuted :: DataCon -> Bool
dataConCannotMatch :: [Type] -> DataCon -> Bool
classDataCon :: Class -> DataCon
specialPromotedDc :: DataCon -> Bool
isVanillaDataCon :: DataCon -> Bool
isUnboxedTupleCon :: DataCon -> Bool
isTupleDataCon :: DataCon -> Bool
dataConIdentity :: DataCon -> ByteString
dataConRepArgTys :: DataCon -> [Type]
dataConOrigArgTys :: DataCon -> [Type]
dataConInstArgTys :: DataCon -> [Type] -> [Type]
dataConUserType :: DataCon -> Type
dataConOrigResTy :: DataCon -> Type
dataConInstSig :: DataCon -> [Type] -> ([TyCoVar], ThetaType, [Type])
dataConSig :: DataCon -> ([TyCoVar], ThetaType, [Type], Type)
dataConBoxer :: DataCon -> Maybe DataConBoxer
dataConImplBangs :: DataCon -> [HsImplBang]
dataConRepStrictness :: DataCon -> [StrictnessMark]
isNullaryRepDataCon :: DataCon -> Bool
isNullarySrcDataCon :: DataCon -> Bool
dataConRepArity :: DataCon -> Arity
dataConSrcBangs :: DataCon -> [HsSrcBang]
dataConFieldType_maybe :: DataCon -> FieldLabelString -> Maybe (FieldLabel, Type)
dataConFieldType :: DataCon -> FieldLabelString -> Type
dataConImplicitTyThings :: DataCon -> [TyThing]
dataConWrapId :: DataCon -> Id
dataConWrapId_maybe :: DataCon -> Maybe Id
dataConWorkId :: DataCon -> Id
dataConTheta :: DataCon -> ThetaType
dataConEqSpec :: DataCon -> [EqSpec]
dataConUnivAndExTyCoVars :: DataCon -> [TyCoVar]
dataConUnivTyVars :: DataCon -> [TyVar]
dataConIsInfix :: DataCon -> Bool
dataConRepType :: DataCon -> Type
dataConOrigTyCon :: DataCon -> TyCon
dataConTagZ :: DataCon -> ConTagZ
dataConTag :: DataCon -> ConTag
mkDataCon :: Name -> Bool -> TyConRepName -> [HsSrcBang] -> [FieldLabel] -> [TyVar] -> [TyCoVar] -> [TyVarBinder] -> [EqSpec] -> KnotTied ThetaType -> [KnotTied Type] -> KnotTied Type -> RuntimeRepInfo -> KnotTied TyCon -> ConTag -> ThetaType -> Id -> DataConRep -> DataCon
isMarkedStrict :: StrictnessMark -> Bool
isSrcUnpacked :: SrcUnpackedness -> Bool
isSrcStrict :: SrcStrictness -> Bool
isBanged :: HsImplBang -> Bool
eqHsBang :: HsImplBang -> HsImplBang -> Bool
filterEqSpec :: [EqSpec] -> [TyVar] -> [TyVar]
substEqSpec :: TCvSubst -> EqSpec -> EqSpec
eqSpecPreds :: [EqSpec] -> ThetaType
eqSpecPair :: EqSpec -> (TyVar, Type)
eqSpecType :: EqSpec -> Type
eqSpecTyVar :: EqSpec -> TyVar
mkEqSpec :: TyVar -> Type -> EqSpec
data HsSrcBang = HsSrcBang SourceText SrcUnpackedness SrcStrictness
data HsImplBang
- = HsLazy
- | HsStrict
- | HsUnpack (Maybe Coercion)
data SrcStrictness
- = SrcLazy
- | SrcStrict
- | NoSrcStrict
data SrcUnpackedness
- = SrcUnpack
- | SrcNoUnpack
- | NoSrcUnpack
data StrictnessMark
- = MarkedStrict
- | NotMarkedStrict
simplifyArgsWorker :: [TyCoBinder] -> Kind -> TyCoVarSet -> [Role] -> [(Type, Coercion)] -> ([Type], [Coercion], CoercionN)
buildCoercion :: Type -> Type -> CoercionN
mkReprPrimEqPred :: Type -> Type -> Type
mkHeteroReprPrimEqPred :: Kind -> Kind -> Type -> Type -> Type
mkHeteroPrimEqPred :: Kind -> Kind -> Type -> Type -> Type
mkPrimEqPredRole :: Role -> Type -> Type -> PredType
mkPrimEqPred :: Type -> Type -> Type
mkHeteroCoercionType :: Role -> Kind -> Kind -> Type -> Type -> Type
coercionRole :: Coercion -> Role
coercionKindRole :: Coercion -> (Pair Type, Role)
coercionKinds :: [Coercion] -> Pair [Type]
lcInScopeSet :: LiftingContext -> InScopeSet
lcTCvSubst :: LiftingContext -> TCvSubst
liftEnvSubstRight :: TCvSubst -> LiftCoEnv -> TCvSubst
liftEnvSubstLeft :: TCvSubst -> LiftCoEnv -> TCvSubst
lcSubstRight :: LiftingContext -> TCvSubst
lcSubstLeft :: LiftingContext -> TCvSubst
swapLiftCoEnv :: LiftCoEnv -> LiftCoEnv
substRightCo :: LiftingContext -> Coercion -> Coercion
substLeftCo :: LiftingContext -> Coercion -> Coercion
isMappedByLC :: TyCoVar -> LiftingContext -> Bool
liftCoSubstVarBndrUsing :: (LiftingContext -> Type -> (CoercionN, a)) -> LiftingContext -> TyCoVar -> (LiftingContext, TyCoVar, CoercionN, a)
liftCoSubstTyVar :: LiftingContext -> Role -> TyVar -> Maybe Coercion
substForAllCoBndrUsingLC :: Bool -> (Coercion -> Coercion) -> LiftingContext -> TyCoVar -> Coercion -> (LiftingContext, TyCoVar, Coercion)
zapLiftingContext :: LiftingContext -> LiftingContext
extendLiftingContextAndInScope :: LiftingContext -> TyCoVar -> Coercion -> LiftingContext
extendLiftingContext :: LiftingContext -> TyCoVar -> Coercion -> LiftingContext
mkSubstLiftingContext :: TCvSubst -> LiftingContext
emptyLiftingContext :: InScopeSet -> LiftingContext
liftCoSubstWith :: Role -> [TyCoVar] -> [Coercion] -> Type -> Coercion
liftCoSubstWithEx :: Role -> [TyVar] -> [Coercion] -> [TyCoVar] -> [Type] -> (Type -> Coercion, [Type])
eqCoercionX :: RnEnv2 -> Coercion -> Coercion -> Bool
eqCoercion :: Coercion -> Coercion -> Bool
topNormaliseNewType_maybe :: Type -> Maybe (Coercion, Type)
topNormaliseTypeX :: NormaliseStepper ev -> (ev -> ev -> ev) -> Type -> Maybe (ev, Type)
unwrapNewTypeStepper :: NormaliseStepper Coercion
composeSteppers :: NormaliseStepper ev -> NormaliseStepper ev -> NormaliseStepper ev
mapStepResult :: (ev1 -> ev2) -> NormaliseStepResult ev1 -> NormaliseStepResult ev2
instNewTyCon_maybe :: TyCon -> [Type] -> Maybe (Type, Coercion)
mkCoCast :: Coercion -> CoercionR -> Coercion
mkPiCo :: Role -> Var -> Coercion -> Coercion
mkPiCos :: Role -> [Var] -> Coercion -> Coercion
castCoercionKindI :: Coercion -> CoercionN -> CoercionN -> Coercion
castCoercionKind :: Coercion -> Role -> Type -> Type -> CoercionN -> CoercionN -> Coercion
promoteCoercion :: Coercion -> CoercionN
ltRole :: Role -> Role -> Bool
nthRole :: Role -> TyCon -> Int -> Role
tyConRolesRepresentational :: TyCon -> [Role]
tyConRolesX :: Role -> TyCon -> [Role]
setNominalRole_maybe :: Role -> Coercion -> Maybe Coercion
downgradeRole :: Role -> Role -> Coercion -> Coercion
mkCoherenceRightCo :: Role -> Type -> CoercionN -> Coercion -> Coercion
mkCoherenceLeftCo :: Role -> Type -> CoercionN -> Coercion -> Coercion
mkGReflLeftCo :: Role -> Type -> CoercionN -> Coercion
mkGReflRightCo :: Role -> Type -> CoercionN -> Coercion
nthCoRole :: Int -> Coercion -> Role
mkTransMCo :: MCoercion -> MCoercion -> MCoercion
mkHoleCo :: CoercionHole -> Coercion
mkUnbranchedAxInstLHS :: CoAxiom Unbranched -> [Type] -> [Coercion] -> Type
mkAxInstLHS :: forall (br :: BranchFlag). CoAxiom br -> BranchIndex -> [Type] -> [Coercion] -> Type
mkUnbranchedAxInstRHS :: CoAxiom Unbranched -> [Type] -> [Coercion] -> Type
mkAxInstRHS :: forall (br :: BranchFlag). CoAxiom br -> BranchIndex -> [Type] -> [Coercion] -> Type
mkUnbranchedAxInstCo :: Role -> CoAxiom Unbranched -> [Type] -> [Coercion] -> Coercion
mkAxInstCo :: forall (br :: BranchFlag). Role -> CoAxiom br -> BranchIndex -> [Type] -> [Coercion] -> Coercion
isCoVar_maybe :: Coercion -> Maybe CoVar
mkCoVarCos :: [CoVar] -> [Coercion]
mkHomoForAllCos :: [TyCoVar] -> Coercion -> Coercion
mkForAllCos :: [(TyCoVar, CoercionN)] -> Coercion -> Coercion
mkAppCos :: Coercion -> [Coercion] -> Coercion
mkRepReflCo :: Type -> Coercion
coToMCo :: Coercion -> MCoercion
isReflexiveCo_maybe :: Coercion -> Maybe (Type, Role)
isReflCo_maybe :: Coercion -> Maybe (Type, Role)
isGReflCo_maybe :: Coercion -> Maybe (Type, Role)
isGReflMCo :: MCoercion -> Bool
isReflCoVar_maybe :: Var -> Maybe Coercion
coVarKind :: CoVar -> Type
coVarTypes :: HasDebugCallStack => CoVar -> Pair Type
splitForAllCo_co_maybe :: Coercion -> Maybe (CoVar, Coercion, Coercion)
splitForAllCo_ty_maybe :: Coercion -> Maybe (TyVar, Coercion, Coercion)
splitForAllCo_maybe :: Coercion -> Maybe (TyCoVar, Coercion, Coercion)
splitFunCo_maybe :: Coercion -> Maybe (Coercion, Coercion)
splitAppCo_maybe :: Coercion -> Maybe (Coercion, Coercion)
splitTyConAppCo_maybe :: Coercion -> Maybe (TyCon, [Coercion])
getCoVar_maybe :: Coercion -> Maybe CoVar
decomposeFunCo :: HasDebugCallStack => Role -> Coercion -> (Coercion, Coercion)
decomposeCo :: Arity -> Coercion -> [Role] -> [Coercion]
tidyCoAxBndrsForUser :: TidyEnv -> [Var] -> (TidyEnv, [Var])
pprCoAxBranch :: TyCon -> CoAxBranch -> SDoc
pprCoAxBranchLHS :: TyCon -> CoAxBranch -> SDoc
pprCoAxBranchUser :: TyCon -> CoAxBranch -> SDoc
pprCoAxiom :: forall (br :: BranchFlag). CoAxiom br -> SDoc
etaExpandCoAxBranch :: CoAxBranch -> ([TyVar], [Type], Type)
setCoVarName :: CoVar -> Name -> CoVar
setCoVarUnique :: CoVar -> Unique -> CoVar
coVarName :: CoVar -> Name
type NormaliseStepper ev = RecTcChecker -> TyCon -> [Type] -> NormaliseStepResult ev
data NormaliseStepResult ev
- = NS_Done
- | NS_Abort
- | NS_Step RecTcChecker Type ev
type LiftCoEnv = VarEnv Coercion
pprLiteral :: (SDoc -> SDoc) -> Literal -> SDoc
absentLiteralOf :: TyCon -> Maybe Literal
literalType :: Literal -> Type
litIsLifted :: Literal -> Bool
litFitsInChar :: Literal -> Bool
litIsDupable :: DynFlags -> Literal -> Bool
litIsTrivial :: Literal -> Bool
rubbishLit :: Literal
nullAddrLit :: Literal
double2FloatLit :: Literal -> Literal
float2DoubleLit :: Literal -> Literal
int2DoubleLit :: Literal -> Literal
double2IntLit :: Literal -> Literal
int2FloatLit :: Literal -> Literal
float2IntLit :: Literal -> Literal
int2CharLit :: Literal -> Literal
char2IntLit :: Literal -> Literal
narrow32WordLit :: Literal -> Literal
narrow16WordLit :: Literal -> Literal
narrow8WordLit :: Literal -> Literal
narrow32IntLit :: Literal -> Literal
narrow16IntLit :: Literal -> Literal
narrow8IntLit :: Literal -> Literal
narrowLit :: Integral a => Proxy a -> Literal -> Literal
int2WordLit :: DynFlags -> Literal -> Literal
word2IntLit :: DynFlags -> Literal -> Literal
isLitValue :: Literal -> Bool
mapLitValue :: DynFlags -> (Integer -> Integer) -> Literal -> Literal
isLitValue_maybe :: Literal -> Maybe Integer
litValue :: Literal -> Integer
isZeroLit :: Literal -> Bool
inCharRange :: Char -> Bool
inWordRange :: DynFlags -> Integer -> Bool
inIntRange :: DynFlags -> Integer -> Bool
mkLitNatural :: Integer -> Type -> Literal
mkLitInteger :: Integer -> Type -> Literal
mkLitString :: String -> Literal
mkLitChar :: Char -> Literal
mkLitDouble :: Rational -> Literal
mkLitFloat :: Rational -> Literal
mkLitWord64Wrap :: DynFlags -> Integer -> Literal
mkLitWord64 :: Integer -> Literal
mkLitInt64Wrap :: DynFlags -> Integer -> Literal
mkLitInt64 :: Integer -> Literal
mkLitWordWrapC :: DynFlags -> Integer -> (Literal, Bool)
mkLitWordWrap :: DynFlags -> Integer -> Literal
mkLitWord :: DynFlags -> Integer -> Literal
mkLitIntWrapC :: DynFlags -> Integer -> (Literal, Bool)
mkLitIntWrap :: DynFlags -> Integer -> Literal
mkLitInt :: DynFlags -> Integer -> Literal
mkLitNumber :: DynFlags -> LitNumType -> Integer -> Type -> Literal
litNumCheckRange :: DynFlags -> LitNumType -> Integer -> Bool
mkLitNumberWrap :: DynFlags -> LitNumType -> Integer -> Type -> Literal
litNumIsSigned :: LitNumType -> Bool
data Literal
- = LitChar Char
- | LitNumber !LitNumType !Integer Type
- | LitString ByteString
- | LitNullAddr
- | LitRubbish
- | LitFloat Rational
- | LitDouble Rational
- | LitLabel FastString (Maybe Int) FunctionOrData
data LitNumType
- = LitNumInteger
- | LitNumNatural
- | LitNumInt
- | LitNumInt64
- | LitNumWord
- | LitNumWord64
tyConAppNeedsKindSig :: Bool -> TyCon -> Int -> Bool
classifiesTypeWithValues :: Kind -> Bool
isKindLevPoly :: Kind -> Bool
isConstraintKindCon :: TyCon -> Bool
setJoinResTy :: Int -> Type -> Type -> Type
modifyJoinResTy :: Int -> (Type -> Type) -> Type -> Type
splitVisVarsOfTypes :: [Type] -> Pair TyCoVarSet
splitVisVarsOfType :: Type -> Pair TyCoVarSet
synTyConResKind :: TyCon -> Kind
tyConsOfType :: Type -> UniqSet TyCon
occCheckExpand :: [Var] -> Type -> Maybe Type
resultIsLevPoly :: Type -> Bool
isTypeLevPoly :: Type -> Bool
tcReturnsConstraintKind :: Kind -> Bool
tcIsRuntimeTypeKind :: Kind -> Bool
tcIsLiftedTypeKind :: Kind -> Bool
tcIsConstraintKind :: Kind -> Bool
tcTypeKind :: HasDebugCallStack => Type -> Kind
typeKind :: HasDebugCallStack => Type -> Kind
nonDetCmpTc :: TyCon -> TyCon -> Ordering
nonDetCmpTypesX :: RnEnv2 -> [Type] -> [Type] -> Ordering
nonDetCmpTypeX :: RnEnv2 -> Type -> Type -> Ordering
nonDetCmpTypes :: [Type] -> [Type] -> Ordering
nonDetCmpType :: Type -> Type -> Ordering
eqVarBndrs :: RnEnv2 -> [Var] -> [Var] -> Maybe RnEnv2
eqTypes :: [Type] -> [Type] -> Bool
eqTypeX :: RnEnv2 -> Type -> Type -> Bool
seqTypes :: [Type] -> ()
seqType :: Type -> ()
isValidJoinPointType :: JoinArity -> Type -> Bool
isPrimitiveType :: Type -> Bool
isStrictType :: HasDebugCallStack => Type -> Bool
isDataFamilyAppType :: Type -> Bool
isAlgType :: Type -> Bool
isUnboxedSumType :: Type -> Bool
isUnboxedTupleType :: Type -> Bool
getRuntimeRep :: HasDebugCallStack => Type -> Type
getRuntimeRep_maybe :: HasDebugCallStack => Type -> Maybe Type
dropRuntimeRepArgs :: [Type] -> [Type]
isRuntimeRepKindedTy :: Type -> Bool
mightBeUnliftedType :: Type -> Bool
isUnliftedType :: HasDebugCallStack => Type -> Bool
isLiftedType_maybe :: HasDebugCallStack => Type -> Maybe Bool
isCoVarType :: Type -> Bool
isFamFreeTy :: Type -> Bool
coAxNthLHS :: forall (br :: BranchFlag). CoAxiom br -> Int -> Type
mkFamilyTyConApp :: TyCon -> [Type] -> Type
closeOverKindsDSet :: DTyVarSet -> DTyVarSet
closeOverKindsList :: [TyVar] -> [TyVar]
closeOverKindsFV :: [TyVar] -> FV
closeOverKinds :: TyVarSet -> TyVarSet
binderRelevantType_maybe :: TyCoBinder -> Maybe Type
tyBinderType :: TyBinder -> Type
tyCoBinderType :: TyCoBinder -> Type
tyCoBinderVar_maybe :: TyCoBinder -> Maybe TyCoVar
isAnonTyCoBinder :: TyCoBinder -> Bool
mkAnonBinder :: AnonArgFlag -> Type -> TyCoBinder
isTauTy :: Type -> Bool
appTyArgFlags :: Type -> [Type] -> [ArgFlag]
tyConArgFlags :: TyCon -> [Type] -> [ArgFlag]
partitionInvisibles :: [(a, ArgFlag)] -> ([a], [a])
filterOutInferredTypes :: TyCon -> [Type] -> [Type]
filterOutInvisibleTypes :: TyCon -> [Type] -> [Type]
splitPiTysInvisibleN :: Int -> Type -> ([TyCoBinder], Type)
splitPiTysInvisible :: Type -> ([TyCoBinder], Type)
invisibleTyBndrCount :: Type -> Int
splitForAllVarBndrs :: Type -> ([TyCoVarBinder], Type)
splitPiTys :: Type -> ([TyCoBinder], Type)
splitPiTy :: Type -> (TyCoBinder, Type)
splitPiTy_maybe :: Type -> Maybe (TyCoBinder, Type)
splitForAllTy_co_maybe :: Type -> Maybe (TyCoVar, Type)
splitForAllTy_ty_maybe :: Type -> Maybe (TyCoVar, Type)
splitForAllTy_maybe :: Type -> Maybe (TyCoVar, Type)
dropForAlls :: Type -> Type
splitForAllTy :: Type -> (TyCoVar, Type)
isFunTy :: Type -> Bool
isPiTy :: Type -> Bool
isForAllTy_co :: Type -> Bool
isForAllTy_ty :: Type -> Bool
isForAllTy :: Type -> Bool
splitForAllTysSameVis :: ArgFlag -> Type -> ([TyCoVar], Type)
splitForAllTys :: Type -> ([TyCoVar], Type)
mkTyConBindersPreferAnon :: [TyVar] -> TyCoVarSet -> [TyConBinder]
mkLamTypes :: [Var] -> Type -> Type
mkLamType :: Var -> Type -> Type
mkVisForAllTys :: [TyVar] -> Type -> Type
mkSpecForAllTys :: [TyVar] -> Type -> Type
mkSpecForAllTy :: TyVar -> Type -> Type
mkInvForAllTys :: [TyVar] -> Type -> Type
mkTyCoInvForAllTys :: [TyCoVar] -> Type -> Type
mkInvForAllTy :: TyVar -> Type -> Type
mkTyCoInvForAllTy :: TyCoVar -> Type -> Type
stripCoercionTy :: Type -> Coercion
isCoercionTy_maybe :: Type -> Maybe Coercion
mkCoercionTy :: Coercion -> Type
discardCast :: Type -> Type
tyConBindersTyCoBinders :: [TyConBinder] -> [TyCoBinder]
splitCastTy_maybe :: Type -> Maybe (Type, Coercion)
newTyConInstRhs :: TyCon -> [Type] -> Type
nextRole :: Type -> Role
splitListTyConApp_maybe :: Type -> Maybe Type
repSplitTyConApp_maybe :: HasDebugCallStack => Type -> Maybe (TyCon, [Type])
tcSplitTyConApp_maybe :: HasCallStack => Type -> Maybe (TyCon, [Type])
splitTyConApp :: Type -> (TyCon, [Type])
tyConAppArgN :: Int -> Type -> Type
tyConAppArgs :: Type -> [Type]
tyConAppArgs_maybe :: Type -> Maybe [Type]
tyConAppTyCon :: Type -> TyCon
tyConAppTyCon_maybe :: Type -> Maybe TyCon
tyConAppTyConPicky_maybe :: Type -> Maybe TyCon
mkTyConApp :: TyCon -> [Type] -> Type
applyTysX :: [TyVar] -> Type -> [Type] -> Type
piResultTys :: HasDebugCallStack => Type -> [Type] -> Type
funArgTy :: Type -> Type
funResultTy :: Type -> Type
splitFunTys :: Type -> ([Type], Type)
splitFunTy_maybe :: Type -> Maybe (Type, Type)
splitFunTy :: Type -> (Type, Type)
pprUserTypeErrorTy :: Type -> SDoc
userTypeError_maybe :: Type -> Maybe Type
isLitTy :: Type -> Maybe TyLit
isStrLitTy :: Type -> Maybe FastString
mkStrLitTy :: FastString -> Type
isNumLitTy :: Type -> Maybe Integer
mkNumLitTy :: Integer -> Type
repSplitAppTys :: HasDebugCallStack => Type -> (Type, [Type])
splitAppTys :: Type -> (Type, [Type])
splitAppTy :: Type -> (Type, Type)
tcRepSplitAppTy_maybe :: Type -> Maybe (Type, Type)
repSplitAppTy_maybe :: HasDebugCallStack => Type -> Maybe (Type, Type)
splitAppTy_maybe :: Type -> Maybe (Type, Type)
mkAppTys :: Type -> [Type] -> Type
repGetTyVar_maybe :: Type -> Maybe TyVar
getCastedTyVar_maybe :: Type -> Maybe (TyVar, CoercionN)
getTyVar_maybe :: Type -> Maybe TyVar
isTyVarTy :: Type -> Bool
getTyVar :: String -> Type -> TyVar
mapCoercion :: Monad m => TyCoMapper env m -> env -> Coercion -> m Coercion
mapType :: Monad m => TyCoMapper env m -> env -> Type -> m Type
isRuntimeRepVar :: TyVar -> Bool
isUnliftedRuntimeRep :: Type -> Bool
isUnliftedTypeKind :: Kind -> Bool
isLiftedRuntimeRep :: Type -> Bool
kindRep_maybe :: HasDebugCallStack => Kind -> Maybe Type
kindRep :: HasDebugCallStack => Kind -> Type
expandTypeSynonyms :: Type -> Type
data TyCoMapper env (m :: Type -> Type) = TyCoMapper {
- tcm_tyvar :: env -> TyVar -> m Type
- tcm_covar :: env -> CoVar -> m Coercion
- tcm_hole :: env -> CoercionHole -> m Coercion
- tcm_tycobinder :: env -> TyCoVar -> ArgFlag -> m (env, TyCoVar)
- tcm_tycon :: TyCon -> m TyCon
}
cloneTyVarBndrs :: TCvSubst -> [TyVar] -> UniqSupply -> (TCvSubst, [TyVar])
cloneTyVarBndr :: TCvSubst -> TyVar -> Unique -> (TCvSubst, TyVar)
substCoVarBndr :: HasCallStack => TCvSubst -> CoVar -> (TCvSubst, CoVar)
substVarBndrs :: HasCallStack => TCvSubst -> [TyCoVar] -> (TCvSubst, [TyCoVar])
substVarBndr :: HasCallStack => TCvSubst -> TyCoVar -> (TCvSubst, TyCoVar)
substTyVarBndrs :: HasCallStack => TCvSubst -> [TyVar] -> (TCvSubst, [TyVar])
substTyVarBndr :: HasCallStack => TCvSubst -> TyVar -> (TCvSubst, TyVar)
lookupCoVar :: TCvSubst -> Var -> Maybe Coercion
substCoVars :: TCvSubst -> [CoVar] -> [Coercion]
substCoVar :: TCvSubst -> CoVar -> Coercion
substCos :: HasCallStack => TCvSubst -> [Coercion] -> [Coercion]
substCoUnchecked :: TCvSubst -> Coercion -> Coercion
lookupTyVar :: TCvSubst -> TyVar -> Maybe Type
substTyVars :: TCvSubst -> [TyVar] -> [Type]
substTyVar :: TCvSubst -> TyVar -> Type
substThetaUnchecked :: TCvSubst -> ThetaType -> ThetaType
substTheta :: HasCallStack => TCvSubst -> ThetaType -> ThetaType
substTysUnchecked :: TCvSubst -> [Type] -> [Type]
substTys :: HasCallStack => TCvSubst -> [Type] -> [Type]
substTyUnchecked :: TCvSubst -> Type -> Type
substTyAddInScope :: TCvSubst -> Type -> Type
substTysWith :: [TyVar] -> [Type] -> [Type] -> [Type]
substCoWithUnchecked :: [TyVar] -> [Type] -> Coercion -> Coercion
substCoWith :: HasCallStack => [TyVar] -> [Type] -> Coercion -> Coercion
substTyWithUnchecked :: [TyVar] -> [Type] -> Type -> Type
substTyWith :: HasCallStack => [TyVar] -> [Type] -> Type -> Type
zipCoEnv :: HasDebugCallStack => [CoVar] -> [Coercion] -> CvSubstEnv
zipTyEnv :: HasDebugCallStack => [TyVar] -> [Type] -> TvSubstEnv
mkTvSubstPrs :: [(TyVar, Type)] -> TCvSubst
zipTCvSubst :: HasDebugCallStack => [TyCoVar] -> [Type] -> TCvSubst
zipTvSubst :: HasDebugCallStack => [TyVar] -> [Type] -> TCvSubst
unionTCvSubst :: TCvSubst -> TCvSubst -> TCvSubst
extendTCvSubstList :: TCvSubst -> [Var] -> [Type] -> TCvSubst
extendTvSubstAndInScope :: TCvSubst -> TyVar -> Type -> TCvSubst
extendCvSubst :: TCvSubst -> CoVar -> Coercion -> TCvSubst
extendTvSubstWithClone :: TCvSubst -> TyVar -> TyVar -> TCvSubst
extendTvSubstBinderAndInScope :: TCvSubst -> TyCoBinder -> Type -> TCvSubst
extendTCvSubstWithClone :: TCvSubst -> TyCoVar -> TyCoVar -> TCvSubst
extendTCvSubst :: TCvSubst -> TyCoVar -> Type -> TCvSubst
extendTCvInScopeSet :: TCvSubst -> VarSet -> TCvSubst
extendTCvInScopeList :: TCvSubst -> [Var] -> TCvSubst
extendTCvInScope :: TCvSubst -> Var -> TCvSubst
zapTCvSubst :: TCvSubst -> TCvSubst
setTvSubstEnv :: TCvSubst -> TvSubstEnv -> TCvSubst
notElemTCvSubst :: Var -> TCvSubst -> Bool
getTCvSubstRangeFVs :: TCvSubst -> VarSet
getTCvInScope :: TCvSubst -> InScopeSet
getCvSubstEnv :: TCvSubst -> CvSubstEnv
getTvSubstEnv :: TCvSubst -> TvSubstEnv
mkTCvSubst :: InScopeSet -> (TvSubstEnv, CvSubstEnv) -> TCvSubst
isEmptyTCvSubst :: TCvSubst -> Bool
mkEmptyTCvSubst :: InScopeSet -> TCvSubst
emptyTCvSubst :: TCvSubst
composeTCvSubst :: TCvSubst -> TCvSubst -> TCvSubst
composeTCvSubstEnv :: InScopeSet -> (TvSubstEnv, CvSubstEnv) -> (TvSubstEnv, CvSubstEnv) -> (TvSubstEnv, CvSubstEnv)
emptyCvSubstEnv :: CvSubstEnv
emptyTvSubstEnv :: TvSubstEnv
data TCvSubst = TCvSubst InScopeSet TvSubstEnv CvSubstEnv
type TvSubstEnv = TyVarEnv Type
type CvSubstEnv = CoVarEnv Coercion
pprParendCo :: Coercion -> SDoc
tidyCos :: TidyEnv -> [Coercion] -> [Coercion]
tidyCo :: TidyEnv -> Coercion -> Coercion
tidyKind :: TidyEnv -> Kind -> Kind
tidyOpenKind :: TidyEnv -> Kind -> (TidyEnv, Kind)
tidyTopType :: Type -> Type
tidyOpenType :: TidyEnv -> Type -> (TidyEnv, Type)
tidyOpenTypes :: TidyEnv -> [Type] -> (TidyEnv, [Type])
tidyType :: TidyEnv -> Type -> Type
tidyTypes :: TidyEnv -> [Type] -> [Type]
tidyTyCoVarOcc :: TidyEnv -> TyCoVar -> TyCoVar
tidyOpenTyCoVar :: TidyEnv -> TyCoVar -> (TidyEnv, TyCoVar)
tidyOpenTyCoVars :: TidyEnv -> [TyCoVar] -> (TidyEnv, [TyCoVar])
tidyFreeTyCoVars :: TidyEnv -> [TyCoVar] -> TidyEnv
tidyTyCoVarBinders :: TidyEnv -> [VarBndr TyCoVar vis] -> (TidyEnv, [VarBndr TyCoVar vis])
tidyTyCoVarBinder :: TidyEnv -> VarBndr TyCoVar vis -> (TidyEnv, VarBndr TyCoVar vis)
tidyVarBndr :: TidyEnv -> TyCoVar -> (TidyEnv, TyCoVar)
tidyVarBndrs :: TidyEnv -> [TyCoVar] -> (TidyEnv, [TyCoVar])
tyCoVarsOfTypesWellScoped :: [Type] -> [TyVar]
tyCoVarsOfTypeWellScoped :: Type -> [TyVar]
scopedSort :: [TyCoVar] -> [TyCoVar]
noFreeVarsOfType :: Type -> Bool
coVarsOfCo :: Coercion -> CoVarSet
coVarsOfTypes :: [Type] -> TyCoVarSet
coVarsOfType :: Type -> CoVarSet
tyCoFVsOfCos :: [Coercion] -> FV
tyCoFVsOfCo :: Coercion -> FV
tyCoVarsOfCoDSet :: Coercion -> DTyCoVarSet
tyCoFVsVarBndr :: Var -> FV -> FV
tyCoFVsVarBndrs :: [Var] -> FV -> FV
tyCoFVsBndr :: TyCoVarBinder -> FV -> FV
tyCoFVsOfType :: Type -> FV
tyCoVarsOfTypeDSet :: Type -> DTyCoVarSet
tyCoVarsOfCos :: [Coercion] -> TyCoVarSet
tyCoVarsOfCo :: Coercion -> TyCoVarSet
tyCoVarsOfTypes :: [Type] -> TyCoVarSet
tyCoVarsOfType :: Type -> TyCoVarSet
type InterestingVarFun = Var -> Bool
funTyCon :: TyCon
coercionSize :: Coercion -> Int
typeSize :: Type -> Int
setCoHoleCoVar :: CoercionHole -> CoVar -> CoercionHole
coHoleCoVar :: CoercionHole -> CoVar
mkTyConTy :: TyCon -> Type
mkPiTys :: [TyCoBinder] -> Type -> Type
mkPiTy :: TyCoBinder -> Type -> Type
mkForAllTys :: [TyCoVarBinder] -> Type -> Type
mkInvisFunTys :: [Type] -> Type -> Type
mkVisFunTys :: [Type] -> Type -> Type
mkInvisFunTy :: Type -> Type -> Type
mkVisFunTy :: Type -> Type -> Type
mkTyVarTys :: [TyVar] -> [Type]
mkTyVarTy :: TyVar -> Type
isNamedBinder :: TyCoBinder -> Bool
isVisibleBinder :: TyCoBinder -> Bool
isInvisibleBinder :: TyCoBinder -> Bool
type KindOrType = Type
type KnotTied ty = ty
type CoercionR = Coercion
type CoercionP = Coercion
type MCoercionR = MCoercion
data CoercionHole = CoercionHole {
- ch_co_var :: CoVar
- ch_ref :: IORef (Maybe Coercion)
}
isPredTy :: HasDebugCallStack => Type -> Bool
isCoercionTy :: Type -> Bool
mkAppTy :: Type -> Type -> Type
mkCastTy :: Type -> Coercion -> Type
piResultTy :: HasDebugCallStack => Type -> Type -> Type
eqType :: Type -> Type -> Bool
coreView :: Type -> Maybe Type
tcView :: Type -> Maybe Type
isRuntimeRepTy :: Type -> Bool
isLiftedTypeKind :: Kind -> Bool
splitTyConApp_maybe :: HasDebugCallStack => Type -> Maybe (TyCon, [Type])
partitionInvisibleTypes :: TyCon -> [Type] -> ([Type], [Type])
tyConSkolem :: TyCon -> Bool
checkRecTc :: RecTcChecker -> TyCon -> Maybe RecTcChecker
setRecTcMaxBound :: Int -> RecTcChecker -> RecTcChecker
defaultRecTcMaxBound :: Int
initRecTc :: RecTcChecker
pprPromotionQuote :: TyCon -> SDoc
tcFlavourIsOpen :: TyConFlavour -> Bool
tyConFlavour :: TyCon -> TyConFlavour
mkTyConTagMap :: TyCon -> NameEnv ConTag
tyConRuntimeRepInfo :: TyCon -> RuntimeRepInfo
tyConFamilyCoercion_maybe :: TyCon -> Maybe (CoAxiom Unbranched)
tyConFamInst_maybe :: TyCon -> Maybe (TyCon, [Type])
tyConFamInstSig_maybe :: TyCon -> Maybe (TyCon, [Type], CoAxiom Unbranched)
isFamInstTyCon :: TyCon -> Bool
tyConATs :: TyCon -> [TyCon]
tyConClass_maybe :: TyCon -> Maybe Class
isClassTyCon :: TyCon -> Bool
famTyConFlav_maybe :: TyCon -> Maybe FamTyConFlav
synTyConRhs_maybe :: TyCon -> Maybe Type
synTyConDefn_maybe :: TyCon -> Maybe ([TyVar], Type)
tyConStupidTheta :: TyCon -> [PredType]
newTyConDataCon_maybe :: TyCon -> Maybe DataCon
newTyConCo :: TyCon -> CoAxiom Unbranched
newTyConCo_maybe :: TyCon -> Maybe (CoAxiom Unbranched)
newTyConEtadRhs :: TyCon -> ([TyVar], Type)
newTyConEtadArity :: TyCon -> Int
newTyConRhs :: TyCon -> ([TyVar], Type)
tyConRoles :: TyCon -> [Role]
tyConFamilyResVar_maybe :: TyCon -> Maybe Name
algTyConRhs :: TyCon -> AlgTyConRhs
tyConFamilySize :: TyCon -> Int
tyConSingleAlgDataCon_maybe :: TyCon -> Maybe DataCon
tyConSingleDataCon :: TyCon -> DataCon
tyConSingleDataCon_maybe :: TyCon -> Maybe DataCon
tyConDataCons_maybe :: TyCon -> Maybe [DataCon]
tyConDataCons :: TyCon -> [DataCon]
isTyConWithSrcDataCons :: TyCon -> Bool
expandSynTyCon_maybe :: TyCon -> [tyco] -> Maybe ([(TyVar, tyco)], Type, [tyco])
isTcLevPoly :: TyCon -> Bool
setTcTyConKind :: TyCon -> Kind -> TyCon
isTcTyCon :: TyCon -> Bool
tyConCType_maybe :: TyCon -> Maybe CType
isImplicitTyCon :: TyCon -> Bool
isLiftedTypeKindTyConName :: Name -> Bool
isKindTyCon :: TyCon -> Bool
isPromotedDataCon_maybe :: TyCon -> Maybe DataCon
isPromotedDataCon :: TyCon -> Bool
isPromotedTupleTyCon :: TyCon -> Bool
isUnboxedSumTyCon :: TyCon -> Bool
isBoxedTupleTyCon :: TyCon -> Bool
tyConTuple_maybe :: TyCon -> Maybe TupleSort
tyConFlavourAssoc_maybe :: TyConFlavour -> Maybe TyCon
tyConAssoc_maybe :: TyCon -> Maybe TyCon
isTyConAssoc :: TyCon -> Bool
isBuiltInSynFamTyCon_maybe :: TyCon -> Maybe BuiltInSynFamily
tyConInjectivityInfo :: TyCon -> Injectivity
isClosedSynFamilyTyConWithAxiom_maybe :: TyCon -> Maybe (CoAxiom Branched)
isOpenTypeFamilyTyCon :: TyCon -> Bool
isDataFamilyTyCon :: TyCon -> Bool
isTypeFamilyTyCon :: TyCon -> Bool
isOpenFamilyTyCon :: TyCon -> Bool
isFamilyTyCon :: TyCon -> Bool
isEnumerationTyCon :: TyCon -> Bool
isGadtSyntaxTyCon :: TyCon -> Bool
mustBeSaturated :: TyCon -> Bool
isFamFreeTyCon :: TyCon -> Bool
isTauTyCon :: TyCon -> Bool
isTypeSynonymTyCon :: TyCon -> Bool
isDataSumTyCon_maybe :: TyCon -> Maybe [DataCon]
isDataProductTyCon_maybe :: TyCon -> Maybe DataCon
isProductTyCon :: TyCon -> Bool
unwrapNewTyConEtad_maybe :: TyCon -> Maybe ([TyVar], Type, CoAxiom Unbranched)
unwrapNewTyCon_maybe :: TyCon -> Maybe ([TyVar], Type, CoAxiom Unbranched)
isNewTyCon :: TyCon -> Bool
isGenInjAlgRhs :: AlgTyConRhs -> Bool
isGenerativeTyCon :: TyCon -> Role -> Bool
isInjectiveTyCon :: TyCon -> Role -> Bool
isDataTyCon :: TyCon -> Bool
isVanillaAlgTyCon :: TyCon -> Bool
isAlgTyCon :: TyCon -> Bool
isUnliftedTyCon :: TyCon -> Bool
isPrimTyCon :: TyCon -> Bool
isAbstractTyCon :: TyCon -> Bool
mkPromotedDataCon :: DataCon -> Name -> TyConRepName -> [TyConTyCoBinder] -> Kind -> [Role] -> RuntimeRepInfo -> TyCon
mkFamilyTyCon :: Name -> [TyConBinder] -> Kind -> Maybe Name -> FamTyConFlav -> Maybe Class -> Injectivity -> TyCon
mkSynonymTyCon :: Name -> [TyConBinder] -> Kind -> [Role] -> Type -> Bool -> Bool -> TyCon
mkLiftedPrimTyCon :: Name -> [TyConBinder] -> Kind -> [Role] -> TyCon
mkKindTyCon :: Name -> [TyConBinder] -> Kind -> [Role] -> Name -> TyCon
mkPrimTyCon :: Name -> [TyConBinder] -> Kind -> [Role] -> TyCon
noTcTyConScopedTyVars :: [(Name, TcTyVar)]
mkTcTyCon :: Name -> [TyConBinder] -> Kind -> [(Name, TcTyVar)] -> Bool -> TyConFlavour -> TyCon
mkSumTyCon :: Name -> [TyConBinder] -> Kind -> Arity -> [TyVar] -> [DataCon] -> AlgTyConFlav -> TyCon
mkTupleTyCon :: Name -> [TyConBinder] -> Kind -> Arity -> DataCon -> TupleSort -> AlgTyConFlav -> TyCon
mkClassTyCon :: Name -> [TyConBinder] -> [Role] -> AlgTyConRhs -> Class -> Name -> TyCon
mkAlgTyCon :: Name -> [TyConBinder] -> Kind -> [Role] -> Maybe CType -> [PredType] -> AlgTyConRhs -> AlgTyConFlav -> Bool -> TyCon
mkFunTyCon :: Name -> [TyConBinder] -> Name -> TyCon
lookupTyConFieldLabel :: FieldLabelString -> TyCon -> Maybe FieldLabel
tyConFieldLabels :: TyCon -> [FieldLabel]
primRepIsFloat :: PrimRep -> Maybe Bool
primElemRepSizeB :: PrimElemRep -> Int
primRepSizeB :: DynFlags -> PrimRep -> Int
primRepsCompatible :: DynFlags -> [PrimRep] -> [PrimRep] -> Bool
primRepCompatible :: DynFlags -> PrimRep -> PrimRep -> Bool
isGcPtrRep :: PrimRep -> Bool
isVoidRep :: PrimRep -> Bool
tyConRepModOcc :: Module -> OccName -> (Module, OccName)
mkPrelTyConRepName :: Name -> TyConRepName
tyConRepName_maybe :: TyCon -> Maybe TyConRepName
isNoParent :: AlgTyConFlav -> Bool
visibleDataCons :: AlgTyConRhs -> [DataCon]
mkDataTyConRhs :: [DataCon] -> AlgTyConRhs
tyConVisibleTyVars :: TyCon -> [TyVar]
tyConTyVarBinders :: [TyConBinder] -> [TyVarBinder]
mkTyConKind :: [TyConBinder] -> Kind -> Kind
isInvisibleTyConBinder :: VarBndr tv TyConBndrVis -> Bool
isVisibleTyConBinder :: VarBndr tv TyConBndrVis -> Bool
isNamedTyConBinder :: TyConBinder -> Bool
tyConBndrVisArgFlag :: TyConBndrVis -> ArgFlag
tyConBinderArgFlag :: TyConBinder -> ArgFlag
mkRequiredTyConBinder :: TyCoVarSet -> TyVar -> TyConBinder
mkNamedTyConBinders :: ArgFlag -> [TyVar] -> [TyConBinder]
mkNamedTyConBinder :: ArgFlag -> TyVar -> TyConBinder
mkAnonTyConBinders :: AnonArgFlag -> [TyVar] -> [TyConBinder]
mkAnonTyConBinder :: AnonArgFlag -> TyVar -> TyConBinder
type TyConBinder = VarBndr TyVar TyConBndrVis
type TyConTyCoBinder = VarBndr TyCoVar TyConBndrVis
data TyConBndrVis
- = NamedTCB ArgFlag
- | AnonTCB AnonArgFlag
data AlgTyConRhs
- = AbstractTyCon
- | DataTyCon {
  - data_cons :: [DataCon]
  - data_cons_size :: Int
  - is_enum :: Bool
  }
- | TupleTyCon {
  - data_con :: DataCon
  - tup_sort :: TupleSort
  }
- | SumTyCon {
  - data_cons :: [DataCon]
  - data_cons_size :: Int
  }
- | NewTyCon {
  - data_con :: DataCon
  - nt_rhs :: Type
  - nt_etad_rhs :: ([TyVar], Type)
  - nt_co :: CoAxiom Unbranched
  - nt_lev_poly :: Bool
  }
data RuntimeRepInfo
- = NoRRI
- | RuntimeRep ([Type] -> [PrimRep])
- | VecCount Int
- | VecElem PrimElemRep
data AlgTyConFlav
- = VanillaAlgTyCon TyConRepName
- | UnboxedAlgTyCon (Maybe TyConRepName)
- | ClassTyCon Class TyConRepName
- | DataFamInstTyCon (CoAxiom Unbranched) TyCon [Type]
data Injectivity
- = NotInjective
- | Injective [Bool]
data FamTyConFlav
- = DataFamilyTyCon TyConRepName
- | OpenSynFamilyTyCon
- | ClosedSynFamilyTyCon (Maybe (CoAxiom Branched))
- | AbstractClosedSynFamilyTyCon
- | BuiltInSynFamTyCon BuiltInSynFamily
type TyConRepName = Name
data PrimRep
- = VoidRep
- | LiftedRep
- | UnliftedRep
- | Int8Rep
- | Int16Rep
- | Int32Rep
- | Int64Rep
- | IntRep
- | Word8Rep
- | Word16Rep
- | Word32Rep
- | Word64Rep
- | WordRep
- | AddrRep
- | FloatRep
- | DoubleRep
- | VecRep Int PrimElemRep
data PrimElemRep
- = Int8ElemRep
- | Int16ElemRep
- | Int32ElemRep
- | Int64ElemRep
- | Word8ElemRep
- | Word16ElemRep
- | Word32ElemRep
- | Word64ElemRep
- | FloatElemRep
- | DoubleElemRep
data TyConFlavour
- = ClassFlavour
- | TupleFlavour Boxity
- | SumFlavour
- | DataTypeFlavour
- | NewtypeFlavour
- | AbstractTypeFlavour
- | DataFamilyFlavour (Maybe TyCon)
- | OpenTypeFamilyFlavour (Maybe TyCon)
- | ClosedTypeFamilyFlavour
- | TypeSynonymFlavour
- | BuiltInTypeFlavour
- | PromotedDataConFlavour
data RecTcChecker
anyDVarEnv :: (a -> Bool) -> DVarEnv a -> Bool
extendDVarEnvList :: DVarEnv a -> [(Var, a)] -> DVarEnv a
partitionDVarEnv :: (a -> Bool) -> DVarEnv a -> (DVarEnv a, DVarEnv a)
modifyDVarEnv :: (a -> a) -> DVarEnv a -> Var -> DVarEnv a
extendDVarEnv_C :: (a -> a -> a) -> DVarEnv a -> Var -> a -> DVarEnv a
elemDVarEnv :: Var -> DVarEnv a -> Bool
isEmptyDVarEnv :: DVarEnv a -> Bool
delDVarEnvList :: DVarEnv a -> [Var] -> DVarEnv a
delDVarEnv :: DVarEnv a -> Var -> DVarEnv a
unitDVarEnv :: Var -> a -> DVarEnv a
plusDVarEnv_C :: (a -> a -> a) -> DVarEnv a -> DVarEnv a -> DVarEnv a
plusDVarEnv :: DVarEnv a -> DVarEnv a -> DVarEnv a
alterDVarEnv :: (Maybe a -> Maybe a) -> DVarEnv a -> Var -> DVarEnv a
filterDVarEnv :: (a -> Bool) -> DVarEnv a -> DVarEnv a
mapDVarEnv :: (a -> b) -> DVarEnv a -> DVarEnv b
foldDVarEnv :: (a -> b -> b) -> b -> DVarEnv a -> b
lookupDVarEnv :: DVarEnv a -> Var -> Maybe a
minusDVarEnv :: DVarEnv a -> DVarEnv a' -> DVarEnv a
extendDVarEnv :: DVarEnv a -> Var -> a -> DVarEnv a
mkDVarEnv :: [(Var, a)] -> DVarEnv a
dVarEnvElts :: DVarEnv a -> [a]
emptyDVarEnv :: DVarEnv a
modifyVarEnv_Directly :: (a -> a) -> UniqFM a -> Unique -> UniqFM a
modifyVarEnv :: (a -> a) -> VarEnv a -> Var -> VarEnv a
lookupVarEnv_NF :: VarEnv a -> Var -> a
zipVarEnv :: [Var] -> [a] -> VarEnv a
restrictVarEnv :: VarEnv a -> VarSet -> VarEnv a
partitionVarEnv :: (a -> Bool) -> VarEnv a -> (VarEnv a, VarEnv a)
delVarEnv_Directly :: VarEnv a -> Unique -> VarEnv a
filterVarEnv_Directly :: (Unique -> a -> Bool) -> VarEnv a -> VarEnv a
lookupVarEnv_Directly :: VarEnv a -> Unique -> Maybe a
isEmptyVarEnv :: VarEnv a -> Bool
unitVarEnv :: Var -> a -> VarEnv a
emptyVarEnv :: VarEnv a
mkVarEnv_Directly :: [(Unique, a)] -> VarEnv a
mkVarEnv :: [(Var, a)] -> VarEnv a
mapVarEnv :: (a -> b) -> VarEnv a -> VarEnv b
lookupWithDefaultVarEnv :: VarEnv a -> a -> Var -> a
filterVarEnv :: (a -> Bool) -> VarEnv a -> VarEnv a
lookupVarEnv :: VarEnv a -> Var -> Maybe a
plusVarEnvList :: [VarEnv a] -> VarEnv a
plusVarEnv :: VarEnv a -> VarEnv a -> VarEnv a
intersectsVarEnv :: VarEnv a -> VarEnv a -> Bool
minusVarEnv :: VarEnv a -> VarEnv b -> VarEnv a
delVarEnv :: VarEnv a -> Var -> VarEnv a
delVarEnvList :: VarEnv a -> [Var] -> VarEnv a
plusMaybeVarEnv_C :: (a -> a -> Maybe a) -> VarEnv a -> VarEnv a -> VarEnv a
plusVarEnv_CD :: (a -> a -> a) -> VarEnv a -> a -> VarEnv a -> a -> VarEnv a
plusVarEnv_C :: (a -> a -> a) -> VarEnv a -> VarEnv a -> VarEnv a
extendVarEnvList :: VarEnv a -> [(Var, a)] -> VarEnv a
extendVarEnv_Directly :: VarEnv a -> Unique -> a -> VarEnv a
extendVarEnv_Acc :: (a -> b -> b) -> (a -> b) -> VarEnv b -> Var -> a -> VarEnv b
extendVarEnv_C :: (a -> a -> a) -> VarEnv a -> Var -> a -> VarEnv a
extendVarEnv :: VarEnv a -> Var -> a -> VarEnv a
alterVarEnv :: (Maybe a -> Maybe a) -> VarEnv a -> Var -> VarEnv a
disjointVarEnv :: VarEnv a -> VarEnv a -> Bool
elemVarEnvByKey :: Unique -> VarEnv a -> Bool
elemVarEnv :: Var -> VarEnv a -> Bool
mkEmptyTidyEnv :: TidyOccEnv -> TidyEnv
emptyTidyEnv :: TidyEnv
rnSwap :: RnEnv2 -> RnEnv2
nukeRnEnvR :: RnEnv2 -> RnEnv2
nukeRnEnvL :: RnEnv2 -> RnEnv2
lookupRnInScope :: RnEnv2 -> Var -> Var
inRnEnvR :: RnEnv2 -> Var -> Bool
inRnEnvL :: RnEnv2 -> Var -> Bool
rnOccR_maybe :: RnEnv2 -> Var -> Maybe Var
rnOccL_maybe :: RnEnv2 -> Var -> Maybe Var
rnOccR :: RnEnv2 -> Var -> Var
rnOccL :: RnEnv2 -> Var -> Var
delBndrsR :: RnEnv2 -> [Var] -> RnEnv2
delBndrsL :: RnEnv2 -> [Var] -> RnEnv2
delBndrR :: RnEnv2 -> Var -> RnEnv2
delBndrL :: RnEnv2 -> Var -> RnEnv2
rnEtaR :: RnEnv2 -> Var -> (RnEnv2, Var)
rnEtaL :: RnEnv2 -> Var -> (RnEnv2, Var)
rnBndrR :: RnEnv2 -> Var -> (RnEnv2, Var)
rnBndrL :: RnEnv2 -> Var -> (RnEnv2, Var)
rnBndr2_var :: RnEnv2 -> Var -> Var -> (RnEnv2, Var)
rnBndr2 :: RnEnv2 -> Var -> Var -> RnEnv2
rnBndrs2 :: RnEnv2 -> [Var] -> [Var] -> RnEnv2
rnEnvR :: RnEnv2 -> VarEnv Var
rnEnvL :: RnEnv2 -> VarEnv Var
rnInScopeSet :: RnEnv2 -> InScopeSet
rnInScope :: Var -> RnEnv2 -> Bool
addRnInScopeSet :: RnEnv2 -> VarSet -> RnEnv2
mkRnEnv2 :: InScopeSet -> RnEnv2
uniqAway :: InScopeSet -> Var -> Var
varSetInScope :: VarSet -> InScopeSet -> Bool
unionInScope :: InScopeSet -> InScopeSet -> InScopeSet
lookupInScope_Directly :: InScopeSet -> Unique -> Maybe Var
lookupInScope :: InScopeSet -> Var -> Maybe Var
elemInScopeSet :: Var -> InScopeSet -> Bool
delInScopeSet :: InScopeSet -> Var -> InScopeSet
extendInScopeSetSet :: InScopeSet -> VarSet -> InScopeSet
extendInScopeSetList :: InScopeSet -> [Var] -> InScopeSet
extendInScopeSet :: InScopeSet -> Var -> InScopeSet
mkInScopeSet :: VarSet -> InScopeSet
getInScopeVars :: InScopeSet -> VarSet
emptyInScopeSet :: InScopeSet
data InScopeSet
data RnEnv2
type TidyEnv = (TidyOccEnv, VarEnv Var)
type VarEnv elt = UniqFM elt
type IdEnv elt = VarEnv elt
type TyVarEnv elt = VarEnv elt
type TyCoVarEnv elt = VarEnv elt
type CoVarEnv elt = VarEnv elt
type DVarEnv elt = UniqDFM elt
type DIdEnv elt = DVarEnv elt
type DTyVarEnv elt = DVarEnv elt
transCloDVarSet :: (DVarSet -> DVarSet) -> DVarSet -> DVarSet
dVarSetToVarSet :: DVarSet -> VarSet
extendDVarSetList :: DVarSet -> [Var] -> DVarSet
seqDVarSet :: DVarSet -> ()
delDVarSetList :: DVarSet -> [Var] -> DVarSet
partitionDVarSet :: (Var -> Bool) -> DVarSet -> (DVarSet, DVarSet)
sizeDVarSet :: DVarSet -> Int
filterDVarSet :: (Var -> Bool) -> DVarSet -> DVarSet
mapDVarSet :: Uniquable b => (a -> b) -> UniqDSet a -> UniqDSet b
allDVarSet :: (Var -> Bool) -> DVarSet -> Bool
anyDVarSet :: (Var -> Bool) -> DVarSet -> Bool
foldDVarSet :: (Var -> a -> a) -> a -> DVarSet -> a
dVarSetMinusVarSet :: DVarSet -> VarSet -> DVarSet
minusDVarSet :: DVarSet -> DVarSet -> DVarSet
delDVarSet :: DVarSet -> Var -> DVarSet
isEmptyDVarSet :: DVarSet -> Bool
intersectsDVarSet :: DVarSet -> DVarSet -> Bool
disjointDVarSet :: DVarSet -> DVarSet -> Bool
dVarSetIntersectVarSet :: DVarSet -> VarSet -> DVarSet
intersectDVarSet :: DVarSet -> DVarSet -> DVarSet
mapUnionDVarSet :: (a -> DVarSet) -> [a] -> DVarSet
unionDVarSets :: [DVarSet] -> DVarSet
unionDVarSet :: DVarSet -> DVarSet -> DVarSet
subDVarSet :: DVarSet -> DVarSet -> Bool
dVarSetElems :: DVarSet -> [Var]
elemDVarSet :: Var -> DVarSet -> Bool
extendDVarSet :: DVarSet -> Var -> DVarSet
mkDVarSet :: [Var] -> DVarSet
unitDVarSet :: Var -> DVarSet
emptyDVarSet :: DVarSet
pprVarSet :: VarSet -> ([Var] -> SDoc) -> SDoc
pluralVarSet :: VarSet -> SDoc
seqVarSet :: VarSet -> ()
transCloVarSet :: (VarSet -> VarSet) -> VarSet -> VarSet
fixVarSet :: (VarSet -> VarSet) -> VarSet -> VarSet
mapVarSet :: Uniquable b => (a -> b) -> UniqSet a -> UniqSet b
allVarSet :: (Var -> Bool) -> VarSet -> Bool
anyVarSet :: (Var -> Bool) -> VarSet -> Bool
subVarSet :: VarSet -> VarSet -> Bool
disjointVarSet :: VarSet -> VarSet -> Bool
intersectsVarSet :: VarSet -> VarSet -> Bool
mapUnionVarSet :: (a -> VarSet) -> [a] -> VarSet
partitionVarSet :: (Var -> Bool) -> VarSet -> (VarSet, VarSet)
elemVarSetByKey :: Unique -> VarSet -> Bool
delVarSetByKey :: VarSet -> Unique -> VarSet
filterVarSet :: (Var -> Bool) -> VarSet -> VarSet
sizeVarSet :: VarSet -> Int
lookupVarSetByName :: VarSet -> Name -> Maybe Var
lookupVarSet :: VarSet -> Var -> Maybe Var
lookupVarSet_Directly :: VarSet -> Unique -> Maybe Var
mkVarSet :: [Var] -> VarSet
isEmptyVarSet :: VarSet -> Bool
delVarSetList :: VarSet -> [Var] -> VarSet
delVarSet :: VarSet -> Var -> VarSet
minusVarSet :: VarSet -> VarSet -> VarSet
elemVarSet :: Var -> VarSet -> Bool
unionVarSets :: [VarSet] -> VarSet
unionVarSet :: VarSet -> VarSet -> VarSet
intersectVarSet :: VarSet -> VarSet -> VarSet
extendVarSetList :: VarSet -> [Var] -> VarSet
extendVarSet :: VarSet -> Var -> VarSet
unitVarSet :: Var -> VarSet
emptyVarSet :: VarSet
type VarSet = UniqSet Var
type IdSet = UniqSet Id
type TyVarSet = UniqSet TyVar
type CoVarSet = UniqSet CoVar
type TyCoVarSet = UniqSet TyCoVar
type DVarSet = UniqDSet Var
type DIdSet = UniqDSet Id
type DTyVarSet = UniqDSet TyVar
type DTyCoVarSet = UniqDSet TyCoVar
mkReflCo :: Role -> Type -> Coercion
mkTyConAppCo :: HasDebugCallStack => Role -> TyCon -> [Coercion] -> Coercion
mkAppCo :: Coercion -> Coercion -> Coercion
mkForAllCo :: TyCoVar -> CoercionN -> Coercion -> Coercion
mkFunCo :: Role -> Coercion -> Coercion -> Coercion
mkCoVarCo :: CoVar -> Coercion
mkAxiomInstCo :: CoAxiom Branched -> BranchIndex -> [Coercion] -> Coercion
mkPhantomCo :: Coercion -> Type -> Type -> Coercion
mkUnsafeCo :: Role -> Type -> Type -> Coercion
mkUnivCo :: UnivCoProvenance -> Role -> Type -> Type -> Coercion
mkSymCo :: Coercion -> Coercion
mkTransCo :: Coercion -> Coercion -> Coercion
mkNthCo :: HasDebugCallStack => Role -> Int -> Coercion -> Coercion
mkLRCo :: LeftOrRight -> Coercion -> Coercion
mkInstCo :: Coercion -> Coercion -> Coercion
mkGReflCo :: Role -> Type -> MCoercionN -> Coercion
mkNomReflCo :: Type -> Coercion
mkKindCo :: Coercion -> Coercion
mkSubCo :: Coercion -> Coercion
mkProofIrrelCo :: Role -> Coercion -> Coercion -> Coercion -> Coercion
mkAxiomRuleCo :: CoAxiomRule -> [Coercion] -> Coercion
isGReflCo :: Coercion -> Bool
isReflCo :: Coercion -> Bool
isReflexiveCo :: Coercion -> Bool
decomposePiCos :: HasDebugCallStack => CoercionN -> Pair Type -> [Type] -> ([CoercionN], CoercionN)
coVarKindsTypesRole :: HasDebugCallStack => CoVar -> (Kind, Kind, Type, Type, Role)
coVarRole :: CoVar -> Role
mkCoercionType :: Role -> Type -> Type -> Type
liftCoSubst :: HasDebugCallStack => Role -> LiftingContext -> Type -> Coercion
seqCo :: Coercion -> ()
coercionKind :: Coercion -> Pair Type
coercionType :: Coercion -> Type
data LiftingContext = LC TCvSubst LiftCoEnv
data Role
- = Nominal
- | Representational
- | Phantom
dataConName :: DataCon -> Name
dataConTyCon :: DataCon -> TyCon
dataConExTyCoVars :: DataCon -> [TyCoVar]
dataConUserTyVars :: DataCon -> [TyVar]
dataConUserTyVarBinders :: DataCon -> [TyVarBinder]
dataConSourceArity :: DataCon -> Arity
dataConFieldLabels :: DataCon -> [FieldLabel]
dataConInstOrigArgTys :: DataCon -> [Type] -> [Type]
dataConStupidTheta :: DataCon -> ThetaType
dataConFullSig :: DataCon -> ([TyVar], [TyCoVar], [EqSpec], ThetaType, [Type], Type)
isUnboxedSumCon :: DataCon -> Bool
data DataCon
data DataConRep
- = NoDataConRep
- | DCR {
  - dcr_wrap_id :: Id
  - dcr_boxer :: DataConBoxer
  - dcr_arg_tys :: [Type]
  - dcr_stricts :: [StrictnessMark]
  - dcr_bangs :: [HsImplBang]
  }
data EqSpec
isExportedId :: Var -> Bool
mustHaveLocalBinding :: Var -> Bool
isGlobalId :: Var -> Bool
isLocalVar :: Var -> Bool
isLocalId :: Var -> Bool
isNonCoVarId :: Var -> Bool
isCoVar :: Var -> Bool
isId :: Var -> Bool
isTyCoVar :: Var -> Bool
isTcTyVar :: Var -> Bool
isTyVar :: Var -> Bool
setIdNotExported :: Id -> Id
setIdExported :: Id -> Id
globaliseId :: Id -> Id
setIdDetails :: Id -> IdDetails -> Id
lazySetIdInfo :: Id -> IdInfo -> Var
mkExportedLocalVar :: IdDetails -> Name -> Type -> IdInfo -> Id
mkCoVar :: Name -> Type -> CoVar
mkLocalVar :: IdDetails -> Name -> Type -> IdInfo -> Id
mkGlobalVar :: IdDetails -> Name -> Type -> IdInfo -> Id
idDetails :: Id -> IdDetails
idInfo :: HasDebugCallStack => Id -> IdInfo
setTcTyVarDetails :: TyVar -> TcTyVarDetails -> TyVar
tcTyVarDetails :: TyVar -> TcTyVarDetails
mkTcTyVar :: Name -> Kind -> TcTyVarDetails -> TyVar
mkTyVar :: Name -> Kind -> TyVar
updateTyVarKindM :: Monad m => (Kind -> m Kind) -> TyVar -> m TyVar
updateTyVarKind :: (Kind -> Kind) -> TyVar -> TyVar
setTyVarKind :: TyVar -> Kind -> TyVar
setTyVarName :: TyVar -> Name -> TyVar
setTyVarUnique :: TyVar -> Unique -> TyVar
tyVarKind :: TyVar -> Kind
tyVarName :: TyVar -> Name
isTyVarBinder :: TyCoVarBinder -> Bool
mkTyVarBinders :: ArgFlag -> [TyVar] -> [TyVarBinder]
mkTyCoVarBinders :: ArgFlag -> [TyCoVar] -> [TyCoVarBinder]
mkTyVarBinder :: ArgFlag -> TyVar -> TyVarBinder
mkTyCoVarBinder :: ArgFlag -> TyCoVar -> TyCoVarBinder
binderType :: VarBndr TyCoVar argf -> Type
binderArgFlag :: VarBndr tv argf -> argf
binderVars :: [VarBndr tv argf] -> [tv]
binderVar :: VarBndr tv argf -> tv
argToForallVisFlag :: ArgFlag -> ForallVisFlag
sameVis :: ArgFlag -> ArgFlag -> Bool
isInvisibleArgFlag :: ArgFlag -> Bool
isVisibleArgFlag :: ArgFlag -> Bool
updateVarTypeM :: Monad m => (Type -> m Type) -> Id -> m Id
updateVarType :: (Type -> Type) -> Id -> Id
setVarType :: Id -> Type -> Id
setVarName :: Var -> Name -> Var
setVarUnique :: Var -> Unique -> Var
varUnique :: Var -> Unique
nonDetCmpVar :: Var -> Var -> Ordering
type Id = Var
type CoVar = Id
type NcId = Id
type TyVar = Var
type TKVar = Var
type TcTyVar = Var
type TypeVar = Var
type KindVar = Var
type EvId = Id
type EvVar = EvId
type DFunId = Id
type DictId = EvId
type IpId = EvId
type EqVar = EvId
type JoinId = Id
type TyCoVar = Id
type InVar = Var
type InTyVar = TyVar
type InCoVar = CoVar
type InId = Id
type OutVar = Var
type OutTyVar = TyVar
type OutCoVar = CoVar
type OutId = Id
data ForallVisFlag
- = ForallVis
- | ForallInvis
data VarBndr var argf = Bndr var argf
type TyCoVarBinder = VarBndr TyCoVar ArgFlag
type TyVarBinder = VarBndr TyVar ArgFlag
deserializeAnns :: Typeable a => ([Word8] -> a) -> AnnEnv -> UniqFM [a]
findAnnsByTypeRep :: AnnEnv -> CoreAnnTarget -> TypeRep -> [[Word8]]
findAnns :: Typeable a => ([Word8] -> a) -> AnnEnv -> CoreAnnTarget -> [a]
plusAnnEnv :: AnnEnv -> AnnEnv -> AnnEnv
extendAnnEnvList :: AnnEnv -> [Annotation] -> AnnEnv
mkAnnEnv :: [Annotation] -> AnnEnv
emptyAnnEnv :: AnnEnv
getAnnTargetName_maybe :: AnnTarget name -> Maybe name
data Annotation = Annotation {
- ann_target :: CoreAnnTarget
- ann_value :: AnnPayload
}
type AnnPayload = Serialized
data AnnTarget name
- = NamedTarget name
- | ModuleTarget Module
type CoreAnnTarget = AnnTarget Name
data AnnEnv
nilDataConKey :: Unique
listTyConKey :: Unique
starInfo :: Bool -> RdrName -> SDoc
pprNameProvenance :: GlobalRdrElt -> SDoc
isExplicitItem :: ImpItemSpec -> Bool
importSpecModule :: ImportSpec -> ModuleName
importSpecLoc :: ImportSpec -> SrcSpan
qualSpecOK :: ModuleName -> ImportSpec -> Bool
unQualSpecOK :: ImportSpec -> Bool
bestImport :: [ImportSpec] -> ImportSpec
shadowNames :: GlobalRdrEnv -> [Name] -> GlobalRdrEnv
extendGlobalRdrEnv :: GlobalRdrEnv -> GlobalRdrElt -> GlobalRdrEnv
transformGREs :: (GlobalRdrElt -> GlobalRdrElt) -> [OccName] -> GlobalRdrEnv -> GlobalRdrEnv
mkGlobalRdrEnv :: [GlobalRdrElt] -> GlobalRdrEnv
plusGlobalRdrEnv :: GlobalRdrEnv -> GlobalRdrEnv -> GlobalRdrEnv
pickGREsModExp :: ModuleName -> [GlobalRdrElt] -> [(GlobalRdrElt, GlobalRdrElt)]
pickGREs :: RdrName -> [GlobalRdrElt] -> [GlobalRdrElt]
unQualOK :: GlobalRdrElt -> Bool
greLabel :: GlobalRdrElt -> Maybe FieldLabelString
isOverloadedRecFldGRE :: GlobalRdrElt -> Bool
isRecFldGRE :: GlobalRdrElt -> Bool
isLocalGRE :: GlobalRdrElt -> Bool
getGRE_NameQualifier_maybes :: GlobalRdrEnv -> Name -> [Maybe [ModuleName]]
lookupGRE_Name_OccName :: GlobalRdrEnv -> Name -> OccName -> Maybe GlobalRdrElt
lookupGRE_FieldLabel :: GlobalRdrEnv -> FieldLabel -> Maybe GlobalRdrElt
lookupGRE_Name :: GlobalRdrEnv -> Name -> Maybe GlobalRdrElt
lookupGRE_RdrName :: RdrName -> GlobalRdrEnv -> [GlobalRdrElt]
greOccName :: GlobalRdrElt -> OccName
lookupGlobalRdrEnv :: GlobalRdrEnv -> OccName -> [GlobalRdrElt]
pprGlobalRdrEnv :: Bool -> GlobalRdrEnv -> SDoc
globalRdrEnvElts :: GlobalRdrEnv -> [GlobalRdrElt]
emptyGlobalRdrEnv :: GlobalRdrEnv
availFromGRE :: GlobalRdrElt -> AvailInfo
gresToAvailInfo :: [GlobalRdrElt] -> [AvailInfo]
greParent_maybe :: GlobalRdrElt -> Maybe Name
greSrcSpan :: GlobalRdrElt -> SrcSpan
greRdrNames :: GlobalRdrElt -> [RdrName]
greQualModName :: GlobalRdrElt -> ModuleName
gresFromAvail :: (Name -> Maybe ImportSpec) -> AvailInfo -> [GlobalRdrElt]
localGREsFromAvail :: AvailInfo -> [GlobalRdrElt]
gresFromAvails :: Maybe ImportSpec -> [AvailInfo] -> [GlobalRdrElt]
delLocalRdrEnvList :: LocalRdrEnv -> [OccName] -> LocalRdrEnv
inLocalRdrEnvScope :: Name -> LocalRdrEnv -> Bool
localRdrEnvElts :: LocalRdrEnv -> [Name]
elemLocalRdrEnv :: RdrName -> LocalRdrEnv -> Bool
lookupLocalRdrOcc :: LocalRdrEnv -> OccName -> Maybe Name
lookupLocalRdrEnv :: LocalRdrEnv -> RdrName -> Maybe Name
extendLocalRdrEnvList :: LocalRdrEnv -> [Name] -> LocalRdrEnv
extendLocalRdrEnv :: LocalRdrEnv -> Name -> LocalRdrEnv
emptyLocalRdrEnv :: LocalRdrEnv
isExact_maybe :: RdrName -> Maybe Name
isExact :: RdrName -> Bool
isOrig_maybe :: RdrName -> Maybe (Module, OccName)
isOrig :: RdrName -> Bool
isQual_maybe :: RdrName -> Maybe (ModuleName, OccName)
isQual :: RdrName -> Bool
isUnqual :: RdrName -> Bool
isSrcRdrName :: RdrName -> Bool
isRdrTc :: RdrName -> Bool
isRdrTyVar :: RdrName -> Bool
isRdrDataCon :: RdrName -> Bool
nameRdrName :: Name -> RdrName
getRdrName :: NamedThing thing => thing -> RdrName
mkQual :: NameSpace -> (FastString, FastString) -> RdrName
mkVarUnqual :: FastString -> RdrName
mkUnqual :: NameSpace -> FastString -> RdrName
mkOrig :: Module -> OccName -> RdrName
mkRdrQual :: ModuleName -> OccName -> RdrName
mkRdrUnqual :: OccName -> RdrName
demoteRdrName :: RdrName -> Maybe RdrName
rdrNameSpace :: RdrName -> NameSpace
rdrNameOcc :: RdrName -> OccName
data RdrName
- = Unqual OccName
- | Qual ModuleName OccName
- | Orig Module OccName
- | Exact Name
data LocalRdrEnv
type GlobalRdrEnv = OccEnv [GlobalRdrElt]
data GlobalRdrElt = GRE {
- gre_name :: Name
- gre_par :: Parent
- gre_lcl :: Bool
- gre_imp :: [ImportSpec]
}
data Parent
- = NoParent
- | ParentIs {
  - par_is :: Name
  }
- | FldParent {
  - par_is :: Name
  - par_lbl :: Maybe FieldLabelString
  }
data ImportSpec = ImpSpec {
- is_decl :: ImpDeclSpec
- is_item :: ImpItemSpec
}
data ImpDeclSpec = ImpDeclSpec {
- is_mod :: ModuleName
- is_as :: ModuleName
- is_qual :: Bool
- is_dloc :: SrcSpan
}
data ImpItemSpec
- = ImpAll
- | ImpSome {
  - is_explicit :: Bool
  - is_iloc :: SrcSpan
  }
type FieldLabelString = FastString
type FieldLabel = FieldLbl Name
data FieldLbl a = FieldLabel {
- flLabel :: FieldLabelString
- flIsOverloaded :: Bool
- flSelector :: a
}
extendDNameEnv :: DNameEnv a -> Name -> a -> DNameEnv a
alterDNameEnv :: (Maybe a -> Maybe a) -> DNameEnv a -> Name -> DNameEnv a
adjustDNameEnv :: (a -> a) -> DNameEnv a -> Name -> DNameEnv a
mapDNameEnv :: (a -> b) -> DNameEnv a -> DNameEnv b
filterDNameEnv :: (a -> Bool) -> DNameEnv a -> DNameEnv a
delFromDNameEnv :: DNameEnv a -> Name -> DNameEnv a
lookupDNameEnv :: DNameEnv a -> Name -> Maybe a
emptyDNameEnv :: DNameEnv a
lookupNameEnv_NF :: NameEnv a -> Name -> a
disjointNameEnv :: NameEnv a -> NameEnv a -> Bool
anyNameEnv :: (elt -> Bool) -> NameEnv elt -> Bool
filterNameEnv :: (elt -> Bool) -> NameEnv elt -> NameEnv elt
delListFromNameEnv :: NameEnv a -> [Name] -> NameEnv a
delFromNameEnv :: NameEnv a -> Name -> NameEnv a
extendNameEnvList_C :: (a -> a -> a) -> NameEnv a -> [(Name, a)] -> NameEnv a
extendNameEnv_Acc :: (a -> b -> b) -> (a -> b) -> NameEnv b -> Name -> a -> NameEnv b
mapNameEnv :: (elt1 -> elt2) -> NameEnv elt1 -> NameEnv elt2
extendNameEnv_C :: (a -> a -> a) -> NameEnv a -> Name -> a -> NameEnv a
plusNameEnv_C :: (a -> a -> a) -> NameEnv a -> NameEnv a -> NameEnv a
plusNameEnv :: NameEnv a -> NameEnv a -> NameEnv a
elemNameEnv :: Name -> NameEnv a -> Bool
mkNameEnvWith :: (a -> Name) -> [a] -> NameEnv a
mkNameEnv :: [(Name, a)] -> NameEnv a
alterNameEnv :: (Maybe a -> Maybe a) -> NameEnv a -> Name -> NameEnv a
lookupNameEnv :: NameEnv a -> Name -> Maybe a
extendNameEnvList :: NameEnv a -> [(Name, a)] -> NameEnv a
extendNameEnv :: NameEnv a -> Name -> a -> NameEnv a
unitNameEnv :: Name -> a -> NameEnv a
isEmptyNameEnv :: NameEnv a -> Bool
emptyNameEnv :: NameEnv a
nameEnvElts :: NameEnv a -> [a]
depAnal :: (node -> [Name]) -> (node -> [Name]) -> [node] -> [SCC node]
type NameEnv a = UniqFM a
type DNameEnv a = UniqDFM a
findUses :: DefUses -> Uses -> Uses
duUses :: DefUses -> Uses
allUses :: DefUses -> Uses
duDefs :: DefUses -> Defs
plusDU :: DefUses -> DefUses -> DefUses
mkDUs :: [(Defs, Uses)] -> DefUses
usesOnly :: Uses -> DefUses
emptyDUs :: DefUses
intersectFVs :: FreeVars -> FreeVars -> FreeVars
delFVs :: [Name] -> FreeVars -> FreeVars
delFV :: Name -> FreeVars -> FreeVars
unitFV :: Name -> FreeVars
addOneFV :: FreeVars -> Name -> FreeVars
mkFVs :: [Name] -> FreeVars
plusFV :: FreeVars -> FreeVars -> FreeVars
plusFVs :: [FreeVars] -> FreeVars
emptyFVs :: FreeVars
isEmptyFVs :: NameSet -> Bool
nameSetElemsStable :: NameSet -> [Name]
nameSetAll :: (Name -> Bool) -> NameSet -> Bool
nameSetAny :: (Name -> Bool) -> NameSet -> Bool
intersectsNameSet :: NameSet -> NameSet -> Bool
delListFromNameSet :: NameSet -> [Name] -> NameSet
intersectNameSet :: NameSet -> NameSet -> NameSet
filterNameSet :: (Name -> Bool) -> NameSet -> NameSet
delFromNameSet :: NameSet -> Name -> NameSet
elemNameSet :: Name -> NameSet -> Bool
minusNameSet :: NameSet -> NameSet -> NameSet
unionNameSets :: [NameSet] -> NameSet
unionNameSet :: NameSet -> NameSet -> NameSet
extendNameSet :: NameSet -> Name -> NameSet
extendNameSetList :: NameSet -> [Name] -> NameSet
mkNameSet :: [Name] -> NameSet
unitNameSet :: Name -> NameSet
emptyNameSet :: NameSet
isEmptyNameSet :: NameSet -> Bool
type NameSet = UniqSet Name
type FreeVars = NameSet
type Defs = NameSet
type Uses = NameSet
type DefUse = (Maybe Defs, Uses)
type DefUses = OrdList DefUse
pprModuleMap :: ModuleToPkgConfAll -> SDoc
pprPackagesSimple :: DynFlags -> SDoc
pprPackages :: DynFlags -> SDoc
isDllName :: DynFlags -> Module -> Name -> Bool
getPreloadPackagesAnd :: DynFlags -> [PreloadUnitId] -> IO [PackageConfig]
listVisibleModuleNames :: DynFlags -> [ModuleName]
lookupPluginModuleWithSuggestions :: DynFlags -> ModuleName -> Maybe FastString -> LookupResult
lookupModuleWithSuggestions :: DynFlags -> ModuleName -> Maybe FastString -> LookupResult
lookupModuleInAllPackages :: DynFlags -> ModuleName -> [(Module, PackageConfig)]
getPackageFrameworks :: DynFlags -> [PreloadUnitId] -> IO [String]
getPackageFrameworkPath :: DynFlags -> [PreloadUnitId] -> IO [String]
getPackageExtraCcOpts :: DynFlags -> [PreloadUnitId] -> IO [String]
packageHsLibs :: DynFlags -> PackageConfig -> [String]
getLibs :: DynFlags -> [PreloadUnitId] -> IO [(String, String)]
collectArchives :: DynFlags -> PackageConfig -> IO [FilePath]
collectLinkOpts :: DynFlags -> [PackageConfig] -> ([String], [String], [String])
getPackageLinkOpts :: DynFlags -> [PreloadUnitId] -> IO ([String], [String], [String])
collectLibraryPaths :: DynFlags -> [PackageConfig] -> [FilePath]
getPackageLibraryPath :: DynFlags -> [PreloadUnitId] -> IO [String]
collectIncludeDirs :: [PackageConfig] -> [FilePath]
getPackageIncludePath :: DynFlags -> [PreloadUnitId] -> IO [String]
unwireUnitId :: DynFlags -> UnitId -> UnitId
pprReason :: SDoc -> UnusablePackageReason -> SDoc
pprFlag :: PackageFlag -> SDoc
isIndefinite :: DynFlags -> Bool
readPackageConfig :: DynFlags -> FilePath -> IO (FilePath, [PackageConfig])
resolvePackageConfig :: DynFlags -> PkgConfRef -> IO (Maybe FilePath)
getPackageConfRefs :: DynFlags -> IO [PkgConfRef]
readPackageConfigs :: DynFlags -> IO [(FilePath, [PackageConfig])]
initPackages :: DynFlags -> IO (DynFlags, [PreloadUnitId])
listPackageConfigMap :: DynFlags -> [PackageConfig]
getInstalledPackageDetails :: DynFlags -> InstalledUnitId -> PackageConfig
lookupInstalledPackage :: DynFlags -> InstalledUnitId -> Maybe PackageConfig
getPackageDetails :: DynFlags -> UnitId -> PackageConfig
searchPackageId :: DynFlags -> SourcePackageId -> [PackageConfig]
lookupPackageName :: DynFlags -> PackageName -> Maybe ComponentId
lookupPackage' :: Bool -> PackageConfigMap -> UnitId -> Maybe PackageConfig
lookupPackage :: DynFlags -> UnitId -> Maybe PackageConfig
data ModuleOrigin
- = ModHidden
- | ModUnusable UnusablePackageReason
- | ModOrigin {
  - fromOrigPackage :: Maybe Bool
  - fromExposedReexport :: [PackageConfig]
  - fromHiddenReexport :: [PackageConfig]
  - fromPackageFlag :: Bool
  }
data UnusablePackageReason
- = IgnoredWithFlag
- | BrokenDependencies [InstalledUnitId]
- | CyclicDependencies [InstalledUnitId]
- | IgnoredDependencies [InstalledUnitId]
- | ShadowedDependencies [InstalledUnitId]
data LookupResult
- = LookupFound Module PackageConfig
- | LookupMultiple [(Module, ModuleOrigin)]
- | LookupHidden [(Module, ModuleOrigin)] [(Module, ModuleOrigin)]
- | LookupUnusable [(Module, ModuleOrigin)]
- | LookupNotFound [ModuleSuggestion]
data ModuleSuggestion
- = SuggestVisible ModuleName Module ModuleOrigin
- | SuggestHidden ModuleName Module ModuleOrigin
listTyCon :: TyCon
typeSymbolKind :: Kind
typeNatKind :: Kind
mkBoxedTupleTy :: [Type] -> Type
heqTyCon :: TyCon
coercibleTyCon :: TyCon
unitTy :: Type
liftedTypeKind :: Kind
constraintKind :: Kind
vecElemTyCon :: TyCon
vecCountTyCon :: TyCon
runtimeRepTyCon :: TyCon
runtimeRepTy :: Type
tupleRepDataConTyCon :: TyCon
vecRepDataConTyCon :: TyCon
liftedRepDataConTyCon :: TyCon
doubleRepDataConTy :: Type
floatRepDataConTy :: Type
addrRepDataConTy :: Type
word64RepDataConTy :: Type
word32RepDataConTy :: Type
word16RepDataConTy :: Type
word8RepDataConTy :: Type
wordRepDataConTy :: Type
int64RepDataConTy :: Type
int32RepDataConTy :: Type
int16RepDataConTy :: Type
int8RepDataConTy :: Type
intRepDataConTy :: Type
unliftedRepDataConTy :: Type
liftedRepDataConTy :: Type
vec64DataConTy :: Type
vec32DataConTy :: Type
vec16DataConTy :: Type
vec8DataConTy :: Type
vec4DataConTy :: Type
vec2DataConTy :: Type
doubleElemRepDataConTy :: Type
floatElemRepDataConTy :: Type
word64ElemRepDataConTy :: Type
word32ElemRepDataConTy :: Type
word16ElemRepDataConTy :: Type
word8ElemRepDataConTy :: Type
int64ElemRepDataConTy :: Type
int32ElemRepDataConTy :: Type
int16ElemRepDataConTy :: Type
int8ElemRepDataConTy :: Type
anyTypeOfKind :: Kind -> Type
unboxedTupleKind :: [Type] -> Kind
mkPromotedListTy :: Kind -> [Type] -> Type
tupleTyConName :: TupleSort -> Arity -> Name
pprPrefixName :: NamedThing a => a -> SDoc
pprInfixName :: (Outputable a, NamedThing a) => a -> SDoc
getOccFS :: NamedThing a => a -> FastString
getOccString :: NamedThing a => a -> String
getSrcSpan :: NamedThing a => a -> SrcSpan
getSrcLoc :: NamedThing a => a -> SrcLoc
nameStableString :: Name -> String
pprNameDefnLoc :: Name -> SDoc
pprDefinedAt :: Name -> SDoc
pprModulePrefix :: PprStyle -> Module -> OccName -> SDoc
pprNameUnqualified :: Name -> SDoc
stableNameCmp :: Name -> Name -> Ordering
localiseName :: Name -> Name
tidyNameOcc :: Name -> OccName -> Name
setNameLoc :: Name -> SrcSpan -> Name
setNameUnique :: Name -> Unique -> Name
mkFCallName :: Unique -> String -> Name
mkSysTvName :: Unique -> FastString -> Name
mkSystemVarName :: Unique -> FastString -> Name
mkSystemNameAt :: Unique -> OccName -> SrcSpan -> Name
mkSystemName :: Unique -> OccName -> Name
mkWiredInName :: Module -> OccName -> Unique -> TyThing -> BuiltInSyntax -> Name
mkExternalName :: Unique -> Module -> OccName -> SrcSpan -> Name
mkDerivedInternalName :: (OccName -> OccName) -> Unique -> Name -> Name
mkClonedInternalName :: Unique -> Name -> Name
mkInternalName :: Unique -> OccName -> SrcSpan -> Name
isSystemName :: Name -> Bool
isVarName :: Name -> Bool
isValName :: Name -> Bool
isDataConName :: Name -> Bool
isTyConName :: Name -> Bool
isTyVarName :: Name -> Bool
nameIsFromExternalPackage :: UnitId -> Name -> Bool
nameIsHomePackageImport :: Module -> Name -> Bool
nameIsHomePackage :: Module -> Name -> Bool
nameIsLocalOrFrom :: Module -> Name -> Bool
nameModule_maybe :: Name -> Maybe Module
nameModule :: HasDebugCallStack => Name -> Module
isHoleName :: Name -> Bool
isInternalName :: Name -> Bool
isExternalName :: Name -> Bool
isBuiltInSyntax :: Name -> Bool
wiredInNameTyThing_maybe :: Name -> Maybe TyThing
isWiredInName :: Name -> Bool
nameSrcSpan :: Name -> SrcSpan
nameSrcLoc :: Name -> SrcLoc
nameNameSpace :: Name -> NameSpace
nameOccName :: Name -> OccName
nameUnique :: Name -> Unique
data BuiltInSyntax
- = BuiltInSyntax
- | UserSyntax
class NamedThing a where
- getOccName :: a -> OccName
- getName :: a -> Name
pprCo :: Coercion -> SDoc
mkForAllTy :: TyCoVar -> ArgFlag -> Type -> Type
data Type
data TyThing
- = AnId Id
- | AConLike ConLike
- | ATyCon TyCon
- | ACoAxiom (CoAxiom Branched)
data Coercion
data UnivCoProvenance
data TyCoBinder
data MCoercion
- = MRefl
- | MCo Coercion
type PredType = Type
type Kind = Type
type ThetaType = [PredType]
type CoercionN = Coercion
data ArgFlag
- = Inferred
- | Specified
- | Required
data AnonArgFlag
- = VisArg
- | InvisArg
data Var
data SimplCount
data CoreM a
data CoreToDo
- = CoreDoSimplify Int SimplMode
- | CoreDoPluginPass String CorePluginPass
- | CoreDoFloatInwards
- | CoreDoFloatOutwards FloatOutSwitches
- | CoreLiberateCase
- | CoreDoPrintCore
- | CoreDoStaticArgs
- | CoreDoCallArity
- | CoreDoExitify
- | CoreDoStrictness
- | CoreDoWorkerWrapper
- | CoreDoSpecialising
- | CoreDoSpecConstr
- | CoreCSE
- | CoreDoRuleCheck CompilerPhase String
- | CoreDoNothing
- | CoreDoPasses [CoreToDo]
- | CoreDesugar
- | CoreDesugarOpt
- | CoreTidy
- | CorePrep
- | CoreOccurAnal
tidyOccName :: TidyOccEnv -> OccName -> (TidyOccEnv, OccName)
avoidClashesOccEnv :: TidyOccEnv -> [OccName] -> TidyOccEnv
initTidyOccEnv :: [OccName] -> TidyOccEnv
emptyTidyOccEnv :: TidyOccEnv
mkMethodOcc :: OccName -> OccName
mkDataCOcc :: OccName -> OccSet -> OccName
mkDataTOcc :: OccName -> OccSet -> OccName
mkDFunOcc :: String -> Bool -> OccSet -> OccName
mkInstTyTcOcc :: String -> OccSet -> OccName
mkLocalOcc :: Unique -> OccName -> OccName
mkSuperDictSelOcc :: Int -> OccName -> OccName
mkSuperDictAuxOcc :: Int -> OccName -> OccName
mkDataConWorkerOcc :: OccName -> OccName
mkRecFldSelOcc :: String -> OccName
mkGen1R :: OccName -> OccName
mkGenR :: OccName -> OccName
mkTyConRepOcc :: OccName -> OccName
mkMaxTagOcc :: OccName -> OccName
mkTag2ConOcc :: OccName -> OccName
mkCon2TagOcc :: OccName -> OccName
mkEqPredCoOcc :: OccName -> OccName
mkInstTyCoOcc :: OccName -> OccName
mkNewTyCoOcc :: OccName -> OccName
mkClassDataConOcc :: OccName -> OccName
mkRepEqOcc :: OccName -> OccName
mkForeignExportOcc :: OccName -> OccName
mkSpecOcc :: OccName -> OccName
mkIPOcc :: OccName -> OccName
mkDictOcc :: OccName -> OccName
mkClassOpAuxOcc :: OccName -> OccName
mkDefaultMethodOcc :: OccName -> OccName
mkBuilderOcc :: OccName -> OccName
mkMatcherOcc :: OccName -> OccName
mkWorkerOcc :: OccName -> OccName
mkDataConWrapperOcc :: OccName -> OccName
isTypeableBindOcc :: OccName -> Bool
isDefaultMethodOcc :: OccName -> Bool
isDerivedOccName :: OccName -> Bool
startsWithUnderscore :: OccName -> Bool
parenSymOcc :: OccName -> SDoc -> SDoc
isSymOcc :: OccName -> Bool
isDataSymOcc :: OccName -> Bool
isDataOcc :: OccName -> Bool
isValOcc :: OccName -> Bool
isTcOcc :: OccName -> Bool
isTvOcc :: OccName -> Bool
isVarOcc :: OccName -> Bool
setOccNameSpace :: NameSpace -> OccName -> OccName
occNameString :: OccName -> String
filterOccSet :: (OccName -> Bool) -> OccSet -> OccSet
intersectsOccSet :: OccSet -> OccSet -> Bool
intersectOccSet :: OccSet -> OccSet -> OccSet
isEmptyOccSet :: OccSet -> Bool
elemOccSet :: OccName -> OccSet -> Bool
minusOccSet :: OccSet -> OccSet -> OccSet
unionManyOccSets :: [OccSet] -> OccSet
unionOccSets :: OccSet -> OccSet -> OccSet
extendOccSetList :: OccSet -> [OccName] -> OccSet
extendOccSet :: OccSet -> OccName -> OccSet
mkOccSet :: [OccName] -> OccSet
unitOccSet :: OccName -> OccSet
emptyOccSet :: OccSet
pprOccEnv :: (a -> SDoc) -> OccEnv a -> SDoc
alterOccEnv :: (Maybe elt -> Maybe elt) -> OccEnv elt -> OccName -> OccEnv elt
filterOccEnv :: (elt -> Bool) -> OccEnv elt -> OccEnv elt
delListFromOccEnv :: OccEnv a -> [OccName] -> OccEnv a
delFromOccEnv :: OccEnv a -> OccName -> OccEnv a
mkOccEnv_C :: (a -> a -> a) -> [(OccName, a)] -> OccEnv a
mapOccEnv :: (a -> b) -> OccEnv a -> OccEnv b
extendOccEnv_Acc :: (a -> b -> b) -> (a -> b) -> OccEnv b -> OccName -> a -> OccEnv b
extendOccEnv_C :: (a -> a -> a) -> OccEnv a -> OccName -> a -> OccEnv a
plusOccEnv_C :: (a -> a -> a) -> OccEnv a -> OccEnv a -> OccEnv a
plusOccEnv :: OccEnv a -> OccEnv a -> OccEnv a
occEnvElts :: OccEnv a -> [a]
foldOccEnv :: (a -> b -> b) -> b -> OccEnv a -> b
elemOccEnv :: OccName -> OccEnv a -> Bool
mkOccEnv :: [(OccName, a)] -> OccEnv a
lookupOccEnv :: OccEnv a -> OccName -> Maybe a
extendOccEnvList :: OccEnv a -> [(OccName, a)] -> OccEnv a
extendOccEnv :: OccEnv a -> OccName -> a -> OccEnv a
unitOccEnv :: OccName -> a -> OccEnv a
emptyOccEnv :: OccEnv a
nameSpacesRelated :: NameSpace -> NameSpace -> Bool
demoteOccName :: OccName -> Maybe OccName
mkClsOccFS :: FastString -> OccName
mkClsOcc :: String -> OccName
mkTcOccFS :: FastString -> OccName
mkTcOcc :: String -> OccName
mkTyVarOccFS :: FastString -> OccName
mkTyVarOcc :: String -> OccName
mkDataOccFS :: FastString -> OccName
mkDataOcc :: String -> OccName
mkVarOccFS :: FastString -> OccName
mkVarOcc :: String -> OccName
mkOccNameFS :: NameSpace -> FastString -> OccName
mkOccName :: NameSpace -> String -> OccName
pprOccName :: OccName -> SDoc
pprNameSpaceBrief :: NameSpace -> SDoc
pprNonVarNameSpace :: NameSpace -> SDoc
pprNameSpace :: NameSpace -> SDoc
isValNameSpace :: NameSpace -> Bool
isVarNameSpace :: NameSpace -> Bool
isTvNameSpace :: NameSpace -> Bool
isTcClsNameSpace :: NameSpace -> Bool
isDataConNameSpace :: NameSpace -> Bool
tvName :: NameSpace
srcDataName :: NameSpace
dataName :: NameSpace
tcClsName :: NameSpace
clsName :: NameSpace
tcName :: NameSpace
data NameSpace
class HasOccName name where
- occName :: name -> OccName
data OccEnv a
type OccSet = UniqSet OccName
type TidyOccEnv = UniqFM Int
emptyFilesToClean :: FilesToClean
isBmi2Enabled :: DynFlags -> Bool
isBmiEnabled :: DynFlags -> Bool
isAvx512pfEnabled :: DynFlags -> Bool
isAvx512fEnabled :: DynFlags -> Bool
isAvx512erEnabled :: DynFlags -> Bool
isAvx512cdEnabled :: DynFlags -> Bool
isAvx2Enabled :: DynFlags -> Bool
isAvxEnabled :: DynFlags -> Bool
isSse4_2Enabled :: DynFlags -> Bool
isSse2Enabled :: DynFlags -> Bool
isSseEnabled :: DynFlags -> Bool
setUnsafeGlobalDynFlags :: DynFlags -> IO ()
makeDynFlagsConsistent :: DynFlags -> (DynFlags, [Located String])
tARGET_MAX_WORD :: DynFlags -> Integer
tARGET_MAX_INT :: DynFlags -> Integer
tARGET_MIN_INT :: DynFlags -> Integer
mAX_PTR_TAG :: DynFlags -> Int
tAG_MASK :: DynFlags -> Int
wordAlignment :: DynFlags -> Alignment
wORD_SIZE_IN_BITS :: DynFlags -> Int
bLOCK_SIZE_W :: DynFlags -> Int
iLDV_STATE_USE :: DynFlags -> Integer
iLDV_STATE_CREATE :: DynFlags -> Integer
iLDV_CREATE_MASK :: DynFlags -> Integer
lDV_SHIFT :: DynFlags -> Int
dYNAMIC_BY_DEFAULT :: DynFlags -> Bool
wORDS_BIGENDIAN :: DynFlags -> Bool
tAG_BITS :: DynFlags -> Int
bITMAP_BITS_SHIFT :: DynFlags -> Int
cLONG_LONG_SIZE :: DynFlags -> Int
cLONG_SIZE :: DynFlags -> Int
cINT_SIZE :: DynFlags -> Int
dOUBLE_SIZE :: DynFlags -> Int
wORD_SIZE :: DynFlags -> Int
aP_STACK_SPLIM :: DynFlags -> Int
rESERVED_STACK_WORDS :: DynFlags -> Int
rESERVED_C_STACK_BYTES :: DynFlags -> Int
mAX_Real_Long_REG :: DynFlags -> Int
mAX_Real_XMM_REG :: DynFlags -> Int
mAX_Real_Double_REG :: DynFlags -> Int
mAX_Real_Float_REG :: DynFlags -> Int
mAX_Real_Vanilla_REG :: DynFlags -> Int
mAX_XMM_REG :: DynFlags -> Int
mAX_Long_REG :: DynFlags -> Int
mAX_Double_REG :: DynFlags -> Int
mAX_Float_REG :: DynFlags -> Int
mAX_Vanilla_REG :: DynFlags -> Int
mUT_ARR_PTRS_CARD_BITS :: DynFlags -> Int
mAX_CHARLIKE :: DynFlags -> Int
mIN_CHARLIKE :: DynFlags -> Int
mAX_INTLIKE :: DynFlags -> Int
mIN_INTLIKE :: DynFlags -> Int
mIN_PAYLOAD_SIZE :: DynFlags -> Int
mAX_SPEC_AP_SIZE :: DynFlags -> Int
mAX_SPEC_SELECTEE_SIZE :: DynFlags -> Int
oFFSET_StgFunInfoExtraRev_arity :: DynFlags -> Int
sIZEOF_StgFunInfoExtraRev :: DynFlags -> Int
oFFSET_StgFunInfoExtraFwd_arity :: DynFlags -> Int
oFFSET_StgUpdateFrame_updatee :: DynFlags -> Int
oFFSET_StgStack_stack :: DynFlags -> Int
oFFSET_StgStack_sp :: DynFlags -> Int
oFFSET_StgTSO_stackobj :: DynFlags -> Int
oFFSET_StgTSO_cccs :: DynFlags -> Int
oFFSET_StgTSO_alloc_limit :: DynFlags -> Int
oFFSET_StgArrBytes_bytes :: DynFlags -> Int
sIZEOF_StgArrBytes_NoHdr :: DynFlags -> Int
oFFSET_StgSmallMutArrPtrs_ptrs :: DynFlags -> Int
sIZEOF_StgSmallMutArrPtrs_NoHdr :: DynFlags -> Int
oFFSET_StgMutArrPtrs_size :: DynFlags -> Int
oFFSET_StgMutArrPtrs_ptrs :: DynFlags -> Int
sIZEOF_StgMutArrPtrs_NoHdr :: DynFlags -> Int
sIZEOF_StgUpdateFrame_NoHdr :: DynFlags -> Int
oFFSET_StgEntCounter_entry_count :: DynFlags -> Int
oFFSET_StgEntCounter_link :: DynFlags -> Int
oFFSET_StgEntCounter_registeredp :: DynFlags -> Int
oFFSET_StgEntCounter_allocd :: DynFlags -> Int
oFFSET_StgEntCounter_allocs :: DynFlags -> Int
sIZEOF_StgSMPThunkHeader :: DynFlags -> Int
oFFSET_StgHeader_ldvw :: DynFlags -> Int
oFFSET_StgHeader_ccs :: DynFlags -> Int
oFFSET_CostCentreStack_scc_count :: DynFlags -> Int
oFFSET_CostCentreStack_mem_alloc :: DynFlags -> Int
sIZEOF_CostCentreStack :: DynFlags -> Int
oFFSET_bdescr_flags :: DynFlags -> Int
oFFSET_bdescr_blocks :: DynFlags -> Int
oFFSET_bdescr_free :: DynFlags -> Int
oFFSET_bdescr_start :: DynFlags -> Int
oFFSET_Capability_r :: DynFlags -> Int
oFFSET_stgGCFun :: DynFlags -> Int
oFFSET_stgGCEnter1 :: DynFlags -> Int
oFFSET_stgEagerBlackholeInfo :: DynFlags -> Int
oFFSET_StgRegTable_rHpAlloc :: DynFlags -> Int
oFFSET_StgRegTable_rCurrentNursery :: DynFlags -> Int
oFFSET_StgRegTable_rCurrentTSO :: DynFlags -> Int
oFFSET_StgRegTable_rCCCS :: DynFlags -> Int
oFFSET_StgRegTable_rHpLim :: DynFlags -> Int
oFFSET_StgRegTable_rHp :: DynFlags -> Int
oFFSET_StgRegTable_rSpLim :: DynFlags -> Int
oFFSET_StgRegTable_rSp :: DynFlags -> Int
oFFSET_StgRegTable_rL1 :: DynFlags -> Int
oFFSET_StgRegTable_rZMM6 :: DynFlags -> Int
oFFSET_StgRegTable_rZMM5 :: DynFlags -> Int
oFFSET_StgRegTable_rZMM4 :: DynFlags -> Int
oFFSET_StgRegTable_rZMM3 :: DynFlags -> Int
oFFSET_StgRegTable_rZMM2 :: DynFlags -> Int
oFFSET_StgRegTable_rZMM1 :: DynFlags -> Int
oFFSET_StgRegTable_rYMM6 :: DynFlags -> Int
oFFSET_StgRegTable_rYMM5 :: DynFlags -> Int
oFFSET_StgRegTable_rYMM4 :: DynFlags -> Int
oFFSET_StgRegTable_rYMM3 :: DynFlags -> Int
oFFSET_StgRegTable_rYMM2 :: DynFlags -> Int
oFFSET_StgRegTable_rYMM1 :: DynFlags -> Int
oFFSET_StgRegTable_rXMM6 :: DynFlags -> Int
oFFSET_StgRegTable_rXMM5 :: DynFlags -> Int
oFFSET_StgRegTable_rXMM4 :: DynFlags -> Int
oFFSET_StgRegTable_rXMM3 :: DynFlags -> Int
oFFSET_StgRegTable_rXMM2 :: DynFlags -> Int
oFFSET_StgRegTable_rXMM1 :: DynFlags -> Int
oFFSET_StgRegTable_rD6 :: DynFlags -> Int
oFFSET_StgRegTable_rD5 :: DynFlags -> Int
oFFSET_StgRegTable_rD4 :: DynFlags -> Int
oFFSET_StgRegTable_rD3 :: DynFlags -> Int
oFFSET_StgRegTable_rD2 :: DynFlags -> Int
oFFSET_StgRegTable_rD1 :: DynFlags -> Int
oFFSET_StgRegTable_rF6 :: DynFlags -> Int
oFFSET_StgRegTable_rF5 :: DynFlags -> Int
oFFSET_StgRegTable_rF4 :: DynFlags -> Int
oFFSET_StgRegTable_rF3 :: DynFlags -> Int
oFFSET_StgRegTable_rF2 :: DynFlags -> Int
oFFSET_StgRegTable_rF1 :: DynFlags -> Int
oFFSET_StgRegTable_rR10 :: DynFlags -> Int
oFFSET_StgRegTable_rR9 :: DynFlags -> Int
oFFSET_StgRegTable_rR8 :: DynFlags -> Int
oFFSET_StgRegTable_rR7 :: DynFlags -> Int
oFFSET_StgRegTable_rR6 :: DynFlags -> Int
oFFSET_StgRegTable_rR5 :: DynFlags -> Int
oFFSET_StgRegTable_rR4 :: DynFlags -> Int
oFFSET_StgRegTable_rR3 :: DynFlags -> Int
oFFSET_StgRegTable_rR2 :: DynFlags -> Int
oFFSET_StgRegTable_rR1 :: DynFlags -> Int
tICKY_BIN_COUNT :: DynFlags -> Int
bLOCKS_PER_MBLOCK :: DynFlags -> Int
bLOCK_SIZE :: DynFlags -> Int
pROF_HDR_SIZE :: DynFlags -> Int
sTD_HDR_SIZE :: DynFlags -> Int
cONTROL_GROUP_CONST_291 :: DynFlags -> Int
compilerInfo :: DynFlags -> [(String, String)]
picPOpts :: DynFlags -> [String]
picCCOpts :: DynFlags -> [String]
setTmpDir :: FilePath -> DynFlags -> DynFlags
setFlagsFromEnvFile :: FilePath -> String -> DynP ()
canonicalizeModuleIfHome :: DynFlags -> Module -> Module
canonicalizeHomeModule :: DynFlags -> ModuleName -> Module
setUnitId :: String -> DynFlags -> DynFlags
unSetGeneralFlag' :: GeneralFlag -> DynFlags -> DynFlags
setGeneralFlag' :: GeneralFlag -> DynFlags -> DynFlags
addWay' :: Way -> DynFlags -> DynFlags
dynamicGhc :: Bool
rtsIsProfiled :: Bool
glasgowExtsFlags :: [Extension]
warningHierarchies :: [[String]]
warningGroups :: [(String, [WarningFlag])]
xFlags :: [FlagSpec Extension]
supportedLanguagesAndExtensions :: PlatformMini -> [String]
fLangFlags :: [FlagSpec Extension]
fFlags :: [FlagSpec GeneralFlag]
wWarningFlags :: [FlagSpec WarningFlag]
flagsForCompletion :: Bool -> [String]
flagsPackage :: [Flag (CmdLineP DynFlags)]
flagsDynamic :: [Flag (CmdLineP DynFlags)]
flagsAll :: [Flag (CmdLineP DynFlags)]
allNonDeprecatedFlags :: [String]
updateWays :: DynFlags -> DynFlags
putLogMsg :: DynFlags -> WarnReason -> Severity -> SrcSpan -> PprStyle -> MsgDoc -> IO ()
parseDynamicFlagsFull :: MonadIO m => [Flag (CmdLineP DynFlags)] -> Bool -> DynFlags -> [Located String] -> m (DynFlags, [Located String], [Warn])
parseDynamicFilePragma :: MonadIO m => DynFlags -> [Located String] -> m (DynFlags, [Located String], [Warn])
parseDynamicFlagsCmdLine :: MonadIO m => DynFlags -> [Located String] -> m (DynFlags, [Located String], [Warn])
updOptLevel :: Int -> DynFlags -> DynFlags
addPluginModuleName :: String -> DynFlags -> DynFlags
thisPackage :: DynFlags -> UnitId
thisUnitIdInsts :: DynFlags -> [(ModuleName, Module)]
thisComponentId :: DynFlags -> ComponentId
getVerbFlags :: DynFlags -> [String]
getOpts :: DynFlags -> (DynFlags -> [a]) -> [a]
unsafeFlagsForInfer :: [(String, DynFlags -> SrcSpan, DynFlags -> Bool, DynFlags -> DynFlags)]
unsafeFlags :: [(String, DynFlags -> SrcSpan, DynFlags -> Bool, DynFlags -> DynFlags)]
safeImplicitImpsReq :: DynFlags -> Bool
safeDirectImpsReq :: DynFlags -> Bool
safeImportsOn :: DynFlags -> Bool
safeInferOn :: DynFlags -> Bool
safeLanguageOn :: DynFlags -> Bool
safeHaskellModeEnabled :: DynFlags -> Bool
safeHaskellOn :: DynFlags -> Bool
packageTrustOn :: DynFlags -> Bool
dynFlagDependencies :: DynFlags -> [ModuleName]
lang_set :: DynFlags -> Maybe Language -> DynFlags
xopt_set_unlessExplSpec :: Extension -> (DynFlags -> Extension -> DynFlags) -> DynFlags -> DynFlags
xopt_unset :: DynFlags -> Extension -> DynFlags
xopt_set :: DynFlags -> Extension -> DynFlags
xopt :: Extension -> DynFlags -> Bool
wopt_unset_fatal :: DynFlags -> WarningFlag -> DynFlags
wopt_set_fatal :: DynFlags -> WarningFlag -> DynFlags
wopt_fatal :: WarningFlag -> DynFlags -> Bool
wopt_unset :: DynFlags -> WarningFlag -> DynFlags
wopt_set :: DynFlags -> WarningFlag -> DynFlags
wopt :: WarningFlag -> DynFlags -> Bool
gopt_unset :: DynFlags -> GeneralFlag -> DynFlags
gopt_set :: DynFlags -> GeneralFlag -> DynFlags
gopt :: GeneralFlag -> DynFlags -> Bool
dopt_unset :: DynFlags -> DumpFlag -> DynFlags
dopt_set :: DynFlags -> DumpFlag -> DynFlags
dopt :: DumpFlag -> DynFlags -> Bool
hasNoOptCoercion :: DynFlags -> Bool
hasNoStateHack :: DynFlags -> Bool
languageExtensions :: Maybe Language -> [Extension]
defaultFlushErr :: FlushErr
defaultFlushOut :: FlushOut
defaultLogActionHPutStrDoc :: DynFlags -> Handle -> SDoc -> PprStyle -> IO ()
defaultLogActionHPrintDoc :: DynFlags -> Handle -> SDoc -> PprStyle -> IO ()
defaultLogAction :: LogAction
defaultFatalMessager :: FatalMessager
interpreterDynamic :: DynFlags -> Bool
interpreterProfiled :: DynFlags -> Bool
interpWays :: [Way]
defaultWays :: Settings -> [Way]
defaultDynFlags :: Settings -> LlvmConfig -> DynFlags
initDynFlags :: DynFlags -> IO DynFlags
dynamicOutputFile :: DynFlags -> FilePath -> FilePath
dynamicTooMkDynamicDynFlags :: DynFlags -> DynFlags
whenCannotGenerateDynamicToo :: MonadIO m => DynFlags -> m () -> m ()
ifGeneratingDynamicToo :: MonadIO m => DynFlags -> m a -> m a -> m a
whenGeneratingDynamicToo :: MonadIO m => DynFlags -> m () -> m ()
wayUnsetGeneralFlags :: Platform -> Way -> [GeneralFlag]
wayGeneralFlags :: Platform -> Way -> [GeneralFlag]
wayRTSOnly :: Way -> Bool
mkBuildTag :: [Way] -> String
positionIndependent :: DynFlags -> Bool
defaultObjectTarget :: DynFlags -> HscTarget
packageFlagsChanged :: DynFlags -> DynFlags -> Bool
isNoLink :: GhcLink -> Bool
isOneShot :: GhcMode -> Bool
targetRetainsAllBindings :: HscTarget -> Bool
isObjectTarget :: HscTarget -> Bool
versionedFilePath :: DynFlags -> FilePath
versionedAppDir :: DynFlags -> MaybeT IO FilePath
tablesNextToCode :: DynFlags -> Bool
opt_i :: DynFlags -> [String]
opt_lc :: DynFlags -> [String]
opt_lo :: DynFlags -> [String]
opt_lcc :: DynFlags -> [String]
opt_windres :: DynFlags -> [String]
opt_lm :: DynFlags -> [String]
opt_l :: DynFlags -> [String]
opt_a :: DynFlags -> [String]
opt_cxx :: DynFlags -> [String]
opt_c :: DynFlags -> [String]
opt_F :: DynFlags -> [String]
opt_P_signature :: DynFlags -> ([String], Fingerprint)
opt_P :: DynFlags -> [String]
opt_L :: DynFlags -> [String]
pgm_i :: DynFlags -> String
pgm_lc :: DynFlags -> (String, [Option])
pgm_lo :: DynFlags -> (String, [Option])
pgm_ranlib :: DynFlags -> String
pgm_ar :: DynFlags -> String
pgm_lcc :: DynFlags -> (String, [Option])
pgm_libtool :: DynFlags -> String
pgm_windres :: DynFlags -> String
pgm_T :: DynFlags -> String
pgm_dll :: DynFlags -> (String, [Option])
pgm_lm :: DynFlags -> (String, [Option])
pgm_l :: DynFlags -> (String, [Option])
pgm_a :: DynFlags -> (String, [Option])
pgm_c :: DynFlags -> String
pgm_F :: DynFlags -> String
pgm_P :: DynFlags -> (String, [Option])
pgm_L :: DynFlags -> String
systemPackageConfig :: DynFlags -> FilePath
extraGccViaCFlags :: DynFlags -> [String]
tmpDir :: DynFlags -> String
topDir :: DynFlags -> FilePath
ghciUsagePath :: DynFlags -> FilePath
ghcUsagePath :: DynFlags -> FilePath
projectVersion :: DynFlags -> String
programName :: DynFlags -> String
settings :: DynFlags -> Settings
backendMaintainsCfg :: DynFlags -> Bool
flattenIncludes :: IncludeSpecs -> [String]
addQuoteInclude :: IncludeSpecs -> [String] -> IncludeSpecs
addGlobalInclude :: IncludeSpecs -> [String] -> IncludeSpecs
optimisationFlags :: EnumSet GeneralFlag
data WarnReason
- = NoReason
- | Reason !WarningFlag
- | ErrReason !(Maybe WarningFlag)
data IncludeSpecs = IncludeSpecs {
- includePathsQuote :: [String]
- includePathsGlobal :: [String]
}
data WarningFlag
- = Opt_WarnDuplicateExports
- | Opt_WarnDuplicateConstraints
- | Opt_WarnRedundantConstraints
- | Opt_WarnHiShadows
- | Opt_WarnImplicitPrelude
- | Opt_WarnIncompletePatterns
- | Opt_WarnIncompleteUniPatterns
- | Opt_WarnIncompletePatternsRecUpd
- | Opt_WarnOverflowedLiterals
- | Opt_WarnEmptyEnumerations
- | Opt_WarnMissingFields
- | Opt_WarnMissingImportList
- | Opt_WarnMissingMethods
- | Opt_WarnMissingSignatures
- | Opt_WarnMissingLocalSignatures
- | Opt_WarnNameShadowing
- | Opt_WarnOverlappingPatterns
- | Opt_WarnTypeDefaults
- | Opt_WarnMonomorphism
- | Opt_WarnUnusedTopBinds
- | Opt_WarnUnusedLocalBinds
- | Opt_WarnUnusedPatternBinds
- | Opt_WarnUnusedImports
- | Opt_WarnUnusedMatches
- | Opt_WarnUnusedTypePatterns
- | Opt_WarnUnusedForalls
- | Opt_WarnUnusedRecordWildcards
- | Opt_WarnRedundantRecordWildcards
- | Opt_WarnWarningsDeprecations
- | Opt_WarnDeprecatedFlags
- | Opt_WarnMissingMonadFailInstances
- | Opt_WarnSemigroup
- | Opt_WarnDodgyExports
- | Opt_WarnDodgyImports
- | Opt_WarnOrphans
- | Opt_WarnAutoOrphans
- | Opt_WarnIdentities
- | Opt_WarnTabs
- | Opt_WarnUnrecognisedPragmas
- | Opt_WarnDodgyForeignImports
- | Opt_WarnUnusedDoBind
- | Opt_WarnWrongDoBind
- | Opt_WarnAlternativeLayoutRuleTransitional
- | Opt_WarnUnsafe
- | Opt_WarnSafe
- | Opt_WarnTrustworthySafe
- | Opt_WarnMissedSpecs
- | Opt_WarnAllMissedSpecs
- | Opt_WarnUnsupportedCallingConventions
- | Opt_WarnUnsupportedLlvmVersion
- | Opt_WarnMissedExtraSharedLib
- | Opt_WarnInlineRuleShadowing
- | Opt_WarnTypedHoles
- | Opt_WarnPartialTypeSignatures
- | Opt_WarnMissingExportedSignatures
- | Opt_WarnUntickedPromotedConstructors
- | Opt_WarnDerivingTypeable
- | Opt_WarnDeferredTypeErrors
- | Opt_WarnDeferredOutOfScopeVariables
- | Opt_WarnNonCanonicalMonadInstances
- | Opt_WarnNonCanonicalMonadFailInstances
- | Opt_WarnNonCanonicalMonoidInstances
- | Opt_WarnMissingPatternSynonymSignatures
- | Opt_WarnUnrecognisedWarningFlags
- | Opt_WarnSimplifiableClassConstraints
- | Opt_WarnCPPUndef
- | Opt_WarnUnbangedStrictPatterns
- | Opt_WarnMissingHomeModules
- | Opt_WarnPartialFields
- | Opt_WarnMissingExportList
- | Opt_WarnInaccessibleCode
- | Opt_WarnStarIsType
- | Opt_WarnStarBinder
- | Opt_WarnImplicitKindVars
- | Opt_WarnSpaceAfterBang
- | Opt_WarnMissingDerivingStrategies
- | Opt_WarnPrepositiveQualifiedModule
- | Opt_WarnUnusedPackages
- | Opt_WarnInferredSafeImports
- | Opt_WarnMissingSafeHaskellMode
- | Opt_WarnCompatUnqualifiedImports
- | Opt_WarnDerivingDefaults
data Language
- = Haskell98
- | Haskell2010
data SafeHaskellMode
- = Sf_None
- | Sf_Unsafe
- | Sf_Trustworthy
- | Sf_Safe
- | Sf_SafeInferred
- | Sf_Ignore
data CfgWeights = CFGWeights {
- uncondWeight :: Int
- condBranchWeight :: Int
- switchWeight :: Int
- callWeight :: Int
- likelyCondWeight :: Int
- unlikelyCondWeight :: Int
- infoTablePenalty :: Int
- backEdgeBonus :: Int
}
class HasDynFlags (m :: Type -> Type) where
- getDynFlags :: m DynFlags
class ContainsDynFlags t where
- extractDynFlags :: t -> DynFlags
data ProfAuto
- = NoProfAuto
- | ProfAutoAll
- | ProfAutoTop
- | ProfAutoExports
- | ProfAutoCalls
data LlvmTarget = LlvmTarget {
- lDataLayout :: String
- lCPU :: String
- lAttributes :: [String]
}
data LlvmConfig = LlvmConfig {
- llvmTargets :: [(String, LlvmTarget)]
- llvmPasses :: [(Int, String)]
}
data HscTarget
- = HscC
- | HscAsm
- | HscLlvm
- | HscInterpreted
- | HscNothing
data GhcMode
- = CompManager
- | OneShot
- | MkDepend
data GhcLink
- = NoLink
- | LinkBinary
- | LinkInMemory
- | LinkDynLib
- | LinkStaticLib
data PackageArg
- = PackageArg String
- | UnitIdArg UnitId
data ModRenaming = ModRenaming {
- modRenamingWithImplicit :: Bool
- modRenamings :: [(ModuleName, ModuleName)]
}
newtype IgnorePackageFlag = IgnorePackage String
data TrustFlag
- = TrustPackage String
- | DistrustPackage String
data PackageFlag
- = ExposePackage String PackageArg ModRenaming
- | HidePackage String
data PackageDBFlag
- = PackageDB PkgConfRef
- | NoUserPackageDB
- | NoGlobalPackageDB
- | ClearPackageDBs
data DynLibLoader
- = Deployable
- | SystemDependent
data RtsOptsEnabled
- = RtsOptsNone
- | RtsOptsIgnore
- | RtsOptsIgnoreAll
- | RtsOptsSafeOnly
- | RtsOptsAll
data Way
- = WayCustom String
- | WayThreaded
- | WayDebug
- | WayProf
- | WayEventLog
- | WayDyn
type FatalMessager = String -> IO ()
type LogAction = DynFlags -> WarnReason -> Severity -> SrcSpan -> PprStyle -> MsgDoc -> IO ()
newtype FlushOut = FlushOut (IO ())
newtype FlushErr = FlushErr (IO ())
data FlagSpec flag = FlagSpec {
- flagSpecName :: String
- flagSpecFlag :: flag
- flagSpecAction :: TurnOnFlag -> DynP ()
- flagSpecGhcMode :: GhcFlagMode
}
data PkgConfRef
- = GlobalPkgConf
- | UserPkgConf
- | PkgConfFile FilePath
data LinkerInfo
- = GnuLD [Option]
- | GnuGold [Option]
- | LlvmLLD [Option]
- | DarwinLD [Option]
- | SolarisLD [Option]
- | AixLD [Option]
- | UnknownLD
data CompilerInfo
- = GCC
- | Clang
- | AppleClang
- | AppleClang51
- | UnknownCC
data FilesToClean = FilesToClean {
- ftcGhcSession :: !(Set FilePath)
- ftcCurrentModule :: !(Set FilePath)
}
isHsigFile :: HscSource -> Bool
isHsBootOrSig :: HscSource -> Bool
hscSourceString :: HscSource -> String
data HscSource
- = HsSrcFile
- | HsBootFile
- | HsigFile
definitePackageConfigId :: PackageConfig -> Maybe DefUnitId
expandedPackageConfigId :: PackageConfig -> UnitId
packageConfigId :: PackageConfig -> UnitId
installedPackageConfigId :: PackageConfig -> InstalledUnitId
pprPackageConfig :: PackageConfig -> SDoc
packageNameString :: PackageConfig -> String
sourcePackageIdString :: PackageConfig -> String
defaultPackageConfig :: PackageConfig
type PackageConfig = InstalledPackageInfo ComponentId SourcePackageId PackageName InstalledUnitId UnitId ModuleName Module
newtype SourcePackageId = SourcePackageId FastString
newtype PackageName = PackageName FastString
unitModuleSet :: Module -> ModuleSet
unionModuleSet :: ModuleSet -> ModuleSet -> ModuleSet
delModuleSet :: ModuleSet -> Module -> ModuleSet
minusModuleSet :: ModuleSet -> ModuleSet -> ModuleSet
intersectModuleSet :: ModuleSet -> ModuleSet -> ModuleSet
elemModuleSet :: Module -> ModuleSet -> Bool
moduleSetElts :: ModuleSet -> [Module]
emptyModuleSet :: ModuleSet
extendModuleSetList :: ModuleSet -> [Module] -> ModuleSet
extendModuleSet :: ModuleSet -> Module -> ModuleSet
mkModuleSet :: [Module] -> ModuleSet
isEmptyModuleEnv :: ModuleEnv a -> Bool
unitModuleEnv :: Module -> a -> ModuleEnv a
moduleEnvToList :: ModuleEnv a -> [(Module, a)]
moduleEnvElts :: ModuleEnv a -> [a]
moduleEnvKeys :: ModuleEnv a -> [Module]
emptyModuleEnv :: ModuleEnv a
mkModuleEnv :: [(Module, a)] -> ModuleEnv a
mapModuleEnv :: (a -> b) -> ModuleEnv a -> ModuleEnv b
lookupWithDefaultModuleEnv :: ModuleEnv a -> a -> Module -> a
lookupModuleEnv :: ModuleEnv a -> Module -> Maybe a
plusModuleEnv :: ModuleEnv a -> ModuleEnv a -> ModuleEnv a
delModuleEnv :: ModuleEnv a -> Module -> ModuleEnv a
delModuleEnvList :: ModuleEnv a -> [Module] -> ModuleEnv a
plusModuleEnv_C :: (a -> a -> a) -> ModuleEnv a -> ModuleEnv a -> ModuleEnv a
extendModuleEnvList_C :: (a -> a -> a) -> ModuleEnv a -> [(Module, a)] -> ModuleEnv a
extendModuleEnvList :: ModuleEnv a -> [(Module, a)] -> ModuleEnv a
extendModuleEnvWith :: (a -> a -> a) -> ModuleEnv a -> Module -> a -> ModuleEnv a
extendModuleEnv :: ModuleEnv a -> Module -> a -> ModuleEnv a
elemModuleEnv :: Module -> ModuleEnv a -> Bool
filterModuleEnv :: (Module -> a -> Bool) -> ModuleEnv a -> ModuleEnv a
wiredInUnitIds :: [UnitId]
isHoleModule :: Module -> Bool
isInteractiveModule :: Module -> Bool
mainUnitId :: UnitId
interactiveUnitId :: UnitId
thisGhcUnitId :: UnitId
thUnitId :: UnitId
rtsUnitId :: UnitId
baseUnitId :: UnitId
integerUnitId :: UnitId
primUnitId :: UnitId
parseModSubst :: ReadP [(ModuleName, Module)]
parseModuleId :: ReadP Module
parseComponentId :: ReadP ComponentId
parseUnitId :: ReadP UnitId
parseModuleName :: ReadP ModuleName
generalizeIndefModule :: IndefModule -> IndefModule
generalizeIndefUnitId :: IndefUnitId -> IndefUnitId
splitUnitIdInsts :: UnitId -> (InstalledUnitId, Maybe IndefUnitId)
splitModuleInsts :: Module -> (InstalledModule, Maybe IndefModule)
renameHoleUnitId' :: PackageConfigMap -> ShHoleSubst -> UnitId -> UnitId
renameHoleModule' :: PackageConfigMap -> ShHoleSubst -> Module -> Module
renameHoleUnitId :: DynFlags -> ShHoleSubst -> UnitId -> UnitId
renameHoleModule :: DynFlags -> ShHoleSubst -> Module -> Module
stringToUnitId :: String -> UnitId
fsToUnitId :: FastString -> UnitId
newSimpleUnitId :: ComponentId -> UnitId
stableUnitIdCmp :: UnitId -> UnitId -> Ordering
newUnitId :: ComponentId -> [(ModuleName, Module)] -> UnitId
hashUnitId :: ComponentId -> [(ModuleName, Module)] -> FastString
unitIdIsDefinite :: UnitId -> Bool
unitIdFreeHoles :: UnitId -> UniqDSet ModuleName
delInstalledModuleEnv :: InstalledModuleEnv a -> InstalledModule -> InstalledModuleEnv a
filterInstalledModuleEnv :: (InstalledModule -> a -> Bool) -> InstalledModuleEnv a -> InstalledModuleEnv a
extendInstalledModuleEnv :: InstalledModuleEnv a -> InstalledModule -> a -> InstalledModuleEnv a
lookupInstalledModuleEnv :: InstalledModuleEnv a -> InstalledModule -> Maybe a
emptyInstalledModuleEnv :: InstalledModuleEnv a
installedUnitIdEq :: InstalledUnitId -> UnitId -> Bool
installedModuleEq :: InstalledModule -> Module -> Bool
stringToInstalledUnitId :: String -> InstalledUnitId
componentIdToInstalledUnitId :: ComponentId -> InstalledUnitId
fsToInstalledUnitId :: FastString -> InstalledUnitId
installedUnitIdString :: InstalledUnitId -> String
toInstalledUnitId :: UnitId -> InstalledUnitId
indefModuleToModule :: DynFlags -> IndefModule -> Module
indefUnitIdToUnitId :: DynFlags -> IndefUnitId -> UnitId
newIndefUnitId :: ComponentId -> [(ModuleName, Module)] -> IndefUnitId
unitIdKey :: UnitId -> Unique
unitIdFS :: UnitId -> FastString
pprModule :: Module -> SDoc
mkModule :: UnitId -> ModuleName -> Module
stableModuleCmp :: Module -> Module -> Ordering
mkHoleModule :: ModuleName -> Module
moduleIsDefinite :: Module -> Bool
moduleFreeHoles :: Module -> UniqDSet ModuleName
moduleNameColons :: ModuleName -> String
moduleNameSlashes :: ModuleName -> String
mkModuleNameFS :: FastString -> ModuleName
mkModuleName :: String -> ModuleName
moduleStableString :: Module -> String
moduleNameString :: ModuleName -> String
moduleNameFS :: ModuleName -> FastString
pprModuleName :: ModuleName -> SDoc
stableModuleNameCmp :: ModuleName -> ModuleName -> Ordering
addBootSuffixLocnOut :: ModLocation -> ModLocation
addBootSuffixLocn :: ModLocation -> ModLocation
addBootSuffix_maybe :: Bool -> FilePath -> FilePath
addBootSuffix :: FilePath -> FilePath
data ModLocation = ModLocation {
- ml_hs_file :: Maybe FilePath
- ml_hi_file :: FilePath
- ml_obj_file :: FilePath
- ml_hie_file :: FilePath
}
class ContainsModule t where
- extractModule :: t -> Module
class HasModule (m :: Type -> Type) where
- getModule :: m Module
data IndefUnitId = IndefUnitId {
- indefUnitIdFS :: FastString
- indefUnitIdKey :: Unique
- indefUnitIdComponentId :: !ComponentId
- indefUnitIdInsts :: ![(ModuleName, Module)]
- indefUnitIdFreeHoles :: UniqDSet ModuleName
}
data IndefModule = IndefModule {
- indefModuleUnitId :: IndefUnitId
- indefModuleName :: ModuleName
}
data InstalledModule = InstalledModule {
- installedModuleUnitId :: !InstalledUnitId
- installedModuleName :: !ModuleName
}
newtype DefUnitId = DefUnitId {
- unDefUnitId :: InstalledUnitId
}
data InstalledModuleEnv elt
type ShHoleSubst = ModuleNameEnv Module
data ModuleEnv elt
type ModuleSet = Set NDModule
type ModuleNameEnv elt = UniqFM elt
type DModuleNameEnv elt = UniqDFM elt
mkFsEnv :: [(FastString, a)] -> FastStringEnv a
lookupFsEnv :: FastStringEnv a -> FastString -> Maybe a
extendFsEnv :: FastStringEnv a -> FastString -> a -> FastStringEnv a
emptyFsEnv :: FastStringEnv a
type FastStringEnv a = UniqFM a
pprUniqSet :: (a -> SDoc) -> UniqSet a -> SDoc
unsafeUFMToUniqSet :: UniqFM a -> UniqSet a
getUniqSet :: UniqSet a -> UniqFM a
mapUniqSet :: Uniquable b => (a -> b) -> UniqSet a -> UniqSet b
nonDetFoldUniqSet_Directly :: (Unique -> elt -> a -> a) -> a -> UniqSet elt -> a
nonDetFoldUniqSet :: (elt -> a -> a) -> a -> UniqSet elt -> a
nonDetKeysUniqSet :: UniqSet elt -> [Unique]
nonDetEltsUniqSet :: UniqSet elt -> [elt]
lookupUniqSet_Directly :: UniqSet a -> Unique -> Maybe a
lookupUniqSet :: Uniquable a => UniqSet b -> a -> Maybe b
isEmptyUniqSet :: UniqSet a -> Bool
sizeUniqSet :: UniqSet a -> Int
uniqSetAll :: (a -> Bool) -> UniqSet a -> Bool
uniqSetAny :: (a -> Bool) -> UniqSet a -> Bool
partitionUniqSet :: (a -> Bool) -> UniqSet a -> (UniqSet a, UniqSet a)
filterUniqSet_Directly :: (Unique -> elt -> Bool) -> UniqSet elt -> UniqSet elt
filterUniqSet :: (a -> Bool) -> UniqSet a -> UniqSet a
elemUniqSet_Directly :: Unique -> UniqSet a -> Bool
elementOfUniqSet :: Uniquable a => a -> UniqSet a -> Bool
uniqSetMinusUFM :: UniqSet a -> UniqFM b -> UniqSet a
restrictUniqSetToUFM :: UniqSet a -> UniqFM b -> UniqSet a
intersectUniqSets :: UniqSet a -> UniqSet a -> UniqSet a
minusUniqSet :: UniqSet a -> UniqSet a -> UniqSet a
unionManyUniqSets :: [UniqSet a] -> UniqSet a
unionUniqSets :: UniqSet a -> UniqSet a -> UniqSet a
delListFromUniqSet_Directly :: UniqSet a -> [Unique] -> UniqSet a
delListFromUniqSet :: Uniquable a => UniqSet a -> [a] -> UniqSet a
delOneFromUniqSet_Directly :: UniqSet a -> Unique -> UniqSet a
delOneFromUniqSet :: Uniquable a => UniqSet a -> a -> UniqSet a
addListToUniqSet :: Uniquable a => UniqSet a -> [a] -> UniqSet a
addOneToUniqSet :: Uniquable a => UniqSet a -> a -> UniqSet a
mkUniqSet :: Uniquable a => [a] -> UniqSet a
unitUniqSet :: Uniquable a => a -> UniqSet a
emptyUniqSet :: UniqSet a
data UniqSet a
pluralUFM :: UniqFM a -> SDoc
pprUFMWithKeys :: UniqFM a -> ([(Unique, a)] -> SDoc) -> SDoc
pprUFM :: UniqFM a -> ([a] -> SDoc) -> SDoc
pprUniqFM :: (a -> SDoc) -> UniqFM a -> SDoc
equalKeysUFM :: UniqFM a -> UniqFM b -> Bool
ufmToIntMap :: UniqFM elt -> IntMap elt
nonDetUFMToList :: UniqFM elt -> [(Unique, elt)]
nonDetFoldUFM_Directly :: (Unique -> elt -> a -> a) -> a -> UniqFM elt -> a
nonDetFoldUFM :: (elt -> a -> a) -> a -> UniqFM elt -> a
nonDetKeysUFM :: UniqFM elt -> [Unique]
nonDetEltsUFM :: UniqFM elt -> [elt]
seqEltsUFM :: ([elt] -> ()) -> UniqFM elt -> ()
allUFM :: (elt -> Bool) -> UniqFM elt -> Bool
anyUFM :: (elt -> Bool) -> UniqFM elt -> Bool
ufmToSet_Directly :: UniqFM elt -> IntSet
eltsUFM :: UniqFM elt -> [elt]
lookupWithDefaultUFM_Directly :: UniqFM elt -> elt -> Unique -> elt
lookupWithDefaultUFM :: Uniquable key => UniqFM elt -> elt -> key -> elt
lookupUFM_Directly :: UniqFM elt -> Unique -> Maybe elt
lookupUFM :: Uniquable key => UniqFM elt -> key -> Maybe elt
elemUFM_Directly :: Unique -> UniqFM elt -> Bool
elemUFM :: Uniquable key => key -> UniqFM elt -> Bool
sizeUFM :: UniqFM elt -> Int
partitionUFM :: (elt -> Bool) -> UniqFM elt -> (UniqFM elt, UniqFM elt)
filterUFM_Directly :: (Unique -> elt -> Bool) -> UniqFM elt -> UniqFM elt
filterUFM :: (elt -> Bool) -> UniqFM elt -> UniqFM elt
mapUFM_Directly :: (Unique -> elt1 -> elt2) -> UniqFM elt1 -> UniqFM elt2
mapUFM :: (elt1 -> elt2) -> UniqFM elt1 -> UniqFM elt2
foldUFM :: (elt -> a -> a) -> a -> UniqFM elt -> a
disjointUFM :: UniqFM elt1 -> UniqFM elt2 -> Bool
intersectUFM_C :: (elt1 -> elt2 -> elt3) -> UniqFM elt1 -> UniqFM elt2 -> UniqFM elt3
intersectUFM :: UniqFM elt1 -> UniqFM elt2 -> UniqFM elt1
minusUFM :: UniqFM elt1 -> UniqFM elt2 -> UniqFM elt1
plusUFMList :: [UniqFM elt] -> UniqFM elt
plusMaybeUFM_C :: (elt -> elt -> Maybe elt) -> UniqFM elt -> UniqFM elt -> UniqFM elt
plusUFM_CD :: (elt -> elt -> elt) -> UniqFM elt -> elt -> UniqFM elt -> elt -> UniqFM elt
plusUFM_C :: (elt -> elt -> elt) -> UniqFM elt -> UniqFM elt -> UniqFM elt
plusUFM :: UniqFM elt -> UniqFM elt -> UniqFM elt
delFromUFM_Directly :: UniqFM elt -> Unique -> UniqFM elt
delListFromUFM_Directly :: UniqFM elt -> [Unique] -> UniqFM elt
delListFromUFM :: Uniquable key => UniqFM elt -> [key] -> UniqFM elt
delFromUFM :: Uniquable key => UniqFM elt -> key -> UniqFM elt
adjustUFM_Directly :: (elt -> elt) -> UniqFM elt -> Unique -> UniqFM elt
adjustUFM :: Uniquable key => (elt -> elt) -> UniqFM elt -> key -> UniqFM elt
addListToUFM_C :: Uniquable key => (elt -> elt -> elt) -> UniqFM elt -> [(key, elt)] -> UniqFM elt
alterUFM :: Uniquable key => (Maybe elt -> Maybe elt) -> UniqFM elt -> key -> UniqFM elt
addToUFM_Acc :: Uniquable key => (elt -> elts -> elts) -> (elt -> elts) -> UniqFM elts -> key -> elt -> UniqFM elts
addToUFM_C :: Uniquable key => (elt -> elt -> elt) -> UniqFM elt -> key -> elt -> UniqFM elt
addToUFM_Directly :: UniqFM elt -> Unique -> elt -> UniqFM elt
addListToUFM_Directly :: UniqFM elt -> [(Unique, elt)] -> UniqFM elt
addListToUFM :: Uniquable key => UniqFM elt -> [(key, elt)] -> UniqFM elt
addToUFM :: Uniquable key => UniqFM elt -> key -> elt -> UniqFM elt
listToUFM_C :: Uniquable key => (elt -> elt -> elt) -> [(key, elt)] -> UniqFM elt
listToUFM_Directly :: [(Unique, elt)] -> UniqFM elt
listToUFM :: Uniquable key => [(key, elt)] -> UniqFM elt
unitDirectlyUFM :: Unique -> elt -> UniqFM elt
unitUFM :: Uniquable key => key -> elt -> UniqFM elt
isNullUFM :: UniqFM elt -> Bool
emptyUFM :: UniqFM elt
data UniqFM ele
newtype NonDetUniqFM ele = NonDetUniqFM {
- getNonDet :: UniqFM ele
}
initUs_ :: UniqSupply -> UniqSM a -> a
initUs :: UniqSupply -> UniqSM a -> (a, UniqSupply)
takeUniqFromSupply :: UniqSupply -> (Unique, UniqSupply)
uniqsFromSupply :: UniqSupply -> [Unique]
uniqFromSupply :: UniqSupply -> Unique
listSplitUniqSupply :: UniqSupply -> [UniqSupply]
splitUniqSupply :: UniqSupply -> (UniqSupply, UniqSupply)
mkSplitUniqSupply :: Char -> IO UniqSupply
uniqFromMask :: Char -> IO Unique
initUniqSupply :: Int -> Int -> IO ()
data UniqSupply
data UniqSM result
class Monad m => MonadUnique (m :: Type -> Type) where
- getUniqueSupplyM :: m UniqSupply
- getUniqueM :: m Unique
- getUniquesM :: m [Unique]
data Unique
class Uniquable a where
- getUnique :: a -> Unique
isKindLevel :: TypeOrKind -> Bool
isTypeLevel :: TypeOrKind -> Bool
mkIntWithInf :: Int -> IntWithInf
treatZeroAsInf :: Int -> IntWithInf
intGtLimit :: Int -> IntWithInf -> Bool
infinity :: IntWithInf
integralFractionalLit :: Bool -> Integer -> FractionalLit
negateFractionalLit :: FractionalLit -> FractionalLit
mkFractionalLit :: Real a => a -> FractionalLit
negateIntegralLit :: IntegralLit -> IntegralLit
mkIntegralLit :: Integral a => a -> IntegralLit
isEarlyActive :: Activation -> Bool
isAlwaysActive :: Activation -> Bool
isNeverActive :: Activation -> Bool
competesWith :: Activation -> Activation -> Bool
isActiveIn :: PhaseNum -> Activation -> Bool
isActive :: CompilerPhase -> Activation -> Bool
pprInlineDebug :: InlinePragma -> SDoc
pprInline :: InlinePragma -> SDoc
setInlinePragmaRuleMatchInfo :: InlinePragma -> RuleMatchInfo -> InlinePragma
setInlinePragmaActivation :: InlinePragma -> Activation -> InlinePragma
inlinePragmaRuleMatchInfo :: InlinePragma -> RuleMatchInfo
inlinePragmaActivation :: InlinePragma -> Activation
inlinePragmaSat :: InlinePragma -> Maybe Arity
isAnyInlinePragma :: InlinePragma -> Bool
isInlinablePragma :: InlinePragma -> Bool
isInlinePragma :: InlinePragma -> Bool
isDefaultInlinePragma :: InlinePragma -> Bool
dfunInlinePragma :: InlinePragma
inlinePragmaSpec :: InlinePragma -> InlineSpec
neverInlinePragma :: InlinePragma
alwaysInlinePragma :: InlinePragma
defaultInlinePragma :: InlinePragma
noUserInlineSpec :: InlineSpec -> Bool
isFunLike :: RuleMatchInfo -> Bool
isConLike :: RuleMatchInfo -> Bool
activeDuringFinal :: Activation
activeAfterInitial :: Activation
pprWithSourceText :: SourceText -> SDoc -> SDoc
failed :: SuccessFlag -> Bool
succeeded :: SuccessFlag -> Bool
successIf :: Bool -> SuccessFlag
zapFragileOcc :: OccInfo -> OccInfo
isOneOcc :: OccInfo -> Bool
isDeadOcc :: OccInfo -> Bool
isStrongLoopBreaker :: OccInfo -> Bool
isWeakLoopBreaker :: OccInfo -> Bool
weakLoopBreaker :: OccInfo
strongLoopBreaker :: OccInfo
isAlwaysTailCalled :: OccInfo -> Bool
zapOccTailCallInfo :: OccInfo -> OccInfo
tailCallInfo :: OccInfo -> TailCallInfo
notOneBranch :: OneBranch
oneBranch :: OneBranch
notInsideLam :: InsideLam
insideLam :: InsideLam
seqOccInfo :: OccInfo -> ()
isManyOccs :: OccInfo -> Bool
noOccInfo :: OccInfo
pprAlternative :: (a -> SDoc) -> a -> ConTag -> Arity -> SDoc
sumParens :: SDoc -> SDoc
tupleParens :: TupleSort -> SDoc -> SDoc
boxityTupleSort :: Boxity -> TupleSort
tupleSortBoxity :: TupleSort -> Boxity
maybeParen :: PprPrec -> PprPrec -> SDoc -> SDoc
appPrec :: PprPrec
opPrec :: PprPrec
funPrec :: PprPrec
sigPrec :: PprPrec
topPrec :: PprPrec
hasOverlappingFlag :: OverlapMode -> Bool
hasOverlappableFlag :: OverlapMode -> Bool
hasIncoherentFlag :: OverlapMode -> Bool
setOverlapModeMaybe :: OverlapFlag -> Maybe OverlapMode -> OverlapFlag
isGenerated :: Origin -> Bool
boolToRecFlag :: Bool -> RecFlag
isNonRec :: RecFlag -> Bool
isRec :: RecFlag -> Bool
isBoxed :: Boxity -> Bool
isTopLevel :: TopLevelFlag -> Bool
isNotTopLevel :: TopLevelFlag -> Bool
compareFixity :: Fixity -> Fixity -> (Bool, Bool)
funTyFixity :: Fixity
negateFixity :: Fixity
defaultFixity :: Fixity
minPrecedence :: Int
maxPrecedence :: Int
pprRuleName :: RuleName -> SDoc
pprWarningTxtForMsg :: WarningTxt -> SDoc
initialVersion :: Version
bumpVersion :: Version -> Version
isPromoted :: PromotionFlag -> Bool
unSwap :: SwapFlag -> (a -> a -> b) -> a -> a -> b
isSwapped :: SwapFlag -> Bool
flipSwap :: SwapFlag -> SwapFlag
bestOneShot :: OneShotInfo -> OneShotInfo -> OneShotInfo
worstOneShot :: OneShotInfo -> OneShotInfo -> OneShotInfo
hasNoOneShotInfo :: OneShotInfo -> Bool
isOneShotInfo :: OneShotInfo -> Bool
noOneShotInfo :: OneShotInfo
alignmentOf :: Int -> Alignment
mkAlignment :: Int -> Alignment
fIRST_TAG :: ConTag
pickLR :: LeftOrRight -> (a, a) -> a
data LeftOrRight
- = CLeft
- | CRight
type Arity = Int
type RepArity = Int
type JoinArity = Int
type ConTag = Int
type ConTagZ = Int
data Alignment
data OneShotInfo
- = NoOneShotInfo
- | OneShotLam
data SwapFlag
- = NotSwapped
- | IsSwapped
data PromotionFlag
- = NotPromoted
- | IsPromoted
data FunctionOrData
- = IsFunction
- | IsData
data StringLiteral = StringLiteral {
- sl_st :: SourceText
- sl_fs :: FastString
}
data WarningTxt
- = WarningTxt (Located SourceText) [Located StringLiteral]
- | DeprecatedTxt (Located SourceText) [Located StringLiteral]
type RuleName = FastString
data Fixity = Fixity SourceText Int FixityDirection
data FixityDirection
- = InfixL
- | InfixR
- | InfixN
data LexicalFixity
- = Prefix
- | Infix
data TopLevelFlag
- = TopLevel
- | NotTopLevel
data Boxity
- = Boxed
- | Unboxed
data RecFlag
- = Recursive
- | NonRecursive
data Origin
- = FromSource
- | Generated
data OverlapFlag = OverlapFlag {
- overlapMode :: OverlapMode
- isSafeOverlap :: Bool
}
data OverlapMode
- = NoOverlap SourceText
- | Overlappable SourceText
- | Overlapping SourceText
- | Overlaps SourceText
- | Incoherent SourceText
newtype PprPrec = PprPrec Int
data TupleSort
- = BoxedTuple
- | UnboxedTuple
- | ConstraintTuple
data EP a = EP {
- fromEP :: a
- toEP :: a
}
data OccInfo
- = ManyOccs {
  - occ_tail :: !TailCallInfo
  }
- | IAmDead
- | OneOcc {
  - occ_in_lam :: !InsideLam
  - occ_one_br :: !OneBranch
  - occ_int_cxt :: !InterestingCxt
  - occ_tail :: !TailCallInfo
  }
- | IAmALoopBreaker {
  - occ_rules_only :: !RulesOnly
  - occ_tail :: !TailCallInfo
  }
type InterestingCxt = Bool
type InsideLam = Bool
type OneBranch = Bool
data TailCallInfo
- = AlwaysTailCalled JoinArity
- | NoTailCallInfo
data DefMethSpec ty
- = VanillaDM
- | GenericDM ty
data SuccessFlag
- = Succeeded
- | Failed
data SourceText
- = SourceText String
- | NoSourceText
type PhaseNum = Int
data CompilerPhase
- = Phase PhaseNum
- | InitialPhase
data Activation
- = NeverActive
- | AlwaysActive
- | ActiveBefore SourceText PhaseNum
- | ActiveAfter SourceText PhaseNum
data RuleMatchInfo
- = ConLike
- | FunLike
data InlinePragma = InlinePragma {
- inl_src :: SourceText
- inl_inline :: InlineSpec
- inl_sat :: Maybe Arity
- inl_act :: Activation
- inl_rule :: RuleMatchInfo
}
data InlineSpec
- = Inline
- | Inlinable
- | NoInline
- | NoUserInline
data IntegralLit = IL {
- il_text :: SourceText
- il_neg :: Bool
- il_value :: Integer
}
data FractionalLit = FL {
- fl_text :: SourceText
- fl_neg :: Bool
- fl_value :: Rational
}
data IntWithInf
data SpliceExplicitFlag
- = ExplicitSplice
- | ImplicitSplice
data TypeOrKind
- = TypeLevel
- | KindLevel
vanillaIdInfo :: IdInfo
coVarDetails :: IdDetails
isCoVarDetails :: IdDetails -> Bool
pprIdDetails :: IdDetails -> SDoc
data IdInfo
data IdDetails
- = VanillaId
- | RecSelId {
  - sel_tycon :: RecSelParent
  - sel_naughty :: Bool
  }
- | DataConWorkId DataCon
- | DataConWrapId DataCon
- | ClassOpId Class
- | PrimOpId PrimOp
- | FCallId ForeignCall
- | TickBoxOpId TickBoxOp
- | DFunId Bool
- | CoVarId
- | JoinId JoinArity
unRealSrcSpan :: RealLocated a -> a
getRealSrcSpan :: RealLocated a -> RealSrcSpan
liftL :: (HasSrcSpan a, HasSrcSpan b, Monad m) => (SrcSpanLess a -> m (SrcSpanLess b)) -> a -> m b
onHasSrcSpan :: (HasSrcSpan a, HasSrcSpan b) => (SrcSpanLess a -> SrcSpanLess b) -> a -> b
cL :: HasSrcSpan a => SrcSpan -> SrcSpanLess a -> a
dL :: HasSrcSpan a => a -> Located (SrcSpanLess a)
isSubspanOf :: SrcSpan -> SrcSpan -> Bool
spans :: SrcSpan -> (Int, Int) -> Bool
leftmost_largest :: SrcSpan -> SrcSpan -> Ordering
leftmost_smallest :: SrcSpan -> SrcSpan -> Ordering
rightmost :: SrcSpan -> SrcSpan -> Ordering
cmpLocated :: (HasSrcSpan a, Ord (SrcSpanLess a)) => a -> a -> Ordering
eqLocated :: (HasSrcSpan a, Eq (SrcSpanLess a)) => a -> a -> Bool
addCLoc :: (HasSrcSpan a, HasSrcSpan b, HasSrcSpan c) => a -> b -> SrcSpanLess c -> c
combineLocs :: (HasSrcSpan a, HasSrcSpan b) => a -> b -> SrcSpan
mkGeneralLocated :: HasSrcSpan e => String -> SrcSpanLess e -> e
noLoc :: HasSrcSpan a => SrcSpanLess a -> a
getLoc :: HasSrcSpan a => a -> SrcSpan
unLoc :: HasSrcSpan a => a -> SrcSpanLess a
mapLoc :: (a -> b) -> GenLocated l a -> GenLocated l b
pprUserRealSpan :: Bool -> RealSrcSpan -> SDoc
srcSpanFileName_maybe :: SrcSpan -> Maybe FastString
realSrcSpanEnd :: RealSrcSpan -> RealSrcLoc
realSrcSpanStart :: RealSrcSpan -> RealSrcLoc
srcSpanEnd :: SrcSpan -> SrcLoc
srcSpanStart :: SrcSpan -> SrcLoc
srcSpanEndCol :: RealSrcSpan -> Int
srcSpanStartCol :: RealSrcSpan -> Int
srcSpanEndLine :: RealSrcSpan -> Int
srcSpanStartLine :: RealSrcSpan -> Int
containsSpan :: RealSrcSpan -> RealSrcSpan -> Bool
isOneLineSpan :: SrcSpan -> Bool
isGoodSrcSpan :: SrcSpan -> Bool
srcSpanFirstCharacter :: SrcSpan -> SrcSpan
combineSrcSpans :: SrcSpan -> SrcSpan -> SrcSpan
mkSrcSpan :: SrcLoc -> SrcLoc -> SrcSpan
mkRealSrcSpan :: RealSrcLoc -> RealSrcLoc -> RealSrcSpan
realSrcLocSpan :: RealSrcLoc -> RealSrcSpan
srcLocSpan :: SrcLoc -> SrcSpan
mkGeneralSrcSpan :: FastString -> SrcSpan
interactiveSrcSpan :: SrcSpan
wiredInSrcSpan :: SrcSpan
noSrcSpan :: SrcSpan
sortLocated :: HasSrcSpan a => [a] -> [a]
advanceSrcLoc :: RealSrcLoc -> Char -> RealSrcLoc
srcLocCol :: RealSrcLoc -> Int
srcLocLine :: RealSrcLoc -> Int
srcLocFile :: RealSrcLoc -> FastString
mkGeneralSrcLoc :: FastString -> SrcLoc
interactiveSrcLoc :: SrcLoc
generatedSrcLoc :: SrcLoc
noSrcLoc :: SrcLoc
mkRealSrcLoc :: FastString -> Int -> Int -> RealSrcLoc
mkSrcLoc :: FastString -> Int -> Int -> SrcLoc
pattern LL :: HasSrcSpan a => SrcSpan -> SrcSpanLess a -> a
data RealSrcLoc
data SrcLoc
- = RealSrcLoc !RealSrcLoc
- | UnhelpfulLoc FastString
data RealSrcSpan
data SrcSpan
- = RealSrcSpan !RealSrcSpan
- | UnhelpfulSpan !FastString
data GenLocated l e = L l e
type Located = GenLocated SrcSpan
type RealLocated = GenLocated RealSrcSpan
type family SrcSpanLess a
class HasSrcSpan a where
- composeSrcSpan :: Located (SrcSpanLess a) -> a
- decomposeSrcSpan :: a -> Located (SrcSpanLess a)
pprDebugAndThen :: DynFlags -> (String -> a) -> SDoc -> SDoc -> a
assertPprPanic :: HasCallStack => String -> Int -> SDoc -> a
pprSTrace :: HasCallStack => SDoc -> a -> a
pprTraceException :: ExceptionMonad m => String -> SDoc -> m a -> m a
pprTraceIt :: Outputable a => String -> a -> a
pprTraceWith :: String -> (a -> SDoc) -> a -> a
pprTraceM :: Applicative f => String -> SDoc -> f ()
pprTrace :: String -> SDoc -> a -> a
pprTraceDebug :: String -> SDoc -> a -> a
pprPgmError :: String -> SDoc -> a
pprSorry :: String -> SDoc -> a
pprPanic :: HasCallStack => String -> SDoc -> a
callStackDoc :: HasCallStack => SDoc
doOrDoes :: [a] -> SDoc
isOrAre :: [a] -> SDoc
plural :: [a] -> SDoc
speakNOf :: Int -> SDoc -> SDoc
speakN :: Int -> SDoc
speakNth :: Int -> SDoc
intWithCommas :: Integral a => a -> SDoc
quotedListWithNor :: [SDoc] -> SDoc
quotedListWithOr :: [SDoc] -> SDoc
pprQuotedList :: Outputable a => [a] -> SDoc
interpp'SP :: Outputable a => [a] -> SDoc
interppSP :: Outputable a => [a] -> SDoc
pprWithBars :: (a -> SDoc) -> [a] -> SDoc
pprWithCommas :: (a -> SDoc) -> [a] -> SDoc
pprFilePathString :: FilePath -> SDoc
pprFastFilePath :: FastString -> SDoc
pprInfixVar :: Bool -> SDoc -> SDoc
pprPrefixVar :: Bool -> SDoc -> SDoc
pprPrimWord64 :: Integer -> SDoc
pprPrimInt64 :: Integer -> SDoc
pprPrimWord :: Integer -> SDoc
pprPrimInt :: Integer -> SDoc
pprPrimChar :: Char -> SDoc
primWord64Suffix :: SDoc
primInt64Suffix :: SDoc
primWordSuffix :: SDoc
primDoubleSuffix :: SDoc
primIntSuffix :: SDoc
primFloatSuffix :: SDoc
primCharSuffix :: SDoc
pprHsBytes :: ByteString -> SDoc
pprHsString :: FastString -> SDoc
pprHsChar :: Char -> SDoc
keyword :: SDoc -> SDoc
coloured :: PprColour -> SDoc -> SDoc
ppUnless :: Bool -> SDoc -> SDoc
ppWhen :: Bool -> SDoc -> SDoc
punctuate :: SDoc -> [SDoc] -> [SDoc]
hangNotEmpty :: SDoc -> Int -> SDoc -> SDoc
hang :: SDoc -> Int -> SDoc -> SDoc
fcat :: [SDoc] -> SDoc
fsep :: [SDoc] -> SDoc
cat :: [SDoc] -> SDoc
sep :: [SDoc] -> SDoc
vcat :: [SDoc] -> SDoc
hsep :: [SDoc] -> SDoc
hcat :: [SDoc] -> SDoc
($+$) :: SDoc -> SDoc -> SDoc
($$) :: SDoc -> SDoc -> SDoc
(<+>) :: SDoc -> SDoc -> SDoc
(<>) :: SDoc -> SDoc -> SDoc
nest :: Int -> SDoc -> SDoc
unicodeSyntax :: SDoc -> SDoc -> SDoc
bullet :: SDoc
kindType :: SDoc
forAllLit :: SDoc
rbrace :: SDoc
lbrace :: SDoc
rbrack :: SDoc
lbrack :: SDoc
rparen :: SDoc
lparen :: SDoc
vbar :: SDoc
dot :: SDoc
underscore :: SDoc
space :: SDoc
equals :: SDoc
colon :: SDoc
comma :: SDoc
semi :: SDoc
larrowtt :: SDoc
arrowtt :: SDoc
larrowt :: SDoc
arrowt :: SDoc
darrow :: SDoc
larrow :: SDoc
arrow :: SDoc
dcolon :: SDoc
blankLine :: SDoc
quotes :: SDoc -> SDoc
cparen :: Bool -> SDoc -> SDoc
angleBrackets :: SDoc -> SDoc
doubleQuotes :: SDoc -> SDoc
quote :: SDoc -> SDoc
brackets :: SDoc -> SDoc
braces :: SDoc -> SDoc
parens :: SDoc -> SDoc
doublePrec :: Int -> Double -> SDoc
word :: Integer -> SDoc
rational :: Rational -> SDoc
double :: Double -> SDoc
float :: Float -> SDoc
integer :: Integer -> SDoc
int :: Int -> SDoc
ztext ::