Safe Haskell | None |
---|---|
Language | GHC2021 |
GHC.Core holds all the main data types for use by for the Glasgow Haskell Compiler midsection
Synopsis
- data Expr b
- data Alt b = Alt AltCon [b] (Expr b)
- data Bind b
- data AltCon
- type Arg b = Expr b
- type CoreProgram = [CoreBind]
- type CoreExpr = Expr CoreBndr
- type CoreAlt = Alt CoreBndr
- type CoreBind = Bind CoreBndr
- type CoreArg = Arg CoreBndr
- type CoreBndr = Var
- type TaggedExpr t = Expr (TaggedBndr t)
- type TaggedAlt t = Alt (TaggedBndr t)
- type TaggedBind t = Bind (TaggedBndr t)
- type TaggedArg t = Arg (TaggedBndr t)
- data TaggedBndr t = TB CoreBndr t
- deTagExpr :: TaggedExpr t -> CoreExpr
- type InId = Id
- type InBind = CoreBind
- type InExpr = CoreExpr
- type InAlt = CoreAlt
- type InArg = CoreArg
- type InType = Type
- type InKind = Kind
- type InBndr = CoreBndr
- type InVar = Var
- type InCoercion = Coercion
- type InTyVar = TyVar
- type InCoVar = CoVar
- type OutId = Id
- type OutBind = CoreBind
- type OutExpr = CoreExpr
- type OutAlt = CoreAlt
- type OutArg = CoreArg
- type OutType = Type
- type OutKind = Kind
- type OutBndr = CoreBndr
- type OutVar = Var
- type OutCoercion = Coercion
- type OutTyVar = TyVar
- type OutCoVar = CoVar
- type MOutCoercion = MCoercion
- mkLet :: Bind b -> Expr b -> Expr b
- mkLets :: [Bind b] -> Expr b -> Expr b
- mkLetNonRec :: b -> Expr b -> Expr b -> Expr b
- mkLetRec :: [(b, Expr b)] -> Expr b -> Expr b
- mkLams :: [b] -> Expr b -> Expr b
- mkApps :: Expr b -> [Arg b] -> Expr b
- mkTyApps :: Expr b -> [Type] -> Expr b
- mkCoApps :: Expr b -> [Coercion] -> Expr b
- mkVarApps :: Expr b -> [Var] -> Expr b
- mkTyArg :: Type -> Expr b
- mkIntLit :: Platform -> Integer -> Expr b
- mkIntLitWrap :: Platform -> Integer -> Expr b
- mkWordLit :: Platform -> Integer -> Expr b
- mkWordLitWrap :: Platform -> Integer -> Expr b
- mkWord8Lit :: Integer -> Expr b
- mkWord32LitWord32 :: Word32 -> Expr b
- mkWord64LitWord64 :: Word64 -> Expr b
- mkInt64LitInt64 :: Int64 -> Expr b
- mkCharLit :: Char -> Expr b
- mkStringLit :: String -> Expr b
- mkFloatLit :: Rational -> Expr b
- mkFloatLitFloat :: Float -> Expr b
- mkDoubleLit :: Rational -> Expr b
- mkDoubleLitDouble :: Double -> Expr b
- mkConApp :: DataCon -> [Arg b] -> Expr b
- mkConApp2 :: DataCon -> [Type] -> [Var] -> Expr b
- mkTyBind :: TyVar -> Type -> CoreBind
- mkCoBind :: CoVar -> Coercion -> CoreBind
- varToCoreExpr :: CoreBndr -> Expr b
- varsToCoreExprs :: [CoreBndr] -> [Expr b]
- mkBinds :: RecFlag -> [(b, Expr b)] -> [Bind b]
- isId :: Var -> Bool
- cmpAltCon :: AltCon -> AltCon -> Ordering
- cmpAlt :: Alt a -> Alt a -> Ordering
- ltAlt :: Alt a -> Alt a -> Bool
- bindersOf :: Bind b -> [b]
- bindersOfBinds :: [Bind b] -> [b]
- rhssOfBind :: Bind b -> [Expr b]
- rhssOfAlts :: [Alt b] -> [Expr b]
- foldBindersOfBindStrict :: (a -> b -> a) -> a -> Bind b -> a
- foldBindersOfBindsStrict :: (a -> b -> a) -> a -> [Bind b] -> a
- collectBinders :: Expr b -> ([b], Expr b)
- collectTyBinders :: CoreExpr -> ([TyVar], CoreExpr)
- collectTyAndValBinders :: CoreExpr -> ([TyVar], [Id], CoreExpr)
- collectNBinders :: JoinArity -> Expr b -> ([b], Expr b)
- collectNValBinders_maybe :: Arity -> CoreExpr -> Maybe ([Var], CoreExpr)
- collectArgs :: Expr b -> (Expr b, [Arg b])
- collectValArgs :: Expr b -> (Expr b, [Arg b])
- stripNArgs :: Word -> Expr a -> Maybe (Expr a)
- collectArgsTicks :: (CoreTickish -> Bool) -> Expr b -> (Expr b, [Arg b], [CoreTickish])
- flattenBinds :: [Bind b] -> [(b, Expr b)]
- collectFunSimple :: Expr b -> Expr b
- exprToType :: CoreExpr -> Type
- wrapLamBody :: (CoreExpr -> CoreExpr) -> CoreExpr -> CoreExpr
- isValArg :: Expr b -> Bool
- isTypeArg :: Expr b -> Bool
- isCoArg :: Expr b -> Bool
- isTyCoArg :: Expr b -> Bool
- valArgCount :: [Arg b] -> Int
- valBndrCount :: [CoreBndr] -> Int
- isRuntimeArg :: CoreExpr -> Bool
- isRuntimeVar :: Var -> Bool
- data Unfolding
- = NoUnfolding
- | BootUnfolding
- | OtherCon [AltCon]
- | DFunUnfolding { }
- | CoreUnfolding { }
- data UnfoldingCache = UnfoldingCache {
- uf_is_value :: !Bool
- uf_is_conlike :: !Bool
- uf_is_work_free :: !Bool
- uf_expandable :: !Bool
- data UnfoldingGuidance
- = UnfWhen {
- ug_arity :: Arity
- ug_unsat_ok :: Bool
- ug_boring_ok :: Bool
- | UnfIfGoodArgs { }
- | UnfNever
- = UnfWhen {
- data UnfoldingSource
- noUnfolding :: Unfolding
- bootUnfolding :: Unfolding
- evaldUnfolding :: Unfolding
- mkOtherCon :: [AltCon] -> Unfolding
- unSaturatedOk :: Bool
- needSaturated :: Bool
- boringCxtOk :: Bool
- boringCxtNotOk :: Bool
- expandUnfolding_maybe :: Unfolding -> Maybe CoreExpr
- maybeUnfoldingTemplate :: Unfolding -> Maybe CoreExpr
- otherCons :: Unfolding -> [AltCon]
- isValueUnfolding :: Unfolding -> Bool
- isEvaldUnfolding :: Unfolding -> Bool
- isCheapUnfolding :: Unfolding -> Bool
- isExpandableUnfolding :: Unfolding -> Bool
- isConLikeUnfolding :: Unfolding -> Bool
- isCompulsoryUnfolding :: Unfolding -> Bool
- isStableUnfolding :: Unfolding -> Bool
- isStableUserUnfolding :: Unfolding -> Bool
- isStableSystemUnfolding :: Unfolding -> Bool
- isInlineUnfolding :: Unfolding -> Bool
- isBootUnfolding :: Unfolding -> Bool
- isBetterUnfoldingThan :: Unfolding -> Unfolding -> Bool
- hasCoreUnfolding :: Unfolding -> Bool
- hasSomeUnfolding :: Unfolding -> Bool
- canUnfold :: Unfolding -> Bool
- neverUnfoldGuidance :: UnfoldingGuidance -> Bool
- isStableSource :: UnfoldingSource -> Bool
- 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 CoreTickish (AnnExpr bndr annot)
- | AnnType Type
- | AnnCoercion Coercion
- data AnnBind bndr annot
- data AnnAlt bndr annot = AnnAlt AltCon [bndr] (AnnExpr bndr annot)
- collectAnnArgs :: AnnExpr b a -> (AnnExpr b a, [AnnExpr b a])
- collectAnnArgsTicks :: (CoreTickish -> Bool) -> AnnExpr b a -> (AnnExpr b a, [AnnExpr b a], [CoreTickish])
- deAnnotate :: AnnExpr bndr annot -> Expr bndr
- deAnnotate' :: AnnExpr' bndr annot -> Expr bndr
- deAnnAlt :: AnnAlt bndr annot -> Alt bndr
- deAnnBind :: AnnBind b annot -> Bind b
- collectAnnBndrs :: AnnExpr bndr annot -> ([bndr], AnnExpr bndr annot)
- collectNAnnBndrs :: Int -> AnnExpr bndr annot -> ([bndr], AnnExpr bndr annot)
- data IsOrphan
- isOrphan :: IsOrphan -> Bool
- notOrphan :: IsOrphan -> Bool
- chooseOrphanAnchor :: NameSet -> IsOrphan
- data CoreRule
- = Rule { }
- | BuiltinRule { }
- type RuleName = FastString
- type RuleFun = RuleOpts -> InScopeEnv -> Id -> [CoreExpr] -> Maybe CoreExpr
- type IdUnfoldingFun = Id -> Unfolding
- data InScopeEnv = ISE InScopeSet IdUnfoldingFun
- data RuleOpts
- ruleArity :: CoreRule -> Int
- ruleName :: CoreRule -> RuleName
- ruleIdName :: CoreRule -> Name
- ruleActivation :: CoreRule -> Activation
- setRuleIdName :: Name -> CoreRule -> CoreRule
- ruleModule :: CoreRule -> Maybe Module
- isBuiltinRule :: CoreRule -> Bool
- isLocalRule :: CoreRule -> Bool
- isAutoRule :: CoreRule -> Bool
Main data types
This is the data type that represents GHCs core intermediate language. Currently GHC uses System FC https://www.microsoft.com/en-us/research/publication/system-f-with-type-equality-coercions/ for this purpose, which is closely related to the simpler and better known System F http://en.wikipedia.org/wiki/System_F.
We get from Haskell source to this Core language in a number of stages:
- The source code is parsed into an abstract syntax tree, which is represented
by the data type
HsExpr
with the names beingRdrNames
- This syntax tree is renamed, which attaches a
Unique
to everyRdrName
(yielding aName
) to disambiguate identifiers which are lexically identical. For example, this program:
f x = let f x = x + 1 in f (x - 2)
Would be renamed by having Unique
s attached so it looked something like this:
f_1 x_2 = let f_3 x_4 = x_4 + 1 in f_3 (x_2 - 2)
But see Note [Shadowing in Core] below.
- The resulting syntax tree undergoes type checking (which also deals with instantiating
type class arguments) to yield a
HsExpr
type that hasId
as it's names. - Finally the syntax tree is desugared from the expressive
HsExpr
type into thisExpr
type, which has far fewer constructors and hence is easier to perform optimization, analysis and code generation on.
The type parameter b
is for the type of binders in the expression tree.
The language consists of the following elements:
- Variables See Note [Variable occurrences in Core]
- Primitive literals
- Applications: note that the argument may be a
Type
. See Note [Representation polymorphism invariants] - Lambda abstraction See Note [Representation polymorphism invariants]
- Recursive and non recursive
let
s. Operationally this corresponds to allocating a thunk for the things bound and then executing the sub-expression.
See Note [Core letrec invariant] See Note [Core let-can-float invariant] See Note [Representation polymorphism invariants] See Note [Core type and coercion invariant]
- Case expression. Operationally this corresponds to evaluating the scrutinee (expression examined) to weak head normal form and then examining at most one level of resulting constructor (i.e. you cannot do nested pattern matching directly with this).
The binder gets bound to the value of the scrutinee,
and the Type
must be that of all the case alternatives
IMPORTANT: see Note [Case expression invariants]
- Cast an expression to a particular type.
This is used to implement
newtype
s (anewtype
constructor or destructor just becomes aCast
in Core) and GADTs. - Ticks. These are used to represent all the source annotation we support: profiling SCCs, HPC ticks, and GHCi breakpoints.
- A type: this should only show up at the top level of an Arg
- A coercion
Var Id | |
Lit Literal | |
App (Expr b) (Arg b) infixl 4 | |
Lam b (Expr b) | |
Let (Bind b) (Expr b) | |
Case (Expr b) b Type [Alt b] | |
Cast (Expr b) CoercionR | |
Tick CoreTickish (Expr b) | |
Type Type | |
Coercion Coercion |
Instances
OutputableBndr b => Outputable (Expr b) Source # | |
Data b => Data (Expr b) Source # | |
Defined in GHC.Core gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Expr b -> c (Expr b) # gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Expr b) # toConstr :: Expr b -> Constr # dataTypeOf :: Expr b -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Expr b)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Expr b)) # gmapT :: (forall b0. Data b0 => b0 -> b0) -> Expr b -> Expr b # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expr b -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expr b -> r # gmapQ :: (forall d. Data d => d -> u) -> Expr b -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Expr b -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Expr b -> m (Expr b) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Expr b -> m (Expr b) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Expr b -> m (Expr b) # | |
Eq (DeBruijn CoreExpr) Source # | |
A case split alternative. Consists of the constructor leading to the alternative,
the variables bound from the constructor, and the expression to be executed given that binding.
The default alternative is (DEFAULT, [], rhs)
Instances
OutputableBndr b => Outputable (Alt b) Source # | |
Data b => Data (Alt b) Source # | |
Defined in GHC.Core gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Alt b -> c (Alt b) # gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Alt b) # dataTypeOf :: Alt b -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Alt b)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Alt b)) # gmapT :: (forall b0. Data b0 => b0 -> b0) -> Alt b -> Alt b # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alt b -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Alt b -> r # gmapQ :: (forall d. Data d => d -> u) -> Alt b -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Alt b -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Alt b -> m (Alt b) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Alt b -> m (Alt b) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Alt b -> m (Alt b) # | |
Eq (DeBruijn CoreAlt) Source # | |
Binding, used for top level bindings in a module and local bindings in a let
.
Instances
OutputableBndr b => Outputable (Bind b) Source # | |
Data b => Data (Bind b) Source # | |
Defined in GHC.Core gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Bind b -> c (Bind b) # gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Bind b) # toConstr :: Bind b -> Constr # dataTypeOf :: Bind b -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Bind b)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Bind b)) # gmapT :: (forall b0. Data b0 => b0 -> b0) -> Bind b -> Bind b # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bind b -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bind b -> r # gmapQ :: (forall d. Data d => d -> u) -> Bind b -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Bind b -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Bind b -> m (Bind b) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Bind b -> m (Bind b) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Bind b -> m (Bind b) # |
A case alternative constructor (i.e. pattern match)
DataAlt DataCon | |
LitAlt Literal | A literal: |
DEFAULT | Trivial alternative: |
Instances
Outputable AltCon Source # | |
Data AltCon Source # | |
Defined in GHC.Core gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AltCon -> c AltCon # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AltCon # toConstr :: AltCon -> Constr # dataTypeOf :: AltCon -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AltCon) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AltCon) # gmapT :: (forall b. Data b => b -> b) -> AltCon -> AltCon # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AltCon -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AltCon -> r # gmapQ :: (forall d. Data d => d -> u) -> AltCon -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AltCon -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AltCon -> m AltCon # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AltCon -> m AltCon # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AltCon -> m AltCon # | |
Eq AltCon Source # | |
Ord AltCon Source # | |
type CoreProgram = [CoreBind] Source #
The common case for the type of binders and variables when we are manipulating the Core language within GHC
type TaggedExpr t = Expr (TaggedBndr t) Source #
type TaggedAlt t = Alt (TaggedBndr t) Source #
type TaggedBind t = Bind (TaggedBndr t) Source #
type TaggedArg t = Arg (TaggedBndr t) Source #
data TaggedBndr t Source #
Binders are tagged with a t
Instances
Outputable b => Outputable (TaggedBndr b) Source # | |
Outputable b => OutputableBndr (TaggedBndr b) Source # | |
Defined in GHC.Core.Ppr pprBndr :: BindingSite -> TaggedBndr b -> SDoc Source # pprPrefixOcc :: TaggedBndr b -> SDoc Source # pprInfixOcc :: TaggedBndr b -> SDoc Source # bndrIsJoin_maybe :: TaggedBndr b -> JoinPointHood Source # |
deTagExpr :: TaggedExpr t -> CoreExpr Source #
In/Out type synonyms
type InCoercion = Coercion Source #
type OutCoercion = Coercion Source #
type MOutCoercion = MCoercion Source #
Expr
construction
mkLets :: [Bind b] -> Expr b -> Expr b Source #
Bind all supplied binding groups over an expression in a nested let expression. Assumes
that the rhs satisfies the let-can-float invariant. Prefer to use
mkCoreLets
if possible, which does guarantee the invariant
mkLetNonRec :: b -> Expr b -> Expr b -> Expr b Source #
mkLetNonRec bndr rhs body
wraps body
in a let
binding bndr
.
mkLetRec :: [(b, Expr b)] -> Expr b -> Expr b Source #
mkLetRec binds body
wraps body
in a let rec
with the given set of
binds
if binds is non-empty.
mkLams :: [b] -> Expr b -> Expr b Source #
Bind all supplied binders over an expression in a nested lambda expression. Prefer to
use mkCoreLams
if possible
mkApps :: Expr b -> [Arg b] -> Expr b infixl 4 Source #
Apply a list of argument expressions to a function expression in a nested fashion. Prefer to
use mkCoreApps
if possible
mkTyApps :: Expr b -> [Type] -> Expr b infixl 4 Source #
Apply a list of type argument expressions to a function expression in a nested fashion
mkCoApps :: Expr b -> [Coercion] -> Expr b infixl 4 Source #
Apply a list of coercion argument expressions to a function expression in a nested fashion
mkVarApps :: Expr b -> [Var] -> Expr b infixl 4 Source #
Apply a list of type or value variables to a function expression in a nested fashion
mkIntLit :: Platform -> Integer -> Expr b Source #
Create a machine integer literal expression of type Int#
from an Integer
.
If you want an expression of type Int
use mkIntExpr
mkIntLitWrap :: Platform -> Integer -> Expr b Source #
Create a machine integer literal expression of type Int#
from an
Integer
, wrapping if necessary.
If you want an expression of type Int
use mkIntExpr
mkWordLit :: Platform -> Integer -> Expr b Source #
Create a machine word literal expression of type Word#
from an Integer
.
If you want an expression of type Word
use mkWordExpr
mkWordLitWrap :: Platform -> Integer -> Expr b Source #
Create a machine word literal expression of type Word#
from an
Integer
, wrapping if necessary.
If you want an expression of type Word
use mkWordExpr
mkWord8Lit :: Integer -> Expr b Source #
mkWord32LitWord32 :: Word32 -> Expr b Source #
mkWord64LitWord64 :: Word64 -> Expr b Source #
mkInt64LitInt64 :: Int64 -> Expr b Source #
mkCharLit :: Char -> Expr b Source #
Create a machine character literal expression of type Char#
.
If you want an expression of type Char
use mkCharExpr
mkStringLit :: String -> Expr b Source #
Create a machine string literal expression of type Addr#
.
If you want an expression of type String
use mkStringExpr
mkFloatLit :: Rational -> Expr b Source #
Create a machine single precision literal expression of type Float#
from a Rational
.
If you want an expression of type Float
use mkFloatExpr
mkFloatLitFloat :: Float -> Expr b Source #
Create a machine single precision literal expression of type Float#
from a Float
.
If you want an expression of type Float
use mkFloatExpr
mkDoubleLit :: Rational -> Expr b Source #
Create a machine double precision literal expression of type Double#
from a Rational
.
If you want an expression of type Double
use mkDoubleExpr
mkDoubleLitDouble :: Double -> Expr b Source #
Create a machine double precision literal expression of type Double#
from a Double
.
If you want an expression of type Double
use mkDoubleExpr
mkConApp :: DataCon -> [Arg b] -> Expr b Source #
Apply a list of argument expressions to a data constructor in a nested fashion. Prefer to
use mkCoreConApps
if possible
mkTyBind :: TyVar -> Type -> CoreBind Source #
Create a binding group where a type variable is bound to a type.
Per Note [Core type and coercion invariant],
this can only be used to bind something in a non-recursive let
expression
mkCoBind :: CoVar -> Coercion -> CoreBind Source #
Create a binding group where a type variable is bound to a type.
Per Note [Core type and coercion invariant],
this can only be used to bind something in a non-recursive let
expression
varToCoreExpr :: CoreBndr -> Expr b Source #
varsToCoreExprs :: [CoreBndr] -> [Expr b] Source #
Is this a value-level (i.e., computationally relevant) Id
entifier?
Satisfies isId = not . isTyVar
.
cmpAltCon :: AltCon -> AltCon -> Ordering Source #
Compares AltCon
s within a single list of alternatives
DEFAULT comes out smallest, so that sorting by AltCon puts
alternatives in the order required: see Note [Case expression invariants]
Simple Expr
access functions and predicates
bindersOfBinds :: [Bind b] -> [b] Source #
bindersOf
applied to a list of binding groups
rhssOfBind :: Bind b -> [Expr b] Source #
rhssOfAlts :: [Alt b] -> [Expr b] Source #
foldBindersOfBindStrict :: (a -> b -> a) -> a -> Bind b -> a Source #
foldBindersOfBindsStrict :: (a -> b -> a) -> a -> [Bind b] -> a Source #
collectBinders :: Expr b -> ([b], Expr b) Source #
We often want to strip off leading lambdas before getting down to
business. Variants are collectTyBinders
, collectValBinders
,
and collectTyAndValBinders
collectNBinders :: JoinArity -> Expr b -> ([b], Expr b) Source #
Strip off exactly N leading lambdas (type or value). Good for use with join points. Panic if there aren't enough
collectNValBinders_maybe :: Arity -> CoreExpr -> Maybe ([Var], CoreExpr) Source #
Strip off exactly N leading value lambdas returning all the binders found up to that point Return Nothing if there aren't enough
collectArgs :: Expr b -> (Expr b, [Arg b]) Source #
Takes a nested application expression and returns the function being applied and the arguments to which it is applied
collectValArgs :: Expr b -> (Expr b, [Arg b]) Source #
Takes a nested application expression and returns the function being applied and the arguments to which it is applied
stripNArgs :: Word -> Expr a -> Maybe (Expr a) Source #
Attempt to remove the last N arguments of a function call. Strip off any ticks or coercions encountered along the way and any at the end.
collectArgsTicks :: (CoreTickish -> Bool) -> Expr b -> (Expr b, [Arg b], [CoreTickish]) Source #
Like collectArgs
, but also looks through floatable
ticks if it means that we can find more arguments.
flattenBinds :: [Bind b] -> [(b, Expr b)] Source #
Collapse all the bindings in the supplied groups into a single
list of lhs/rhs pairs suitable for binding in a Rec
binding group
collectFunSimple :: Expr b -> Expr b Source #
Takes a nested application expression and returns the function being applied. Looking through casts and ticks to find it.
exprToType :: CoreExpr -> Type Source #
wrapLamBody :: (CoreExpr -> CoreExpr) -> CoreExpr -> CoreExpr Source #
fmap on the body of a lambda. wrapLamBody f (x -> body) == (x -> f body)
isValArg :: Expr b -> Bool Source #
Returns True
for value arguments, false for type args
NB: coercions are value arguments (zero width, to be sure,
like State#, but still value args).
isCoArg :: Expr b -> Bool Source #
Returns True
iff the expression is a Coercion
expression at its top level
valArgCount :: [Arg b] -> Int Source #
The number of argument expressions that are values rather than types at their top level
valBndrCount :: [CoreBndr] -> Int Source #
The number of binders that bind values rather than types
isRuntimeArg :: CoreExpr -> Bool Source #
Will this argument expression exist at runtime?
isRuntimeVar :: Var -> Bool Source #
Will this variable exist at runtime?
Unfolding data types
Records the unfolding of an identifier, which is approximately the form the identifier would have if we substituted its definition in for the identifier. This type should be treated as abstract everywhere except in GHC.Core.Unfold
NoUnfolding | We have no information about the unfolding. |
BootUnfolding | We have no information about the unfolding, because
this |
OtherCon [AltCon] | It ain't one of these constructors.
data C = C !(Int -> Int) case x of { C f -> ... } Here, |
DFunUnfolding | |
CoreUnfolding | An unfolding with redundant cached information. Parameters: uf_tmpl: Template used to perform unfolding; NB: Occurrence info is guaranteed correct: see Note [OccInfo in unfoldings and rules] uf_is_top: Is this a top level binding? uf_is_value: uf_is_work_free: Does this waste only a little work if we expand it inside an inlining?
Basically this is a cached version of uf_guidance: Tells us about the size of the unfolding template |
Instances
data UnfoldingCache Source #
Properties of a CoreUnfolding
that could be computed on-demand from its template.
See Note [UnfoldingCache]
UnfoldingCache | |
|
Instances
Outputable UnfoldingCache Source # | |
Defined in GHC.Core.Ppr ppr :: UnfoldingCache -> SDoc Source # | |
Eq UnfoldingCache Source # | |
Defined in GHC.Core (==) :: UnfoldingCache -> UnfoldingCache -> Bool # (/=) :: UnfoldingCache -> UnfoldingCache -> Bool # |
data UnfoldingGuidance Source #
UnfoldingGuidance
says when unfolding should take place
Instances
Outputable UnfoldingGuidance Source # | |
Defined in GHC.Core.Ppr ppr :: UnfoldingGuidance -> SDoc Source # | |
Eq UnfoldingGuidance Source # | |
Defined in GHC.Core (==) :: UnfoldingGuidance -> UnfoldingGuidance -> Bool # (/=) :: UnfoldingGuidance -> UnfoldingGuidance -> Bool # |
data UnfoldingSource Source #
Instances
Binary UnfoldingSource Source # | |
Defined in GHC.Types.Basic put_ :: WriteBinHandle -> UnfoldingSource -> IO () Source # put :: WriteBinHandle -> UnfoldingSource -> IO (Bin UnfoldingSource) Source # get :: ReadBinHandle -> IO UnfoldingSource Source # | |
Outputable UnfoldingSource Source # | |
Defined in GHC.Types.Basic ppr :: UnfoldingSource -> SDoc Source # |
Constructing Unfolding
s
noUnfolding :: Unfolding Source #
There is no known Unfolding
bootUnfolding :: Unfolding Source #
There is no known Unfolding
, because this came from an
hi-boot file.
evaldUnfolding :: Unfolding Source #
This unfolding marks the associated thing as being evaluated
mkOtherCon :: [AltCon] -> Unfolding Source #
unSaturatedOk :: Bool Source #
needSaturated :: Bool Source #
boringCxtOk :: Bool Source #
Predicates and deconstruction on Unfolding
maybeUnfoldingTemplate :: Unfolding -> Maybe CoreExpr Source #
Retrieves the template of an unfolding if possible maybeUnfoldingTemplate is used mainly when specialising, and we do want to specialise DFuns, so it's important to return a template for DFunUnfoldings
otherCons :: Unfolding -> [AltCon] Source #
The constructors that the unfolding could never be:
returns []
if no information is available
isValueUnfolding :: Unfolding -> Bool Source #
Determines if it is certainly the case that the unfolding will
yield a value (something in HNF): returns False
if unsure
isEvaldUnfolding :: Unfolding -> Bool Source #
Determines if it possibly the case that the unfolding will
yield a value. Unlike isValueUnfolding
it returns True
for OtherCon
isCheapUnfolding :: Unfolding -> Bool Source #
Is the thing we will unfold into certainly cheap?
isConLikeUnfolding :: Unfolding -> Bool Source #
True
if the unfolding is a constructor application, the application
of a CONLIKE function or OtherCon
isStableUnfolding :: Unfolding -> Bool Source #
isInlineUnfolding :: Unfolding -> Bool Source #
True of a stable unfolding that is
(a) always inlined; that is, with an UnfWhen
guidance, or
(b) a DFunUnfolding which never needs to be inlined
isBootUnfolding :: Unfolding -> Bool Source #
hasCoreUnfolding :: Unfolding -> Bool Source #
hasSomeUnfolding :: Unfolding -> Bool Source #
Only returns False if there is no unfolding information available at all
isStableSource :: UnfoldingSource -> Bool Source #
Annotated expression data types
type AnnExpr bndr annot = (annot, AnnExpr' bndr annot) Source #
Annotated core: allows annotation at every node in the tree
data AnnExpr' bndr annot Source #
A clone of the Expr
type but allowing annotation at every tree node
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 CoreTickish (AnnExpr bndr annot) | |
AnnType Type | |
AnnCoercion Coercion |
Operations on annotated expressions
collectAnnArgs :: AnnExpr b a -> (AnnExpr b a, [AnnExpr b a]) Source #
Takes a nested application expression and returns the function being applied and the arguments to which it is applied
collectAnnArgsTicks :: (CoreTickish -> Bool) -> AnnExpr b a -> (AnnExpr b a, [AnnExpr b a], [CoreTickish]) Source #
Operations on annotations
deAnnotate :: AnnExpr bndr annot -> Expr bndr Source #
deAnnotate' :: AnnExpr' bndr annot -> Expr bndr Source #
collectAnnBndrs :: AnnExpr bndr annot -> ([bndr], AnnExpr bndr annot) Source #
As collectBinders
but for AnnExpr
rather than Expr
collectNAnnBndrs :: Int -> AnnExpr bndr annot -> ([bndr], AnnExpr bndr annot) Source #
As collectNBinders
but for AnnExpr
rather than Expr
Orphanhood
Is this instance an orphan? If it is not an orphan, contains an OccName
witnessing the instance's non-orphanhood.
See Note [Orphans]
Instances
Binary IsOrphan Source # | |
Data IsOrphan Source # | |
Defined in GHC.Core gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IsOrphan -> c IsOrphan # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c IsOrphan # toConstr :: IsOrphan -> Constr # dataTypeOf :: IsOrphan -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c IsOrphan) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IsOrphan) # gmapT :: (forall b. Data b => b -> b) -> IsOrphan -> IsOrphan # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IsOrphan -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IsOrphan -> r # gmapQ :: (forall d. Data d => d -> u) -> IsOrphan -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> IsOrphan -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> IsOrphan -> m IsOrphan # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IsOrphan -> m IsOrphan # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IsOrphan -> m IsOrphan # |
chooseOrphanAnchor :: NameSet -> IsOrphan Source #
Core rule data types
A CoreRule
is:
- "Local" if the function it is a rule for is defined in the same module as the rule itself.
- "Orphan" if nothing on the LHS is defined in the same module as the rule itself
Rule | |
| |
BuiltinRule | Built-in rules are used for constant folding and suchlike. They have no free variables. A built-in rule is always visible (there is no such thing as an orphan built-in rule.) |
Instances
type RuleName = FastString Source #
type IdUnfoldingFun = Id -> Unfolding Source #
data InScopeEnv Source #
The InScopeSet
in the InScopeEnv
is a superset of variables that are
currently in scope. See Note [The InScopeSet invariant].
Operations on CoreRule
s
ruleArity :: CoreRule -> Int Source #
The number of arguments the ru_fn
must be applied
to before the rule can match on it
ruleActivation :: CoreRule -> Activation Source #
isBuiltinRule :: CoreRule -> Bool Source #
isLocalRule :: CoreRule -> Bool Source #
isAutoRule :: CoreRule -> Bool Source #