Safe Haskell	None
Language	Haskell2010

GHC.Core.Opt.Monad

Contents

Types used in core-to-core passes
The monad

Synopsis

data FloatOutSwitches = FloatOutSwitches {
- floatOutLambdas :: Maybe Int
- floatOutConstants :: Bool
- floatOutOverSatApps :: Bool
- floatToTopLevelOnly :: Bool
}
data CoreM a
runCoreM :: HscEnv -> RuleBase -> Char -> Module -> NamePprCtx -> SrcSpan -> CoreM a -> IO (a, SimplCount)
mapDynFlagsCoreM :: (DynFlags -> DynFlags) -> CoreM a -> CoreM a
dropSimplCount :: CoreM a -> CoreM a
getHscEnv :: CoreM HscEnv
getModule :: HasModule m => m Module
initRuleEnv :: ModGuts -> CoreM RuleEnv
getExternalRuleBase :: CoreM RuleBase
getDynFlags :: HasDynFlags m => m DynFlags
getPackageFamInstEnv :: CoreM PackageFamInstEnv
getInteractiveContext :: CoreM InteractiveContext
getUniqMask :: CoreM Char
getNamePprCtx :: CoreM NamePprCtx
getSrcSpanM :: CoreM SrcSpan
addSimplCount :: SimplCount -> CoreM ()
liftIO :: MonadIO m => IO a -> m a
liftIOWithCount :: IO (SimplCount, a) -> CoreM a
getAnnotations :: Typeable a => ([Word8] -> a) -> ModGuts -> CoreM (ModuleEnv [a], NameEnv [a])
getFirstAnnotations :: Typeable a => ([Word8] -> a) -> ModGuts -> CoreM (ModuleEnv a, NameEnv a)
putMsg :: SDoc -> CoreM ()
putMsgS :: String -> CoreM ()
errorMsg :: SDoc -> CoreM ()
msg :: MessageClass -> SDoc -> CoreM ()
fatalErrorMsg :: SDoc -> CoreM ()
fatalErrorMsgS :: String -> CoreM ()
debugTraceMsg :: SDoc -> CoreM ()
debugTraceMsgS :: String -> CoreM ()

Types used in core-to-core passes

data FloatOutSwitches Source #

Constructors

FloatOutSwitches

Fields

floatOutLambdas :: Maybe Int
Just n = float lambdas to top level, if doing so will abstract over n or fewer value variables Nothing = float all lambdas to top level, regardless of how many free variables Just 0 is the vanilla case: float a lambda iff it has no free vars
floatOutConstants :: Bool
True = float constants to top level, even if they do not escape a lambda
floatOutOverSatApps :: Bool
True = float out over-saturated applications based on arity information. See Note [Floating over-saturated applications] in GHC.Core.Opt.SetLevels
floatToTopLevelOnly :: Bool
Allow floating to the top level only.

Instances

Instances details

Outputable FloatOutSwitches Source #
Instance details Defined in GHC.Core.Opt.Monad Methods ppr :: FloatOutSwitches -> SDoc Source #

The monad

data CoreM a Source #

The monad used by Core-to-Core passes to register simplification statistics. Also used to have common state (in the form of UniqueSupply) for generating Uniques.

Instances

Instances details

