You can use this to call functions returning an action in the Ghc monad inside an IO action. This is needed for some (too restrictive) callback arguments of some library functions:

libFunc :: String -> (Int -> IO a) -> IO a
ghcFunc :: Int -> Ghc a

ghcFuncUsingLibFunc :: String -> Ghc a -> Ghc a
ghcFuncUsingLibFunc str =
  reifyGhc $ \s ->
    libFunc $ \i -> do
      reflectGhc (ghcFunc i) s

data Session #

The Session is a handle to the complete state of a compilation session. A compilation session consists of a set of modules constituting the current program or library, the context for interactive evaluation, and various caches.

Constructors

Session !(IORef HscEnv)

Hsc Monad

getHscEnv :: Hsc HscEnv #

Driver compat

batchMsg :: Messager #

HscEnv Compat

set_hsc_dflags :: DynFlags -> HscEnv -> HscEnv Source #

overPkgDbRef :: (FilePath -> FilePath) -> PackageDBFlag -> PackageDBFlag Source #

guessTarget :: GhcMonad m => String -> Maybe Phase -> m Target Source #

setNoCode :: DynFlags -> DynFlags Source #

getModSummaries :: ModuleGraph -> [ModSummary] Source #

mapOverIncludePaths :: (FilePath -> FilePath) -> DynFlags -> DynFlags Source #

getLogger :: HscEnv -> Logger Source #

AST compat

pattern RealSrcSpan :: RealSrcSpan -> SrcSpan Source #

type LExpression = LHsExpr GhcTc Source #

type LBinding = LHsBind GhcTc Source #

type LPattern = LPat GhcTc Source #

inTypes :: MatchGroup GhcTc LExpression -> [Type] Source #

outType :: MatchGroup GhcTc LExpression -> Type Source #

Exceptions

catch :: (MonadCatch m, Exception e) => m a -> (e -> m a) -> m a Source #

bracket :: ExceptionMonad m => m a -> (a -> m c) -> (a -> m b) -> m b Source #

handle :: (ExceptionMonad m, Exception e) => (e -> m a) -> m a -> m a Source #

Doc Gap functions

pageMode :: Mode Source #

oneLineMode :: Mode Source #

DynFlags compat

initializePluginsForModSummary :: HscEnv -> ModSummary -> IO (Int, [ModuleName], ModSummary) Source #

setFrontEndHooks :: Maybe (ModSummary -> Hsc FrontendResult) -> HscEnv -> HscEnv Source #

updOptLevel :: Int -> DynFlags -> DynFlags #

Sets the DynFlags to be appropriate to the optimisation level

setWayDynamicIfHostIsDynamic :: DynFlags -> DynFlags Source #

gopt_set :: DynFlags -> GeneralFlag -> DynFlags Source #

parseDynamicFlags :: MonadIO m => Logger -> DynFlags -> [Located String] -> m (DynFlags, [Located String], [Warn]) Source #

Platform constants

hostIsDynamic :: Bool Source #

misc

getModuleName :: (a, b) -> a Source #

getTyThing :: (a, b, c, d, e) -> a Source #

fixInfo :: (a, b, c, d, e) -> (a, b, c, d) Source #

data FrontendResult #

FrontendResult describes the result of running the frontend of a Haskell module. Usually, you'll get a FrontendTypecheck, since running the frontend involves typechecking a program, but for an hs-boot merge you'll just get a ModIface, since no actual typechecking occurred.

This data type really should be in HscTypes, but it needs to have a TcGblEnv which is only defined here.

Constructors

FrontendTypecheck TcGblEnv

data Hsc a #

Instances

Instances details

Monad Hsc
Instance details Defined in HscTypes Methods (>>=) :: Hsc a -> (a -> Hsc b) -> Hsc b # (>>) :: Hsc a -> Hsc b -> Hsc b # return :: a -> Hsc a #
Functor Hsc
Instance details Defined in HscTypes Methods fmap :: (a -> b) -> Hsc a -> Hsc b # (<$) :: a -> Hsc b -> Hsc a #
Applicative Hsc
Instance details Defined in HscTypes Methods pure :: a -> Hsc a # (<>) :: Hsc (a -> b) -> Hsc a -> Hsc b # liftA2 :: (a -> b -> c) -> Hsc a -> Hsc b -> Hsc c # (>) :: Hsc a -> Hsc b -> Hsc b # (<*) :: Hsc a -> Hsc b -> Hsc a #
MonadIO Hsc
Instance details Defined in HscTypes Methods liftIO :: IO a -> Hsc a #
HasDynFlags Hsc
Instance details Defined in HscTypes Methods getDynFlags :: Hsc DynFlags #

mapMG :: (ModSummary -> ModSummary) -> ModuleGraph -> ModuleGraph #

Map a function f over all the ModSummaries. To preserve invariants f can't change the isBoot status.

mgModSummaries :: ModuleGraph -> [ModSummary] #

unsetLogAction :: GhcMonad m => m () Source #