ghc-7.6.3: The GHC API

Safe Haskell | None

GhcMonad

Contents

- `Ghc` monad stuff
  - Warnings

Synopsis

- class (Functor m, MonadIO m, ExceptionMonad m, HasDynFlags m) => GhcMonad m where
  - getSession :: m HscEnv
  - setSession :: HscEnv -> m ()
- newtype Ghc a = Ghc {
  - unGhc :: Session -> IO a
  }
- newtype GhcT m a = GhcT {
  - unGhcT :: Session -> m a
  }
- liftGhcT :: Monad m => m a -> GhcT m a
- reflectGhc :: Ghc a -> Session -> IO a
- reifyGhc :: (Session -> IO a) -> Ghc a
- getSessionDynFlags :: GhcMonad m => m DynFlags
- liftIO :: MonadIO m => IO a -> m a
- data Session = Session !(IORef HscEnv)
- withSession :: GhcMonad m => (HscEnv -> m a) -> m a
- modifySession :: GhcMonad m => (HscEnv -> HscEnv) -> m ()
- withTempSession :: GhcMonad m => (HscEnv -> HscEnv) -> m a -> m a
- logWarnings :: GhcMonad m => WarningMessages -> m ()
- printException :: GhcMonad m => SourceError -> m ()
- printExceptionAndWarnings :: GhcMonad m => SourceError -> m ()
- type WarnErrLogger = GhcMonad m => Maybe SourceError -> m ()
- defaultWarnErrLogger :: WarnErrLogger

# `Ghc` monad stuff

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.

Methods

getSession :: m HscEnv

setSession :: HscEnv -> m ()

Instances

GhcMonad Ghc |
(Functor m, ExceptionMonad m, MonadIO m) => GhcMonad (GhcT m) |

newtype Ghc a

A minimal implementation of a `GhcMonad`. If you need a custom monad, e.g., to maintain additional state consider wrapping this monad or using `GhcT`.

Constructors

Ghc |
Fields unGhc :: Session -> IO a

Instances

Monad Ghc |
Functor Ghc |
MonadFix Ghc |
MonadIO Ghc |
ExceptionMonad Ghc |
HasDynFlags Ghc |
GhcMonad Ghc |

newtype 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.

Constructors

GhcT |
Fields unGhcT :: Session -> m a

Instances

Monad m => Monad (GhcT m) |
Functor m => Functor (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) |

liftGhcT :: Monad m => m a -> GhcT m a

reflectGhc :: Ghc a -> Session -> IO a

Reflect a computation in the `Ghc` monad into the `IO` monad.

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

reifyGhc :: (Session -> IO a) -> Ghc a

getSessionDynFlags :: GhcMonad m => m DynFlags

Grabs the DynFlags from the Session

liftIO :: MonadIO m => IO a -> m a

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) |

withSession :: GhcMonad m => (HscEnv -> m a) -> m a

Call the argument with the current session.

modifySession :: GhcMonad m => (HscEnv -> HscEnv) -> m ()

Set the current session to the result of applying the current session to the argument.

withTempSession :: GhcMonad m => (HscEnv -> HscEnv) -> m a -> m a

Call an action with a temporarily modified Session.

## Warnings

logWarnings :: GhcMonad m => WarningMessages -> m ()

A monad that allows logging of warnings.

printException :: GhcMonad m => SourceError -> m ()

Print the error message and all warnings. Useful inside exception handlers. Clears warnings after printing.

printExceptionAndWarnings :: GhcMonad m => SourceError -> m ()

Deprecated: use printException instead

type WarnErrLogger = GhcMonad m => Maybe SourceError -> m ()

A function called to log warnings and errors.

defaultWarnErrLogger :: WarnErrLogger