| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
GHC
Contents
- Initialisation
- GHC Monad
- Flags and settings
- Targets
- Loading/compiling the program
- Inspecting the module structure of the program
- Inspecting modules
- Querying the environment
- Printing
- Interactive evaluation
- Abstract syntax elements
- Exceptions
- Token stream manipulations
- Pure interface to the parser
- API Annotations
- Miscellaneous
- defaultErrorHandler :: (ExceptionMonad m, MonadIO m) => FatalMessager -> FlushOut -> m a -> m a
- defaultCleanupHandler :: (ExceptionMonad m, MonadIO m) => DynFlags -> m a -> m a
- prettyPrintGhcErrors :: ExceptionMonad m => DynFlags -> m a -> m a
- data Ghc a
- data GhcT m a
- class (Functor m, MonadIO m, ExceptionMonad m, HasDynFlags m) => GhcMonad m where
- getSession :: m HscEnv
- setSession :: HscEnv -> m ()
- data HscEnv
- runGhc :: Maybe FilePath -> Ghc a -> IO a
- runGhcT :: (ExceptionMonad m, Functor m, MonadIO m) => Maybe FilePath -> GhcT m a -> m a
- initGhcMonad :: GhcMonad m => Maybe FilePath -> m ()
- gcatch :: (ExceptionMonad m, Exception e) => m a -> (e -> m a) -> m a
- gbracket :: ExceptionMonad m => m a -> (a -> m b) -> (a -> m c) -> m c
- gfinally :: ExceptionMonad m => m a -> m b -> m a
- printException :: GhcMonad m => SourceError -> m ()
- handleSourceError :: ExceptionMonad m => (SourceError -> m a) -> m a -> m a
- needsTemplateHaskell :: ModuleGraph -> Bool
- data DynFlags = DynFlags {
- ghcMode :: GhcMode
- ghcLink :: GhcLink
- hscTarget :: HscTarget
- settings :: Settings
- sigOf :: SigOf
- verbosity :: Int
- optLevel :: Int
- simplPhases :: Int
- maxSimplIterations :: Int
- ruleCheck :: Maybe String
- strictnessBefore :: [Int]
- parMakeCount :: Maybe Int
- enableTimeStats :: Bool
- ghcHeapSize :: Maybe Int
- maxRelevantBinds :: Maybe Int
- simplTickFactor :: Int
- specConstrThreshold :: Maybe Int
- specConstrCount :: Maybe Int
- specConstrRecursive :: Int
- liberateCaseThreshold :: Maybe Int
- floatLamArgs :: Maybe Int
- historySize :: Int
- cmdlineHcIncludes :: [String]
- importPaths :: [FilePath]
- mainModIs :: Module
- mainFunIs :: Maybe String
- ctxtStkDepth :: Int
- tyFunStkDepth :: Int
- thisPackage :: PackageKey
- ways :: [Way]
- buildTag :: String
- rtsBuildTag :: String
- splitInfo :: Maybe (String, Int)
- objectDir :: Maybe String
- dylibInstallName :: Maybe String
- hiDir :: Maybe String
- stubDir :: Maybe String
- dumpDir :: Maybe String
- objectSuf :: String
- hcSuf :: String
- hiSuf :: String
- canGenerateDynamicToo :: IORef Bool
- dynObjectSuf :: String
- dynHiSuf :: String
- dllSplitFile :: Maybe FilePath
- dllSplit :: Maybe [Set String]
- outputFile :: Maybe String
- dynOutputFile :: Maybe String
- outputHi :: Maybe String
- dynLibLoader :: DynLibLoader
- dumpPrefix :: Maybe FilePath
- dumpPrefixForce :: Maybe FilePath
- ldInputs :: [Option]
- includePaths :: [String]
- libraryPaths :: [String]
- frameworkPaths :: [String]
- cmdlineFrameworks :: [String]
- rtsOpts :: Maybe String
- rtsOptsEnabled :: RtsOptsEnabled
- hpcDir :: String
- pluginModNames :: [ModuleName]
- pluginModNameOpts :: [(ModuleName, String)]
- hooks :: Hooks
- depMakefile :: FilePath
- depIncludePkgDeps :: Bool
- depExcludeMods :: [ModuleName]
- depSuffixes :: [String]
- extraPkgConfs :: [PkgConfRef] -> [PkgConfRef]
- packageFlags :: [PackageFlag]
- packageEnv :: Maybe FilePath
- pkgDatabase :: Maybe [PackageConfig]
- pkgState :: PackageState
- filesToClean :: IORef [FilePath]
- dirsToClean :: IORef (Map FilePath FilePath)
- filesToNotIntermediateClean :: IORef [FilePath]
- nextTempSuffix :: IORef Int
- generatedDumps :: IORef (Set FilePath)
- dumpFlags :: IntSet
- generalFlags :: IntSet
- warningFlags :: IntSet
- language :: Maybe Language
- safeHaskell :: SafeHaskellMode
- safeInfer :: Bool
- safeInferred :: Bool
- thOnLoc :: SrcSpan
- newDerivOnLoc :: SrcSpan
- overlapInstLoc :: SrcSpan
- incoherentOnLoc :: SrcSpan
- pkgTrustOnLoc :: SrcSpan
- warnSafeOnLoc :: SrcSpan
- warnUnsafeOnLoc :: SrcSpan
- trustworthyOnLoc :: SrcSpan
- extensions :: [OnOff ExtensionFlag]
- extensionFlags :: IntSet
- ufCreationThreshold :: Int
- ufUseThreshold :: Int
- ufFunAppDiscount :: Int
- ufDictDiscount :: Int
- ufKeenessFactor :: Float
- ufDearOp :: Int
- maxWorkerArgs :: Int
- ghciHistSize :: Int
- log_action :: LogAction
- flushOut :: FlushOut
- flushErr :: FlushErr
- haddockOptions :: Maybe String
- ghciScripts :: [String]
- pprUserLength :: Int
- pprCols :: Int
- traceLevel :: Int
- useUnicode :: Bool
- profAuto :: ProfAuto
- interactivePrint :: Maybe String
- llvmVersion :: IORef Int
- nextWrapperNum :: IORef (ModuleEnv Int)
- sseVersion :: Maybe SseVersion
- avx :: Bool
- avx2 :: Bool
- avx512cd :: Bool
- avx512er :: Bool
- avx512f :: Bool
- avx512pf :: Bool
- rtldInfo :: IORef (Maybe LinkerInfo)
- rtccInfo :: IORef (Maybe CompilerInfo)
- maxInlineAllocSize :: Int
- maxInlineMemcpyInsns :: Int
- maxInlineMemsetInsns :: Int
- data GeneralFlag
- = Opt_DumpToFile
- | Opt_D_faststring_stats
- | Opt_D_dump_minimal_imports
- | Opt_DoCoreLinting
- | Opt_DoStgLinting
- | Opt_DoCmmLinting
- | Opt_DoAsmLinting
- | Opt_DoAnnotationLinting
- | Opt_NoLlvmMangler
- | Opt_WarnIsError
- | Opt_PrintExplicitForalls
- | Opt_PrintExplicitKinds
- | Opt_CallArity
- | Opt_Strictness
- | Opt_LateDmdAnal
- | Opt_KillAbsence
- | Opt_KillOneShot
- | Opt_FullLaziness
- | Opt_FloatIn
- | Opt_Specialise
- | Opt_SpecialiseAggressively
- | Opt_StaticArgumentTransformation
- | Opt_CSE
- | Opt_LiberateCase
- | Opt_SpecConstr
- | Opt_DoLambdaEtaExpansion
- | Opt_IgnoreAsserts
- | Opt_DoEtaReduction
- | Opt_CaseMerge
- | Opt_UnboxStrictFields
- | Opt_UnboxSmallStrictFields
- | Opt_DictsCheap
- | Opt_EnableRewriteRules
- | Opt_Vectorise
- | Opt_VectorisationAvoidance
- | Opt_RegsGraph
- | Opt_RegsIterative
- | Opt_PedanticBottoms
- | Opt_LlvmTBAA
- | Opt_LlvmPassVectorsInRegisters
- | Opt_IrrefutableTuples
- | Opt_CmmSink
- | Opt_CmmElimCommonBlocks
- | Opt_OmitYields
- | Opt_SimpleListLiterals
- | Opt_FunToThunk
- | Opt_DictsStrict
- | Opt_DmdTxDictSel
- | Opt_Loopification
- | Opt_IgnoreInterfacePragmas
- | Opt_OmitInterfacePragmas
- | Opt_ExposeAllUnfoldings
- | Opt_WriteInterface
- | Opt_AutoSccsOnIndividualCafs
- | Opt_ProfCountEntries
- | Opt_Pp
- | Opt_ForceRecomp
- | Opt_ExcessPrecision
- | Opt_EagerBlackHoling
- | Opt_NoHsMain
- | Opt_SplitObjs
- | Opt_StgStats
- | Opt_HideAllPackages
- | Opt_PrintBindResult
- | Opt_Haddock
- | Opt_HaddockOptions
- | Opt_Hpc_No_Auto
- | Opt_BreakOnException
- | Opt_BreakOnError
- | Opt_PrintEvldWithShow
- | Opt_PrintBindContents
- | Opt_GenManifest
- | Opt_EmbedManifest
- | Opt_EmitExternalCore
- | Opt_SharedImplib
- | Opt_BuildingCabalPackage
- | Opt_IgnoreDotGhci
- | Opt_GhciSandbox
- | Opt_GhciHistory
- | Opt_HelpfulErrors
- | Opt_DeferTypeErrors
- | Opt_DeferTypedHoles
- | Opt_Parallel
- | Opt_GranMacros
- | Opt_PIC
- | Opt_SccProfilingOn
- | Opt_Ticky
- | Opt_Ticky_Allocd
- | Opt_Ticky_LNE
- | Opt_Ticky_Dyn_Thunk
- | Opt_Static
- | Opt_RPath
- | Opt_RelativeDynlibPaths
- | Opt_Hpc
- | Opt_FlatCache
- | Opt_SimplPreInlining
- | Opt_ErrorSpans
- | Opt_PprCaseAsLet
- | Opt_PprShowTicks
- | Opt_SuppressCoercions
- | Opt_SuppressVarKinds
- | Opt_SuppressModulePrefixes
- | Opt_SuppressTypeApplications
- | Opt_SuppressIdInfo
- | Opt_SuppressTypeSignatures
- | Opt_SuppressUniques
- | Opt_AutoLinkPackages
- | Opt_ImplicitImportQualified
- | Opt_KeepHiDiffs
- | Opt_KeepHcFiles
- | Opt_KeepSFiles
- | Opt_KeepTmpFiles
- | Opt_KeepRawTokenStream
- | Opt_KeepLlvmFiles
- | Opt_BuildDynamicToo
- | Opt_DistrustAllPackages
- | Opt_PackageTrust
- | Opt_Debug
- data Severity
- data HscTarget
- gopt :: GeneralFlag -> DynFlags -> Bool
- data GhcMode
- data GhcLink
- defaultObjectTarget :: Platform -> HscTarget
- parseDynamicFlags :: MonadIO m => DynFlags -> [Located String] -> m (DynFlags, [Located String], [Located String])
- getSessionDynFlags :: GhcMonad m => m DynFlags
- setSessionDynFlags :: GhcMonad m => DynFlags -> m [PackageKey]
- getProgramDynFlags :: GhcMonad m => m DynFlags
- setProgramDynFlags :: GhcMonad m => DynFlags -> m [PackageKey]
- getInteractiveDynFlags :: GhcMonad m => m DynFlags
- setInteractiveDynFlags :: GhcMonad m => DynFlags -> m ()
- parseStaticFlags :: [Located String] -> IO ([Located String], [Located String])
- data Target = Target {}
- data TargetId
- data Phase
- setTargets :: GhcMonad m => [Target] -> m ()
- getTargets :: GhcMonad m => m [Target]
- addTarget :: GhcMonad m => Target -> m ()
- removeTarget :: GhcMonad m => TargetId -> m ()
- guessTarget :: GhcMonad m => String -> Maybe Phase -> m Target
- depanal :: GhcMonad m => [ModuleName] -> Bool -> m ModuleGraph
- load :: GhcMonad m => LoadHowMuch -> m SuccessFlag
- data LoadHowMuch
- data InteractiveImport
- data SuccessFlag
- succeeded :: SuccessFlag -> Bool
- failed :: SuccessFlag -> Bool
- defaultWarnErrLogger :: WarnErrLogger
- type WarnErrLogger = forall m. GhcMonad m => Maybe SourceError -> m ()
- workingDirectoryChanged :: GhcMonad m => m ()
- parseModule :: GhcMonad m => ModSummary -> m ParsedModule
- typecheckModule :: GhcMonad m => ParsedModule -> m TypecheckedModule
- desugarModule :: GhcMonad m => TypecheckedModule -> m DesugaredModule
- loadModule :: (TypecheckedMod mod, GhcMonad m) => mod -> m mod
- data ParsedModule = ParsedModule {}
- data TypecheckedModule = TypecheckedModule {}
- data DesugaredModule = DesugaredModule {}
- type TypecheckedSource = LHsBinds Id
- type ParsedSource = Located (HsModule RdrName)
- type RenamedSource = (HsGroup Name, [LImportDecl Name], Maybe [LIE Name], Maybe LHsDocString)
- class ParsedMod m => TypecheckedMod m where
- renamedSource :: m -> Maybe RenamedSource
- typecheckedSource :: m -> TypecheckedSource
- moduleInfo :: m -> ModuleInfo
- class ParsedMod m where
- parsedSource :: m -> ParsedSource
- coreModule :: DesugaredMod m => m -> ModGuts
- data CoreModule = CoreModule {
- cm_module :: !Module
- cm_types :: !TypeEnv
- cm_binds :: CoreProgram
- cm_safe :: SafeHaskellMode
- compileToCoreModule :: GhcMonad m => FilePath -> m CoreModule
- compileToCoreSimplified :: GhcMonad m => FilePath -> m CoreModule
- type ModuleGraph = [ModSummary]
- 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_srcimps :: [Located (ImportDecl RdrName)]
- ms_textual_imps :: [Located (ImportDecl RdrName)]
- ms_hspp_file :: FilePath
- ms_hspp_opts :: DynFlags
- ms_hspp_buf :: Maybe StringBuffer
- ms_mod_name :: ModSummary -> ModuleName
- data ModLocation = ModLocation {}
- getModSummary :: GhcMonad m => ModuleName -> m ModSummary
- getModuleGraph :: GhcMonad m => m ModuleGraph
- isLoaded :: GhcMonad m => ModuleName -> m Bool
- topSortModuleGraph :: Bool -> [ModSummary] -> Maybe ModuleName -> [SCC ModSummary]
- data ModuleInfo
- getModuleInfo :: GhcMonad m => Module -> m (Maybe ModuleInfo)
- modInfoTyThings :: ModuleInfo -> [TyThing]
- modInfoTopLevelScope :: ModuleInfo -> Maybe [Name]
- modInfoExports :: ModuleInfo -> [Name]
- modInfoInstances :: ModuleInfo -> [ClsInst]
- modInfoIsExportedName :: ModuleInfo -> Name -> Bool
- modInfoLookupName :: GhcMonad m => ModuleInfo -> Name -> m (Maybe TyThing)
- modInfoIface :: ModuleInfo -> Maybe ModIface
- modInfoSafe :: ModuleInfo -> SafeHaskellMode
- lookupGlobalName :: GhcMonad m => Name -> m (Maybe TyThing)
- findGlobalAnns :: (GhcMonad m, Typeable a) => ([Word8] -> a) -> AnnTarget Name -> m [a]
- mkPrintUnqualifiedForModule :: GhcMonad m => ModuleInfo -> m (Maybe PrintUnqualified)
- data ModIface = ModIface {
- mi_module :: !Module
- mi_sig_of :: !(Maybe Module)
- mi_iface_hash :: !Fingerprint
- mi_mod_hash :: !Fingerprint
- mi_flag_hash :: !Fingerprint
- mi_orphan :: !WhetherHasOrphans
- mi_finsts :: !WhetherHasFamInst
- mi_boot :: !IsBootInterface
- mi_deps :: Dependencies
- mi_usages :: [Usage]
- mi_exports :: ![IfaceExport]
- mi_exp_hash :: !Fingerprint
- mi_used_th :: !Bool
- mi_fixities :: [(OccName, Fixity)]
- mi_warns :: Warnings
- mi_anns :: [IfaceAnnotation]
- mi_decls :: [(Fingerprint, IfaceDecl)]
- mi_globals :: !(Maybe GlobalRdrEnv)
- mi_insts :: [IfaceClsInst]
- mi_fam_insts :: [IfaceFamInst]
- mi_rules :: [IfaceRule]
- mi_orphan_hash :: !Fingerprint
- mi_vect_info :: !IfaceVectInfo
- mi_warn_fn :: Name -> Maybe WarningTxt
- mi_fix_fn :: OccName -> Fixity
- mi_hash_fn :: OccName -> Maybe (OccName, Fingerprint)
- mi_hpc :: !AnyHpcUsage
- mi_trust :: !IfaceTrustInfo
- mi_trust_pkg :: !Bool
- data SafeHaskellMode
- data PrintUnqualified
- alwaysQualify :: PrintUnqualified
- getBindings :: GhcMonad m => m [TyThing]
- getInsts :: GhcMonad m => m ([ClsInst], [FamInst])
- getPrintUnqual :: GhcMonad m => m PrintUnqualified
- findModule :: GhcMonad m => ModuleName -> Maybe FastString -> m Module
- lookupModule :: GhcMonad m => ModuleName -> Maybe FastString -> m Module
- isModuleTrusted :: GhcMonad m => Module -> m Bool
- moduleTrustReqs :: GhcMonad m => Module -> m (Bool, [PackageKey])
- setContext :: GhcMonad m => [InteractiveImport] -> m ()
- getContext :: GhcMonad m => m [InteractiveImport]
- getNamesInScope :: GhcMonad m => m [Name]
- getRdrNamesInScope :: GhcMonad m => m [RdrName]
- getGRE :: GhcMonad m => m GlobalRdrEnv
- moduleIsInterpreted :: GhcMonad m => Module -> m Bool
- getInfo :: GhcMonad m => Bool -> Name -> m (Maybe (TyThing, Fixity, [ClsInst], [FamInst]))
- exprType :: GhcMonad m => String -> m Type
- typeKind :: GhcMonad m => Bool -> String -> m (Type, Kind)
- parseName :: GhcMonad m => String -> m [Name]
- data RunResult
- = RunOk [Name]
- | RunException SomeException
- | RunBreak ThreadId [Name] (Maybe BreakInfo)
- runStmt :: GhcMonad m => String -> SingleStep -> m RunResult
- runStmtWithLocation :: GhcMonad m => String -> Int -> String -> SingleStep -> m RunResult
- runDecls :: GhcMonad m => String -> m [Name]
- runDeclsWithLocation :: GhcMonad m => String -> Int -> String -> m [Name]
- runTcInteractive :: HscEnv -> TcRn a -> IO (Messages, Maybe a)
- parseImportDecl :: GhcMonad m => String -> m (ImportDecl RdrName)
- data SingleStep
- resume :: GhcMonad m => (SrcSpan -> Bool) -> SingleStep -> m RunResult
- data Resume
- data History
- getHistorySpan :: GhcMonad m => History -> m SrcSpan
- getHistoryModule :: History -> Module
- getResumeContext :: GhcMonad m => m [Resume]
- abandon :: GhcMonad m => m Bool
- abandonAll :: GhcMonad m => m Bool
- back :: GhcMonad m => m ([Name], Int, SrcSpan)
- forward :: GhcMonad m => m ([Name], Int, SrcSpan)
- showModule :: GhcMonad m => ModSummary -> m String
- isModuleInterpreted :: GhcMonad m => ModSummary -> m Bool
- compileExpr :: GhcMonad m => String -> m HValue
- data HValue
- dynCompileExpr :: GhcMonad m => String -> m Dynamic
- obtainTermFromId :: GhcMonad m => Int -> Bool -> Id -> m Term
- obtainTermFromVal :: GhcMonad m => Int -> Bool -> Type -> a -> m Term
- reconstructType :: HscEnv -> Int -> Id -> IO (Maybe Type)
- modInfoModBreaks :: ModuleInfo -> ModBreaks
- data ModBreaks = ModBreaks {
- modBreaks_flags :: BreakArray
- modBreaks_locs :: !(Array BreakIndex SrcSpan)
- modBreaks_vars :: !(Array BreakIndex [OccName])
- modBreaks_decls :: !(Array BreakIndex [String])
- type BreakIndex = Int
- data BreakInfo
- data BreakArray
- setBreakOn :: DynFlags -> BreakArray -> Int -> IO Bool
- setBreakOff :: DynFlags -> BreakArray -> Int -> IO Bool
- getBreak :: DynFlags -> BreakArray -> Int -> IO (Maybe Word)
- lookupName :: GhcMonad m => Name -> m (Maybe TyThing)
- setGHCiMonad :: GhcMonad m => String -> m ()
- data PackageKey
- data Module
- mkModule :: PackageKey -> ModuleName -> Module
- pprModule :: Module -> SDoc
- moduleName :: Module -> ModuleName
- modulePackageKey :: Module -> PackageKey
- data ModuleName
- mkModuleName :: String -> ModuleName
- moduleNameString :: ModuleName -> String
- data Name
- isExternalName :: Name -> Bool
- nameModule :: Name -> Module
- pprParenSymName :: NamedThing a => a -> SDoc
- nameSrcSpan :: Name -> SrcSpan
- class NamedThing a where
- getOccName :: a -> OccName
- getName :: a -> Name
- data RdrName
- type Id = Var
- idType :: Id -> Kind
- isImplicitId :: Id -> Bool
- isDeadBinder :: Id -> Bool
- isExportedId :: Var -> Bool
- isLocalId :: Var -> Bool
- isGlobalId :: Var -> Bool
- isRecordSelector :: Id -> Bool
- isPrimOpId :: Id -> Bool
- isFCallId :: Id -> Bool
- isClassOpId_maybe :: Id -> Maybe Class
- isDataConWorkId :: Id -> Bool
- idDataCon :: Id -> DataCon
- isBottomingId :: Id -> Bool
- isDictonaryId :: Id -> Bool
- recordSelectorFieldLabel :: Id -> (TyCon, FieldLabel)
- data TyCon
- tyConTyVars :: TyCon -> [TyVar]
- tyConDataCons :: TyCon -> [DataCon]
- tyConArity :: TyCon -> Arity
- isClassTyCon :: TyCon -> Bool
- isTypeSynonymTyCon :: TyCon -> Bool
- isTypeFamilyTyCon :: TyCon -> Bool
- isNewTyCon :: TyCon -> Bool
- isPrimTyCon :: TyCon -> Bool
- isFunTyCon :: TyCon -> Bool
- isFamilyTyCon :: TyCon -> Bool
- isOpenFamilyTyCon :: TyCon -> Bool
- isOpenTypeFamilyTyCon :: TyCon -> Bool
- tyConClass_maybe :: TyCon -> Maybe Class
- synTyConRhs_maybe :: TyCon -> Maybe Type
- synTyConDefn_maybe :: TyCon -> Maybe ([TyVar], Type)
- synTyConResKind :: TyCon -> Kind
- type TyVar = Var
- alphaTyVars :: [TyVar]
- data DataCon
- dataConSig :: DataCon -> ([TyVar], ThetaType, [Type], Type)
- dataConType :: DataCon -> Type
- dataConTyCon :: DataCon -> TyCon
- dataConFieldLabels :: DataCon -> [FieldLabel]
- dataConIsInfix :: DataCon -> Bool
- isVanillaDataCon :: DataCon -> Bool
- dataConUserType :: DataCon -> Type
- dataConSrcBangs :: DataCon -> [HsSrcBang]
- data StrictnessMark
- isMarkedStrict :: StrictnessMark -> Bool
- data Class
- classMethods :: Class -> [Id]
- classSCTheta :: Class -> [PredType]
- classTvsFds :: Class -> ([TyVar], [FunDep TyVar])
- classATs :: Class -> [TyCon]
- pprFundeps :: Outputable a => [FunDep a] -> SDoc
- data ClsInst
- instanceDFunId :: ClsInst -> DFunId
- pprInstance :: ClsInst -> SDoc
- pprInstanceHdr :: ClsInst -> SDoc
- pprFamInst :: FamInst -> SDoc
- data FamInst
- data Type
- splitForAllTys :: Type -> ([TyVar], Type)
- funResultTy :: Type -> Type
- pprParendType :: Type -> SDoc
- pprTypeApp :: TyCon -> [Type] -> SDoc
- type Kind = Type
- type PredType = Type
- type ThetaType = [PredType]
- pprForAll :: [TyVar] -> SDoc
- pprThetaArrowTy :: ThetaType -> SDoc
- data TyThing
- module HsSyn
- data FixityDirection
- defaultFixity :: Fixity
- maxPrecedence :: Int
- negateFixity :: Fixity
- compareFixity :: Fixity -> Fixity -> (Bool, Bool)
- data SrcLoc
- data RealSrcLoc
- mkSrcLoc :: FastString -> Int -> Int -> SrcLoc
- noSrcLoc :: SrcLoc
- srcLocFile :: RealSrcLoc -> FastString
- srcLocLine :: RealSrcLoc -> Int
- srcLocCol :: RealSrcLoc -> Int
- data SrcSpan
- data RealSrcSpan
- mkSrcSpan :: SrcLoc -> SrcLoc -> SrcSpan
- srcLocSpan :: SrcLoc -> SrcSpan
- isGoodSrcSpan :: SrcSpan -> Bool
- noSrcSpan :: SrcSpan
- srcSpanStart :: SrcSpan -> SrcLoc
- srcSpanEnd :: SrcSpan -> SrcLoc
- srcSpanFile :: RealSrcSpan -> FastString
- srcSpanStartLine :: RealSrcSpan -> Int
- srcSpanEndLine :: RealSrcSpan -> Int
- srcSpanStartCol :: RealSrcSpan -> Int
- srcSpanEndCol :: RealSrcSpan -> Int
- data GenLocated l e = L l e
- type Located e = GenLocated SrcSpan e
- noLoc :: e -> Located e
- mkGeneralLocated :: String -> e -> Located e
- getLoc :: GenLocated l e -> l
- unLoc :: GenLocated l e -> e
- eqLocated :: Eq a => Located a -> Located a -> Bool
- cmpLocated :: Ord a => Located a -> Located a -> Ordering
- combineLocs :: Located a -> Located b -> SrcSpan
- addCLoc :: Located a -> Located b -> c -> Located c
- leftmost_smallest :: SrcSpan -> SrcSpan -> Ordering
- leftmost_largest :: SrcSpan -> SrcSpan -> Ordering
- rightmost :: SrcSpan -> SrcSpan -> Ordering
- spans :: SrcSpan -> (Int, Int) -> Bool
- isSubspanOf :: SrcSpan -> SrcSpan -> Bool
- data GhcException
- showGhcException :: GhcException -> String -> String
- data Token
- getTokenStream :: GhcMonad m => Module -> m [Located Token]
- getRichTokenStream :: GhcMonad m => Module -> m [(Located Token, String)]
- showRichTokenStream :: [(Located Token, String)] -> String
- addSourceToTokens :: RealSrcLoc -> StringBuffer -> [Located Token] -> [(Located Token, String)]
- parser :: String -> DynFlags -> FilePath -> Either ErrorMessages (WarningMessages, Located (HsModule RdrName))
- type ApiAnns = (Map ApiAnnKey [SrcSpan], Map SrcSpan [Located AnnotationComment])
- data AnnKeywordId
- = AnnAs
- | AnnAt
- | AnnBang
- | AnnBackquote
- | AnnBy
- | AnnCase
- | AnnClass
- | AnnClose
- | AnnCloseC
- | AnnCloseP
- | AnnCloseS
- | AnnColon
- | AnnComma
- | AnnCommaTuple
- | AnnDarrow
- | AnnData
- | AnnDcolon
- | AnnDefault
- | AnnDeriving
- | AnnDo
- | AnnDot
- | AnnDotdot
- | AnnElse
- | AnnEqual
- | AnnExport
- | AnnFamily
- | AnnForall
- | AnnForeign
- | AnnFunId
- | AnnGroup
- | AnnHeader
- | AnnHiding
- | AnnIf
- | AnnImport
- | AnnIn
- | AnnInfix
- | AnnInstance
- | AnnLam
- | AnnLarrow
- | AnnLet
- | AnnMdo
- | AnnMinus
- | AnnModule
- | AnnNewtype
- | AnnName
- | AnnOf
- | AnnOpen
- | AnnOpenC
- | AnnOpenP
- | AnnOpenPE
- | AnnOpenPTE
- | AnnOpenS
- | AnnPackageName
- | AnnPattern
- | AnnProc
- | AnnQualified
- | AnnRarrow
- | AnnRec
- | AnnRole
- | AnnSafe
- | AnnSemi
- | AnnSimpleQuote
- | AnnStatic
- | AnnThen
- | AnnThIdSplice
- | AnnThIdTySplice
- | AnnThTyQuote
- | AnnTilde
- | AnnTildehsh
- | AnnType
- | AnnUnit
- | AnnUsing
- | AnnVal
- | AnnValStr
- | AnnVbar
- | AnnWhere
- | Annlarrowtail
- | Annrarrowtail
- | AnnLarrowtail
- | AnnRarrowtail
- | AnnEofPos
- data AnnotationComment
- getAnnotation :: ApiAnns -> SrcSpan -> AnnKeywordId -> [SrcSpan]
- getAndRemoveAnnotation :: ApiAnns -> SrcSpan -> AnnKeywordId -> ([SrcSpan], ApiAnns)
- getAnnotationComments :: ApiAnns -> SrcSpan -> [Located AnnotationComment]
- getAndRemoveAnnotationComments :: ApiAnns -> SrcSpan -> ([Located AnnotationComment], ApiAnns)
- cyclicModuleErr :: [ModSummary] -> SDoc
Initialisation
defaultErrorHandler :: (ExceptionMonad m, MonadIO m) => FatalMessager -> FlushOut -> m a -> m a
Install some default exception handlers and run the inner computation. Unless you want to handle exceptions yourself, you should wrap this around the top level of your program. The default handlers output the error message(s) to stderr and exit cleanly.
defaultCleanupHandler :: (ExceptionMonad m, MonadIO m) => DynFlags -> m a -> m a
Install a default cleanup handler to remove temporary files deposited by
a GHC run. This is separate from defaultErrorHandler, because you might
want to override the error handling, but still get the ordinary cleanup
behaviour.
prettyPrintGhcErrors :: ExceptionMonad m => DynFlags -> m a -> m a
GHC Monad
data Ghc a
data GhcT m a
A monad transformer to add GHC specific features to another monad.
Note that the wrapped monad must support IO and handling of exceptions.
Instances
| Monad m => Monad (GhcT m) | |
| Functor m => Functor (GhcT m) | |
| Applicative m => Applicative (GhcT m) | |
| MonadIO m => MonadIO (GhcT m) | |
| ExceptionMonad m => ExceptionMonad (GhcT m) | |
| (Functor m, ExceptionMonad m, MonadIO m) => HasDynFlags (GhcT m) | |
| (Functor m, ExceptionMonad m, MonadIO m) => GhcMonad (GhcT m) |
class (Functor m, MonadIO m, ExceptionMonad m, HasDynFlags m) => GhcMonad m where
A monad that has all the features needed by GHC API calls.
In short, a GHC monad
- allows embedding of IO actions,
- can log warnings,
- allows handling of (extensible) exceptions, and
- maintains a current session.
If you do not use Ghc or GhcT, make sure to call initGhcMonad
before any call to the GHC API functions can occur.
data HscEnv
Hscenv is like Session, except that some of the fields are immutable.
An HscEnv is used to compile a single module from plain Haskell source
code (after preprocessing) to either C, assembly or C--. Things like
the module graph don't change during a single compilation.
Historical note: "hsc" used to be the name of the compiler binary, when there was a separate driver and compiler. To compile a single module, the driver would invoke hsc on the source code... so nowadays we think of hsc as the layer of the compiler that deals with compiling a single module.
Instances
Arguments
| :: Maybe FilePath | See argument to |
| -> Ghc a | The action to perform. |
| -> IO a |
Run function for the Ghc monad.
It initialises the GHC session and warnings via initGhcMonad. Each call
to this function will create a new session which should not be shared among
several threads.
Any errors not handled inside the Ghc action are propagated as IO
exceptions.
Arguments
| :: (ExceptionMonad m, Functor m, MonadIO m) | |
| => Maybe FilePath | See argument to |
| -> GhcT m a | The action to perform. |
| -> m a |
Run function for GhcT monad transformer.
It initialises the GHC session and warnings via initGhcMonad. Each call
to this function will create a new session which should not be shared among
several threads.
initGhcMonad :: GhcMonad m => Maybe FilePath -> m ()
Initialise a GHC session.
If you implement a custom GhcMonad you must call this function in the
monad run function. It will initialise the session variable and clear all
warnings.
The first argument should point to the directory where GHC's library files
reside. More precisely, this should be the output of ghc --print-libdir
of the version of GHC the module using this API is compiled with. For
portability, you should use the ghc-paths package, available at
http://hackage.haskell.org/package/ghc-paths.
gcatch :: (ExceptionMonad m, Exception e) => m a -> (e -> m a) -> m a
gbracket :: ExceptionMonad m => m a -> (a -> m b) -> (a -> m c) -> m c
gfinally :: ExceptionMonad m => m a -> m b -> m a
printException :: GhcMonad m => SourceError -> m ()
Print the error message and all warnings. Useful inside exception handlers. Clears warnings after printing.
Arguments
| :: ExceptionMonad m | |
| => (SourceError -> m a) | exception handler |
| -> m a | action to perform |
| -> m a |
Perform the given action and call the exception handler if the action
throws a SourceError. See SourceError for more information.
Flags and settings
data DynFlags
Contains not only a collection of GeneralFlags but also a plethora of
information relating to the compilation of a single file or GHC session
Constructors
data GeneralFlag
Enumerates the simple on-or-off dynamic flags
Constructors
Instances
data Severity
Constructors
| SevOutput | |
| SevDump | |
| SevInteractive | |
| SevInfo | |
| SevWarning | |
| SevError | |
| SevFatal |
data HscTarget
The target code type of the compilation (if any).
Whenever you change the target, also make sure to set ghcLink to
something sensible.
HscNothing can be used to avoid generating any output, however, note
that:
- If a program uses Template Haskell the typechecker may try to run code
from an imported module. This will fail if no code has been generated
for this module. You can use
needsTemplateHaskellto detect whether this might be the case and choose to either switch to a different target or avoid typechecking such modules. (The latter may be preferable for security reasons.)
Constructors
| HscC | Generate C code. |
| HscAsm | Generate assembly using the native code generator. |
| HscLlvm | Generate assembly using the llvm code generator. |
| HscInterpreted | Generate bytecode. (Requires |
| HscNothing | Don't generate any code. See notes above. |
gopt :: GeneralFlag -> DynFlags -> Bool
Test whether a GeneralFlag is set
data GhcMode
The GhcMode tells us whether we're doing multi-module
compilation (controlled via the GHC API) or one-shot
(single-module) compilation. This makes a difference primarily to
the Finder: in one-shot mode we look for interface files for
imported modules, but in multi-module mode we look for source files
in order to check whether they need to be recompiled.
Constructors
| CompManager |
|
| OneShot | ghc -c Foo.hs |
| MkDepend |
|
Instances
data GhcLink
What to do in the link step, if there is one.
Constructors
| NoLink | Don't link at all |
| LinkBinary | Link object code into a binary |
| LinkInMemory | Use the in-memory dynamic linker (works for both bytecode and object code). |
| LinkDynLib | Link objects into a dynamic lib (DLL on Windows, DSO on ELF platforms) |
| LinkStaticLib | Link objects into a static lib |
defaultObjectTarget :: Platform -> HscTarget
The HscTarget value corresponding to the default way to create
object files on the current platform.
parseDynamicFlags :: MonadIO m => DynFlags -> [Located String] -> m (DynFlags, [Located String], [Located String])
getSessionDynFlags :: GhcMonad m => m DynFlags
Grabs the DynFlags from the Session
setSessionDynFlags :: GhcMonad m => DynFlags -> m [PackageKey]
Updates both the interactive and program DynFlags in a Session. This also reads the package database (unless it has already been read), and prepares the compilers knowledge about packages. It can be called again to load new packages: just add new package flags to (packageFlags dflags).
Returns a list of new packages that may need to be linked in using
the dynamic linker (see linkPackages) as a result of new package
flags. If you are not doing linking or doing static linking, you
can ignore the list of packages returned.
getProgramDynFlags :: GhcMonad m => m DynFlags
Returns the program DynFlags.
setProgramDynFlags :: GhcMonad m => DynFlags -> m [PackageKey]
Sets the program DynFlags.
getInteractiveDynFlags :: GhcMonad m => m DynFlags
Get the DynFlags used to evaluate interactive expressions.
setInteractiveDynFlags :: GhcMonad m => DynFlags -> m ()
Set the DynFlags used to evaluate interactive expressions.
Note: this cannot be used for changes to packages. Use
setSessionDynFlags, or setProgramDynFlags and then copy the
pkgState into the interactive DynFlags.
parseStaticFlags :: [Located String] -> IO ([Located String], [Located String])
Parses GHC's static flags from a list of command line arguments.
These flags are static in the sense that they can be set only once and they are global, meaning that they affect every instance of GHC running; multiple GHC threads will use the same flags.
This function must be called before any session is started, i.e., before
the first call to withGhc.
Static flags are more of a hack and are static for more or less historical reasons. In the long run, most static flags should eventually become dynamic flags.
XXX: can we add an auto-generated list of static flags here?
Targets
data Target
A compilation target.
A target may be supplied with the actual text of the module. If so, use this instead of the file contents (this is for use in an IDE where the file hasn't been saved by the user yet).
Constructors
| Target | |
Fields
| |
Instances
data TargetId
Constructors
| TargetModule ModuleName | A module name: search for the file |
| TargetFile FilePath (Maybe Phase) | A filename: preprocess & parse it to find the module name. If specified, the Phase indicates how to compile this file (which phase to start from). Nothing indicates the starting phase should be determined from the suffix of the filename. |
Instances
setTargets :: GhcMonad m => [Target] -> m ()
Sets the targets for this session. Each target may be a module name
or a filename. The targets correspond to the set of root modules for
the program/library. Unloading the current program is achieved by
setting the current set of targets to be empty, followed by load.
getTargets :: GhcMonad m => m [Target]
Returns the current set of targets
removeTarget :: GhcMonad m => TargetId -> m ()
Remove a target
guessTarget :: GhcMonad m => String -> Maybe Phase -> m Target
Attempts to guess what Target a string refers to. This function
implements the --make/GHCi command-line syntax for filenames:
- if the string looks like a Haskell source filename, then interpret it as such
- if adding a .hs or .lhs suffix yields the name of an existing file, then use that
- otherwise interpret the string as a module name
Loading/compiling the program
Arguments
| :: GhcMonad m | |
| => [ModuleName] | excluded modules |
| -> Bool | allow duplicate roots |
| -> m ModuleGraph |
Perform a dependency analysis starting from the current targets and update the session with the new module graph.
Dependency analysis entails parsing the import directives and may
therefore require running certain preprocessors.
Note that each ModSummary in the module graph caches its DynFlags.
These DynFlags are determined by the current session DynFlags and the
OPTIONS and LANGUAGE pragmas of the parsed module. Thus if you want to
changes to the DynFlags to take effect you need to call this function
again.
load :: GhcMonad m => LoadHowMuch -> m SuccessFlag
Try to load the program. See LoadHowMuch for the different modes.
This function implements the core of GHC's --make mode. It preprocesses,
compiles and loads the specified modules, avoiding re-compilation wherever
possible. Depending on the target (see hscTarget) compilating
and loading may result in files being created on disk.
Calls the reportModuleCompilationResult callback after each compiling
each module, whether successful or not.
Throw a SourceError if errors are encountered before the actual
compilation starts (e.g., during dependency analysis). All other errors
are reported using the callback.
data LoadHowMuch
Describes which modules of the module graph need to be loaded.
Constructors
| LoadAllTargets | Load all targets and its dependencies. |
| LoadUpTo ModuleName | Load only the given module and its dependencies. |
| LoadDependenciesOf ModuleName | Load only the dependencies of the given module, but not the module itself. |
data InteractiveImport
Constructors
| IIDecl (ImportDecl RdrName) | Bring the exports of a particular module (filtered by an import decl) into scope |
| IIModule ModuleName | Bring into scope the entire top-level envt of of this module, including the things imported into it. |
Instances
succeeded :: SuccessFlag -> Bool
failed :: SuccessFlag -> Bool
type WarnErrLogger = forall m. GhcMonad m => Maybe SourceError -> m ()
A function called to log warnings and errors.
workingDirectoryChanged :: GhcMonad m => m ()
Inform GHC that the working directory has changed. GHC will flush its cache of module locations, since it may no longer be valid.
Note: Before changing the working directory make sure all threads running in the same session have stopped. If you change the working directory, you should also unload the current program (set targets to empty, followed by load).
parseModule :: GhcMonad m => ModSummary -> m ParsedModule
Parse a module.
Throws a SourceError on parse error.
typecheckModule :: GhcMonad m => ParsedModule -> m TypecheckedModule
Typecheck and rename a parsed module.
Throws a SourceError if either fails.
desugarModule :: GhcMonad m => TypecheckedModule -> m DesugaredModule
Desugar a typechecked module.
loadModule :: (TypecheckedMod mod, GhcMonad m) => mod -> m mod
Load a module. Input doesn't need to be desugared.
A module must be loaded before dependent modules can be typechecked. This
always includes generating a ModIface and, depending on the
hscTarget, may also include code generation.
This function will always cause recompilation and will always overwrite previous compilation results (potentially files on disk).
data TypecheckedModule
The result of successful typechecking. It also contains the parser result.
Constructors
| TypecheckedModule | |
data DesugaredModule
The result of successful desugaring (i.e., translation to core). Also contains all the information of a typechecked module.
Constructors
| DesugaredModule | |
Fields | |
type TypecheckedSource = LHsBinds Id
type ParsedSource = Located (HsModule RdrName)
type RenamedSource = (HsGroup Name, [LImportDecl Name], Maybe [LIE Name], Maybe LHsDocString)
class ParsedMod m => TypecheckedMod m where
Minimal complete definition
renamedSource, typecheckedSource, moduleInfo, tm_internals
Methods
renamedSource :: m -> Maybe RenamedSource
typecheckedSource :: m -> TypecheckedSource
moduleInfo :: m -> ModuleInfo
class ParsedMod m where
Minimal complete definition
modSummary, parsedSource
Methods
parsedSource :: m -> ParsedSource
coreModule :: DesugaredMod m => m -> ModGuts
Compiling to Core
data CoreModule
A CoreModule consists of just the fields of a ModGuts that are needed for
the compileToCoreModule interface.
Constructors
| CoreModule | |
Fields
| |
Instances
compileToCoreModule :: GhcMonad m => FilePath -> m CoreModule
This is the way to get access to the Core bindings corresponding
to a module. compileToCore parses, typechecks, and
desugars the module, then returns the resulting Core module (consisting of
the module name, type declarations, and function declarations) if
successful.
compileToCoreSimplified :: GhcMonad m => FilePath -> m CoreModule
Like compileToCoreModule, but invokes the simplifier, so as to return simplified and tidied Core.
Inspecting the module structure of the program
type ModuleGraph = [ModSummary]
A ModuleGraph contains all the nodes from the home package (only). There will be a node for each source module, plus a node for each hi-boot module.
The graph is not necessarily stored in topologically-sorted order. Use
topSortModuleGraph and flattenSCC to achieve this.
data ModSummary
A single node in a ModuleGraph. The nodes of the module graph
are one of:
- A regular Haskell source module
- A hi-boot source module
- An external-core source module
Constructors
| ModSummary | |
Fields
| |
Instances
ms_mod_name :: ModSummary -> ModuleName
data ModLocation
Where a module lives on the file system: the actual locations of the .hs, .hi and .o files, if we have them
Constructors
| ModLocation | |
Fields
| |
Instances
getModSummary :: GhcMonad m => ModuleName -> m ModSummary
Return the ModSummary of a module with the given name.
The module must be part of the module graph (see hsc_mod_graph and
ModuleGraph). If this is not the case, this function will throw a
GhcApiError.
This function ignores boot modules and requires that there is only one non-boot module with the given name.
getModuleGraph :: GhcMonad m => m ModuleGraph
Get the module dependency graph.
isLoaded :: GhcMonad m => ModuleName -> m Bool
Return True == module is loaded.
Arguments
| :: Bool | Drop hi-boot nodes? (see below) |
| -> [ModSummary] | |
| -> Maybe ModuleName | Root module name. If |
| -> [SCC ModSummary] |
Topological sort of the module graph
Calculate SCCs of the module graph, possibly dropping the hi-boot nodes The resulting list of strongly-connected-components is in topologically sorted order, starting with the module(s) at the bottom of the dependency graph (ie compile them first) and ending with the ones at the top.
Drop hi-boot nodes (first boolean arg)?
False: treat the hi-boot summaries as nodes of the graph, so the graph must be acyclicTrue: eliminate the hi-boot nodes, and instead pretend the a source-import of Foo is an import of Foo The resulting graph has no hi-boot nodes, but can be cyclic
Inspecting modules
data ModuleInfo
Container for information about a Module.
getModuleInfo :: GhcMonad m => Module -> m (Maybe ModuleInfo)
Request information about a loaded Module
modInfoTyThings :: ModuleInfo -> [TyThing]
The list of top-level entities defined in a module
modInfoTopLevelScope :: ModuleInfo -> Maybe [Name]
modInfoExports :: ModuleInfo -> [Name]
modInfoInstances :: ModuleInfo -> [ClsInst]
Returns the instances defined by the specified module. Warning: currently unimplemented for package modules.
modInfoIsExportedName :: ModuleInfo -> Name -> Bool
modInfoLookupName :: GhcMonad m => ModuleInfo -> Name -> m (Maybe TyThing)
modInfoIface :: ModuleInfo -> Maybe ModIface
modInfoSafe :: ModuleInfo -> SafeHaskellMode
Retrieve module safe haskell mode
lookupGlobalName :: GhcMonad m => Name -> m (Maybe TyThing)
Looks up a global name: that is, any top-level name in any
visible module. Unlike lookupName, lookupGlobalName does not use
the interactive context, and therefore does not require a preceding
setContext.
mkPrintUnqualifiedForModule :: GhcMonad m => ModuleInfo -> m (Maybe PrintUnqualified)
data ModIface
A ModIface plus a ModDetails summarises everything we know
about a compiled module. The ModIface is the stuff *before* linking,
and can be written out to an interface file. The 'ModDetails is after
linking and can be completely recovered from just the ModIface.
When we read an interface file, we also construct a ModIface from it,
except that we explicitly make the mi_decls and a few other fields empty;
as when reading we consolidate the declarations etc. into a number of indexed
maps and environments in the ExternalPackageState.
Constructors
| ModIface | |
Fields
| |
data SafeHaskellMode
The various Safe Haskell modes
Constructors
| Sf_None | |
| Sf_Unsafe | |
| Sf_Trustworthy | |
| Sf_Safe |
Querying the environment
Printing
data PrintUnqualified
When printing code that contains original names, we need to map the
original names back to something the user understands. This is the
purpose of the triple of functions that gets passed around
when rendering SDoc.
Interactive evaluation
getBindings :: GhcMonad m => m [TyThing]
Return the bindings for the current interactive session.
getInsts :: GhcMonad m => m ([ClsInst], [FamInst])
Return the instances for the current interactive session.
getPrintUnqual :: GhcMonad m => m PrintUnqualified
findModule :: GhcMonad m => ModuleName -> Maybe FastString -> m Module
Takes a ModuleName and possibly a PackageKey, and consults the
filesystem and package database to find the corresponding Module,
using the algorithm that is used for an import declaration.
lookupModule :: GhcMonad m => ModuleName -> Maybe FastString -> m Module
Like findModule, but differs slightly when the module refers to
a source file, and the file has not been loaded via load. In
this case, findModule will throw an error (module not loaded),
but lookupModule will check to see whether the module can also be
found in a package, and if so, that package Module will be
returned. If not, the usual module-not-found error will be thrown.
isModuleTrusted :: GhcMonad m => Module -> m Bool
Check that a module is safe to import (according to Safe Haskell).
We return True to indicate the import is safe and False otherwise although in the False case an error may be thrown first.
moduleTrustReqs :: GhcMonad m => Module -> m (Bool, [PackageKey])
Return if a module is trusted and the pkgs it depends on to be trusted.
setContext :: GhcMonad m => [InteractiveImport] -> m ()
Set the interactive evaluation context.
(setContext imports) sets the ic_imports field (which in turn
determines what is in scope at the prompt) to imports, and
constructs the ic_rn_glb_env environment to reflect it.
We retain in scope all the things defined at the prompt, and kept in ic_tythings. (Indeed, they shadow stuff from ic_imports.)
getContext :: GhcMonad m => m [InteractiveImport]
Get the interactive evaluation context, consisting of a pair of the set of modules from which we take the full top-level scope, and the set of modules from which we take just the exports respectively.
getNamesInScope :: GhcMonad m => m [Name]
Returns all names in scope in the current interactive context
getRdrNamesInScope :: GhcMonad m => m [RdrName]
getGRE :: GhcMonad m => m GlobalRdrEnv
get the GlobalRdrEnv for a session
moduleIsInterpreted :: GhcMonad m => Module -> m Bool
Returns True if the specified module is interpreted, and hence has
its full top-level scope available.
getInfo :: GhcMonad m => Bool -> Name -> m (Maybe (TyThing, Fixity, [ClsInst], [FamInst]))
Looks up an identifier in the current interactive context (for :info) Filter the instances by the ones whose tycons (or clases resp) are in scope (qualified or otherwise). Otherwise we list a whole lot too many! The exact choice of which ones to show, and which to hide, is a judgement call. (see Trac #1581)
exprType :: GhcMonad m => String -> m Type
Get the type of an expression Returns its most general type
parseName :: GhcMonad m => String -> m [Name]
Parses a string as an identifier, and returns the list of Names that
the identifier can refer to in the current interactive context.
data RunResult
Constructors
| RunOk [Name] | names bound by this evaluation |
| RunException SomeException | statement raised an exception |
| RunBreak ThreadId [Name] (Maybe BreakInfo) |
runStmt :: GhcMonad m => String -> SingleStep -> m RunResult
Run a statement in the current interactive context. Statement may bind multple values.
runStmtWithLocation :: GhcMonad m => String -> Int -> String -> SingleStep -> m RunResult
Run a statement in the current interactive context. Passing debug information Statement may bind multple values.
parseImportDecl :: GhcMonad m => String -> m (ImportDecl RdrName)
data SingleStep
Constructors
| RunToCompletion | |
| SingleStep | |
| RunAndLogSteps |
data Resume
data History
getHistorySpan :: GhcMonad m => History -> m SrcSpan
getHistoryModule :: History -> Module
getResumeContext :: GhcMonad m => m [Resume]
abandonAll :: GhcMonad m => m Bool
showModule :: GhcMonad m => ModSummary -> m String
isModuleInterpreted :: GhcMonad m => ModSummary -> m Bool
compileExpr :: GhcMonad m => String -> m HValue
data HValue
dynCompileExpr :: GhcMonad m => String -> m Dynamic
data ModBreaks
All the information about the breakpoints for a given module
Constructors
| ModBreaks | |
Fields
| |
type BreakIndex = Int
Breakpoint index
data BreakInfo
Instances
data BreakArray
setBreakOn :: DynFlags -> BreakArray -> Int -> IO Bool
setBreakOff :: DynFlags -> BreakArray -> Int -> IO Bool
lookupName :: GhcMonad m => Name -> m (Maybe TyThing)
EXPERIMENTAL
setGHCiMonad :: GhcMonad m => String -> m ()
Warning: This is experimental! Don't use.
EXPERIMENTAL: DO NOT USE.
Set the monad GHCi lifts user statements into.
Checks that a type (in string form) is an instance of the
GHC.GHCi.GHCiSandboxIO type class. Sets it to be the GHCi monad if it is,
throws an error otherwise.
Abstract syntax elements
Packages
data PackageKey
A string which uniquely identifies a package. For wired-in packages, it is just the package name, but for user compiled packages, it is a hash. ToDo: when the key is a hash, we can do more clever things than store the hex representation and hash-cons those strings.
Modules
data Module
A Module is a pair of a PackageKey and a ModuleName.
mkModule :: PackageKey -> ModuleName -> Module
moduleName :: Module -> ModuleName
modulePackageKey :: Module -> PackageKey
data ModuleName
A ModuleName is essentially a simple string, e.g. Data.List.
mkModuleName :: String -> ModuleName
moduleNameString :: ModuleName -> String
Names
data Name
A unique, unambigious name for something, containing information about where that thing originated.
Instances
| Eq Name | |
| Data Name | |
| Ord Name | |
| OutputableBndr Name | |
| Outputable Name | |
| Uniquable Name | |
| Binary Name | |
| HasOccName Name | |
| NamedThing Name | |
| type PostRn Name ty = ty | |
| type PostTc Name ty = PlaceHolder |
isExternalName :: Name -> Bool
nameModule :: Name -> Module
pprParenSymName :: NamedThing a => a -> SDoc
print a NamedThing, adding parentheses if the name is an operator.
nameSrcSpan :: Name -> SrcSpan
class NamedThing a where
A class allowing convenient access to the Name of various datatypes
Minimal complete definition
data RdrName
Do not use the data constructors of RdrName directly: prefer the family
of functions that creates them, such as mkRdrUnqual
- Note: A Located RdrName will only have API Annotations if it is a compound one, e.g.
`bar` ( ~ )
AnnKeywordId:AnnType,AnnOpen'('or'['or'[:',AnnClose')'or']'or':]',,AnnBackquote'`',AnnVal,AnnTildehsh,AnnTilde,
Constructors
| Unqual OccName | Used for ordinary, unqualified occurrences, e.g. |
| Qual ModuleName OccName | A qualified name written by the user in
source code. The module isn't necessarily
the module where the thing is defined;
just the one from which it is imported.
Examples are |
Instances
| Eq RdrName | |
| Data RdrName | |
| Ord RdrName | |
| OutputableBndr RdrName | |
| Outputable RdrName | |
| HasOccName RdrName | |
| type PostRn RdrName ty = PlaceHolder | |
| type PostTc RdrName ty = PlaceHolder |
Identifiers
isImplicitId :: Id -> Bool
isImplicitId tells whether an Ids info is implied by other
declarations, so we don't need to put its signature in an interface
file, even if it's mentioned in some other interface unfolding.
isDeadBinder :: Id -> Bool
isExportedId :: Var -> Bool
isExportedIdVar means "don't throw this away"
isGlobalId :: Var -> Bool
isRecordSelector :: Id -> Bool
isPrimOpId :: Id -> Bool
isClassOpId_maybe :: Id -> Maybe Class
isDataConWorkId :: Id -> Bool
Get from either the worker or the wrapper Id to the DataCon. Currently used only in the desugarer.
INVARIANT: idDataCon (dataConWrapId d) = d: remember, dataConWrapId can return either the wrapper or the worker
isBottomingId :: Id -> Bool
Returns true if an application to n args would diverge
isDictonaryId :: Id -> Bool
recordSelectorFieldLabel :: Id -> (TyCon, FieldLabel)
Type constructors
data TyCon
TyCons represent type constructors. Type constructors are introduced by things such as:
1) Data declarations: data Foo = ... creates the Foo type constructor of
kind *
2) Type synonyms: type Foo = ... creates the Foo type constructor
3) Newtypes: newtype Foo a = MkFoo ... creates the Foo type constructor
of kind * -> *
4) Class declarations: class Foo where creates the Foo type constructor
of kind *
This data type also encodes a number of primitive, built in type constructors such as those for function and tuple types.
tyConTyVars :: TyCon -> [TyVar]
The kind and type variables used in the type constructor. Invariant: length tyvars = arity Precisely, this list scopes over:
- The
algTcStupidTheta - The cached types in algTyConRhs.NewTyCon
- The family instance types if present
Note that it does not scope over the data constructors.
tyConDataCons :: TyCon -> [DataCon]
As tyConDataCons_maybe, but returns the empty list of constructors if no
constructors could be found
tyConArity :: TyCon -> Arity
Number of arguments this TyCon must receive to be considered saturated (including implicit kind variables)
isClassTyCon :: TyCon -> Bool
Is this TyCon that for a class instance?
isTypeSynonymTyCon :: TyCon -> Bool
Is this a TyCon representing a regular H98 type synonym (type)?
isTypeFamilyTyCon :: TyCon -> Bool
Is this a synonym TyCon that can have may have further instances appear?
isNewTyCon :: TyCon -> Bool
Is this TyCon that for a newtype
isPrimTyCon :: TyCon -> Bool
Does this TyCon represent something that cannot be defined in Haskell?
isFunTyCon :: TyCon -> Bool
isFamilyTyCon :: TyCon -> Bool
Is this a TyCon, synonym or otherwise, that defines a family?
isOpenFamilyTyCon :: TyCon -> Bool
Is this a TyCon, synonym or otherwise, that defines a family with
instances?
isOpenTypeFamilyTyCon :: TyCon -> Bool
tyConClass_maybe :: TyCon -> Maybe Class
If this TyCon is that for a class instance, return the class it is for.
Otherwise returns Nothing
synTyConRhs_maybe :: TyCon -> Maybe Type
Extract the information pertaining to the right hand side of a type synonym
(type) declaration.
synTyConDefn_maybe :: TyCon -> Maybe ([TyVar], Type)
Extract the TyVars bound by a vanilla type synonym
and the corresponding (unsubstituted) right hand side.
synTyConResKind :: TyCon -> Kind
Type variables
alphaTyVars :: [TyVar]
Data constructors
data DataCon
A data constructor
dataConSig :: DataCon -> ([TyVar], ThetaType, [Type], Type)
The "signature" of the DataCon returns, in order:
1) The result of dataConAllTyVars,
2) All the ThetaTypes relating to the DataCon (coercion, dictionary, implicit
parameter - whatever)
3) The type arguments to the constructor
4) The original result type of the DataCon
dataConType :: DataCon -> Type
dataConTyCon :: DataCon -> TyCon
The type constructor that we are building via this data constructor
dataConFieldLabels :: DataCon -> [FieldLabel]
The labels for the fields of this particular DataCon
dataConIsInfix :: DataCon -> Bool
Should the DataCon be presented infix?
isVanillaDataCon :: DataCon -> Bool
Vanilla DataCons are those that are nice boring Haskell 98 constructors
dataConUserType :: DataCon -> Type
The user-declared type of the data constructor in the nice-to-read form:
T :: forall a b. a -> b -> T [a]
rather than:
T :: forall a c. forall b. (c~[a]) => a -> b -> T c
NB: If the constructor is part of a data instance, the result type mentions the family tycon, not the internal one.
dataConSrcBangs :: DataCon -> [HsSrcBang]
The strictness markings written by the porgrammer.
The list is in one-to-one correspondence with the arity of the DataCon
isMarkedStrict :: StrictnessMark -> Bool
Classes
classMethods :: Class -> [Id]
classSCTheta :: Class -> [PredType]
classTvsFds :: Class -> ([TyVar], [FunDep TyVar])
pprFundeps :: Outputable a => [FunDep a] -> SDoc
Instances
data ClsInst
Instances
instanceDFunId :: ClsInst -> DFunId
pprInstance :: ClsInst -> SDoc
pprInstanceHdr :: ClsInst -> SDoc
pprFamInst :: FamInst -> SDoc
Pretty-prints a FamInst (type/data family instance) with its defining location.
data FamInst
Instances
Types and Kinds
splitForAllTys :: Type -> ([TyVar], Type)
Attempts to take a forall type apart, returning all the immediate such bound
type variables and the remainder of the type. Always suceeds, even if that means
returning an empty list of TyVars
funResultTy :: Type -> Type
Extract the function result type and panic if that is not possible
pprParendType :: Type -> SDoc
pprTypeApp :: TyCon -> [Type] -> SDoc
The key type representing kinds in the compiler. Invariant: a kind is always in one of these forms:
FunTy k1 k2 TyConApp PrimTyCon [...] TyVar kv -- (during inference only) ForAll ... -- (for top-level coercions)
A type of the form p of kind Constraint represents a value whose type is
the Haskell predicate p, where a predicate is what occurs before
the => in a Haskell type.
We use PredType as documentation to mark those types that we guarantee to have
this kind.
It can be expanded into its representation, but:
- The type checker must treat it as opaque
- The rest of the compiler treats it as transparent
Consider these examples:
f :: (Eq a) => a -> Int
g :: (?x :: Int -> Int) => a -> Int
h :: (r\l) => {r} => {l::Int | r}Here the Eq a and ?x :: Int -> Int and rl are all called "predicates"
pprThetaArrowTy :: ThetaType -> SDoc
Entities
Syntax
module HsSyn
Fixities
data FixityDirection
maxPrecedence :: Int
compareFixity :: Fixity -> Fixity -> (Bool, Bool)
Source locations
data SrcLoc
Constructors
| RealSrcLoc !RealSrcLoc | |
| UnhelpfulLoc FastString |
mkSrcLoc :: FastString -> Int -> Int -> SrcLoc
srcLocFile :: RealSrcLoc -> FastString
Gives the filename of the RealSrcLoc
srcLocLine :: RealSrcLoc -> Int
Raises an error when used on a "bad" SrcLoc
srcLocCol :: RealSrcLoc -> Int
Raises an error when used on a "bad" SrcLoc
data SrcSpan
Constructors
| RealSrcSpan !RealSrcSpan | |
| UnhelpfulSpan !FastString |
data RealSrcSpan
A SrcSpan delimits a portion of a text file. It could be represented by a pair of (line,column) coordinates, but in fact we optimise slightly by using more compact representations for single-line and zero-length spans, both of which are quite common.
The end position is defined to be the column after the end of the span. That is, a span of (1,1)-(1,2) is one character long, and a span of (1,1)-(1,1) is zero characters long.
srcLocSpan :: SrcLoc -> SrcSpan
Create a SrcSpan corresponding to a single point
isGoodSrcSpan :: SrcSpan -> Bool
Test if a SrcSpan is "good", i.e. has precise location information
srcSpanStart :: SrcSpan -> SrcLoc
srcSpanEnd :: SrcSpan -> SrcLoc
srcSpanFile :: RealSrcSpan -> FastString
srcSpanStartLine :: RealSrcSpan -> Int
srcSpanEndLine :: RealSrcSpan -> Int
srcSpanStartCol :: RealSrcSpan -> Int
srcSpanEndCol :: RealSrcSpan -> Int
Located
data GenLocated l e
We attach SrcSpans to lots of things, so let's have a datatype for it.
Constructors
| L l e |
Instances
| Functor (GenLocated l) | |
| Foldable (GenLocated l) | |
| Traversable (GenLocated l) | |
| (Eq l, Eq e) => Eq (GenLocated l e) | |
| (Data l, Data e) => Data (GenLocated l e) | |
| (Ord l, Ord e) => Ord (GenLocated l e) | |
| (Outputable l, Outputable e) => Outputable (GenLocated l e) | |
| Binary a => Binary (GenLocated SrcSpan a) |
type Located e = GenLocated SrcSpan e
Constructing Located
mkGeneralLocated :: String -> e -> Located e
Deconstructing Located
getLoc :: GenLocated l e -> l
unLoc :: GenLocated l e -> e
Combining and comparing Located values
cmpLocated :: Ord a => Located a -> Located a -> Ordering
Tests the ordering of the two located things
combineLocs :: Located a -> Located b -> SrcSpan
addCLoc :: Located a -> Located b -> c -> Located c
Combine locations from two Located things and add them to a third thing
leftmost_smallest :: SrcSpan -> SrcSpan -> Ordering
Alternative strategies for ordering SrcSpans
leftmost_largest :: SrcSpan -> SrcSpan -> Ordering
Alternative strategies for ordering SrcSpans
spans :: SrcSpan -> (Int, Int) -> Bool
Determines whether a span encloses a given line and column index
Arguments
| :: SrcSpan | The span that may be enclosed by the other |
| -> SrcSpan | The span it may be enclosed by |
| -> Bool |
Determines whether a span is enclosed by another one
Exceptions
data GhcException
GHC's own exception type error messages all take the form:
location: error
If the location is on the command line, or in GHC itself, then location="ghc". All of the error types below correspond to a location of "ghc", except for ProgramError (where the string is assumed to contain a location already, so we don't print one).
Constructors
| PhaseFailed String ExitCode | |
| Signal Int | Some other fatal signal (SIGHUP,SIGTERM) |
| UsageError String | Prints the short usage msg after the error |
| CmdLineError String | A problem with the command line arguments, but don't print usage. |
| Panic String | The |
| PprPanic String SDoc | |
| Sorry String | The user tickled something that's known not to work yet, but we're not counting it as a bug. |
| PprSorry String SDoc | |
| InstallationError String | An installation problem. |
| ProgramError String | An error in the user's code, probably. |
| PprProgramError String SDoc |
Instances
showGhcException :: GhcException -> String -> String
Append a description of the given exception to this string.
Token stream manipulations
data Token
Instances
getTokenStream :: GhcMonad m => Module -> m [Located Token]
Return module source as token stream, including comments.
The module must be in the module graph and its source must be available.
Throws a SourceError on parse error.
getRichTokenStream :: GhcMonad m => Module -> m [(Located Token, String)]
Give even more information on the source than getTokenStream
This function allows reconstructing the source completely with
showRichTokenStream.
showRichTokenStream :: [(Located Token, String)] -> String
Take a rich token stream such as produced from getRichTokenStream and
return source code almost identical to the original code (except for
insignificant whitespace.)
addSourceToTokens :: RealSrcLoc -> StringBuffer -> [Located Token] -> [(Located Token, String)]
Given a source location and a StringBuffer corresponding to this location, return a rich token stream with the source associated to the tokens.
Pure interface to the parser
Arguments
| :: String | Haskell module source text (full Unicode is supported) |
| -> DynFlags | the flags |
| -> FilePath | the filename (for source locations) |
| -> Either ErrorMessages (WarningMessages, Located (HsModule RdrName)) |
A pure interface to the module parser.
API Annotations
data AnnKeywordId
API Annotations exist so that tools can perform source to source conversions of Haskell code. They are used to keep track of the various syntactic keywords that are not captured in the existing AST.
The annotations, together with original source comments are made
available in the field of pm_annotations.
Comments are only retained if ParsedModule is set in
Opt_KeepRawTokenStream before parsing.DynFlags
The wiki page describing this feature is https://ghc.haskell.org/trac/ghc/wiki/ApiAnnotations
Note: in general the names of these are taken from the corresponding token, unless otherwise noted See note [Api annotations] above for details of the usage
Constructors
data AnnotationComment
Constructors
| AnnDocCommentNext String | something beginning '-- |' |
| AnnDocCommentPrev String | something beginning '-- ^' |
| AnnDocCommentNamed String | something beginning '-- $' |
| AnnDocSection Int String | a section heading |
| AnnDocOptions String | doc options (prune, ignore-exports, etc) |
| AnnDocOptionsOld String | doc options declared "-- # ..."-style |
| AnnLineComment String | comment starting by "--" |
| AnnBlockComment String | comment in {- -} |
getAnnotation :: ApiAnns -> SrcSpan -> AnnKeywordId -> [SrcSpan]
getAndRemoveAnnotation :: ApiAnns -> SrcSpan -> AnnKeywordId -> ([SrcSpan], ApiAnns)
getAnnotationComments :: ApiAnns -> SrcSpan -> [Located AnnotationComment]
getAndRemoveAnnotationComments :: ApiAnns -> SrcSpan -> ([Located AnnotationComment], ApiAnns)
Retrieve the comments allocated to the current SrcSpan, and
remove them from the annotations
Miscellaneous
cyclicModuleErr :: [ModSummary] -> SDoc