MonadIO CoreM Source #
Instance details Defined in GHC.Core.Opt.Monad Methods liftIO :: IO a -> CoreM a Source #
Alternative CoreM Source #
Instance details Defined in GHC.Core.Opt.Monad Methods empty :: CoreM a Source # (<\|>) :: CoreM a -> CoreM a -> CoreM a Source # some :: CoreM a -> CoreM [a] Source # many :: CoreM a -> CoreM [a] Source #
Applicative CoreM Source #
Instance details Defined in GHC.Core.Opt.Monad Methods pure :: a -> CoreM a Source # (<>) :: CoreM (a -> b) -> CoreM a -> CoreM b Source # liftA2 :: (a -> b -> c) -> CoreM a -> CoreM b -> CoreM c Source # (>) :: CoreM a -> CoreM b -> CoreM b Source # (<*) :: CoreM a -> CoreM b -> CoreM a Source #
Functor CoreM Source #
Instance details Defined in GHC.Core.Opt.Monad Methods fmap :: (a -> b) -> CoreM a -> CoreM b Source # (<$) :: a -> CoreM b -> CoreM a Source #
Monad CoreM Source #
Instance details Defined in GHC.Core.Opt.Monad Methods (>>=) :: CoreM a -> (a -> CoreM b) -> CoreM b Source # (>>) :: CoreM a -> CoreM b -> CoreM b Source # return :: a -> CoreM a Source #
MonadPlus CoreM Source #
Instance details Defined in GHC.Core.Opt.Monad Methods mzero :: CoreM a Source # mplus :: CoreM a -> CoreM a -> CoreM a Source #
HasDynFlags CoreM Source #
Instance details Defined in GHC.Core.Opt.Monad Methods getDynFlags :: CoreM DynFlags Source #
MonadThings CoreM Source #
Instance details Defined in GHC.Plugins Methods lookupThing :: Name -> CoreM TyThing Source # lookupId :: Name -> CoreM Id Source # lookupDataCon :: Name -> CoreM DataCon Source # lookupTyCon :: Name -> CoreM TyCon Source #
MonadUnique CoreM Source #
Instance details Defined in GHC.Core.Opt.Monad Methods getUniqueSupplyM :: CoreM UniqSupply Source # getUniqueM :: CoreM Unique Source # getUniquesM :: CoreM [Unique] Source #
HasModule CoreM Source #
Instance details Defined in GHC.Core.Opt.Monad Methods getModule :: CoreM Module Source #
HasLogger CoreM Source #
Instance details Defined in GHC.Core.Opt.Monad Methods getLogger :: CoreM Logger Source #

runCoreM Source #

Arguments

:: HscEnv
-> RuleBase
-> Char	Mask
-> Module
-> NamePprCtx
-> SrcSpan
-> CoreM a
-> IO (a, SimplCount)

mapDynFlagsCoreM :: (DynFlags -> DynFlags) -> CoreM a -> CoreM a Source #

Adjust the dyn flags passed to the argument action

dropSimplCount :: CoreM a -> CoreM a Source #

Drop the single count of the argument action so it doesn't effect the total.

Reading from the monad

getHscEnv :: CoreM HscEnv Source #

getModule :: HasModule m => m Module Source #

initRuleEnv :: ModGuts -> CoreM RuleEnv Source #

getExternalRuleBase :: CoreM RuleBase Source #

getDynFlags :: HasDynFlags m => m DynFlags Source #

getPackageFamInstEnv :: CoreM PackageFamInstEnv Source #

getInteractiveContext :: CoreM InteractiveContext Source #

getUniqMask :: CoreM Char Source #

getNamePprCtx :: CoreM NamePprCtx Source #

getSrcSpanM :: CoreM SrcSpan Source #

Writing to the monad

addSimplCount :: SimplCount -> CoreM () Source #

Lifting into the monad

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

Lift a computation from the IO monad. This allows us to run IO computations in any monadic stack, so long as it supports these kinds of operations (i.e. IO is the base monad for the stack).

Example

Expand

import Control.Monad.Trans.State -- from the "transformers" library

printState :: Show s => StateT s IO ()
printState = do
  state <- get
  liftIO $ print state

Had we omitted liftIO, we would have ended up with this error:

• Couldn't match type ‘IO’ with ‘StateT s IO’
 Expected type: StateT s IO ()
   Actual type: IO ()

The important part here is the mismatch between StateT s IO () and IO ().

Luckily, we know of a function that takes an IO a and returns an (m a): liftIO, enabling us to run the program and see the expected results:

> evalStateT printState "hello"
"hello"

> evalStateT printState 3
3

liftIOWithCount :: IO (SimplCount, a) -> CoreM a Source #

Lift an IO operation into CoreM while consuming its SimplCount

Dealing with annotations

getAnnotations :: Typeable a => ([Word8] -> a) -> ModGuts -> CoreM (ModuleEnv [a], NameEnv [a]) Source #

Get all annotations of a given type. This happens lazily, that is no deserialization will take place until the [a] is actually demanded and the [a] can also be empty (the UniqFM is not filtered).

This should be done once at the start of a Core-to-Core pass that uses annotations.

See Note [Annotations]

getFirstAnnotations :: Typeable a => ([Word8] -> a) -> ModGuts -> CoreM (ModuleEnv a, NameEnv a) Source #

Get at most one annotation of a given type per annotatable item.