| Safe Haskell | Safe-Inferred |
|---|---|
| Language | Haskell2010 |
GHC.Core
Description
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
- 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]
- 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]
- collectBinders :: Expr b -> ([b], Expr b)
- collectTyBinders :: CoreExpr -> ([TyVar], CoreExpr)
- collectTyAndValBinders :: CoreExpr -> ([TyVar], [Id], CoreExpr)
- collectNBinders :: Int -> Expr b -> ([b], Expr b)
- collectArgs :: 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)]
- exprToType :: CoreExpr -> Type
- exprToCoercion_maybe :: CoreExpr -> Maybe Coercion
- applyTypeToArg :: Type -> CoreExpr -> Type
- 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 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
- unfoldingTemplate :: Unfolding -> CoreExpr
- 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
- hasCoreUnfolding :: Unfolding -> Bool
- hasSomeUnfolding :: Unfolding -> Bool
- isBootUnfolding :: 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 RuleBase = NameEnv [CoreRule]
- type RuleName = FastString
- type RuleFun = RuleOpts -> InScopeEnv -> Id -> [CoreExpr] -> Maybe CoreExpr
- type IdUnfoldingFun = Id -> Unfolding
- type InScopeEnv = (InScopeSet, IdUnfoldingFun)
- data RuleEnv = RuleEnv {}
- data RuleOpts = RuleOpts {}
- mkRuleEnv :: RuleBase -> [Module] -> RuleEnv
- emptyRuleEnv :: RuleEnv
- 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
HsExprwith the names beingRdrNames - This syntax tree is renamed, which attaches a
Uniqueto 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 Uniques 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] below.
- The resulting syntax tree undergoes type checking (which also deals with instantiating
type class arguments) to yield a
HsExprtype that hasIdas it's names. - Finally the syntax tree is desugared from the expressive
HsExprtype into thisExprtype, 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
Expr. See Note [Core let/app invariant] See Note [Levity polymorphism invariants] - Lambda abstraction See Note [Levity polymorphism invariants]
- Recursive and non recursive
lets. 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/app invariant] See Note [Levity 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 Expr 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
newtypes (anewtypeconstructor or destructor just becomes aCastin 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
Constructors
| 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
| Data b => Data (Expr b) # | |
Defined in GHC.Core Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Expr b -> c (Expr b) Source # gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Expr b) Source # toConstr :: Expr b -> Constr Source # dataTypeOf :: Expr b -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Expr b)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Expr b)) Source # gmapT :: (forall b0. Data b0 => b0 -> b0) -> Expr b -> Expr b Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expr b -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expr b -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Expr b -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Expr b -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Expr b -> m (Expr b) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Expr b -> m (Expr b) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Expr b -> m (Expr b) Source # | |
| OutputableBndr b => Outputable (Expr b) # | |
Defined in GHC.Core.Ppr | |
| Eq (DeBruijn CoreExpr) # | |
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
| Data b => Data (Alt b) # | |
Defined in GHC.Core Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Alt b -> c (Alt b) Source # gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Alt b) Source # toConstr :: Alt b -> Constr Source # dataTypeOf :: Alt b -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Alt b)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Alt b)) Source # gmapT :: (forall b0. Data b0 => b0 -> b0) -> Alt b -> Alt b Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alt b -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Alt b -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Alt b -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Alt b -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Alt b -> m (Alt b) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Alt b -> m (Alt b) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Alt b -> m (Alt b) Source # | |
| OutputableBndr b => Outputable (Alt b) # | |
Defined in GHC.Core.Ppr | |
| Eq (DeBruijn CoreAlt) # | |
Binding, used for top level bindings in a module and local bindings in a let.
Instances
| Data b => Data (Bind b) # | |
Defined in GHC.Core Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Bind b -> c (Bind b) Source # gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Bind b) Source # toConstr :: Bind b -> Constr Source # dataTypeOf :: Bind b -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Bind b)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Bind b)) Source # gmapT :: (forall b0. Data b0 => b0 -> b0) -> Bind b -> Bind b Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bind b -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bind b -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Bind b -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Bind b -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Bind b -> m (Bind b) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Bind b -> m (Bind b) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Bind b -> m (Bind b) Source # | |
| OutputableBndr b => Outputable (Bind b) # | |
Defined in GHC.Core.Ppr | |
A case alternative constructor (i.e. pattern match)
Constructors
| DataAlt DataCon | |
| LitAlt Literal | A literal: |
| DEFAULT | Trivial alternative: |
Instances
| Data AltCon # | |
Defined in GHC.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AltCon -> c AltCon Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AltCon Source # toConstr :: AltCon -> Constr Source # dataTypeOf :: AltCon -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AltCon) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AltCon) Source # gmapT :: (forall b. Data b => b -> b) -> AltCon -> AltCon Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AltCon -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AltCon -> r Source # gmapQ :: (forall d. Data d => d -> u) -> AltCon -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> AltCon -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AltCon -> m AltCon Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AltCon -> m AltCon Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AltCon -> m AltCon Source # | |
| Outputable AltCon # | |
| Eq AltCon # | |
| Ord AltCon # | |
type CoreProgram = [CoreBind] #
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) #
type TaggedAlt t = Alt (TaggedBndr t) #
type TaggedBind t = Bind (TaggedBndr t) #
type TaggedArg t = Arg (TaggedBndr t) #
data TaggedBndr t #
Binders are tagged with a t
Instances
| Outputable b => Outputable (TaggedBndr b) # | |
Defined in GHC.Core Methods ppr :: TaggedBndr b -> SDoc # | |
| Outputable b => OutputableBndr (TaggedBndr b) # | |
Defined in GHC.Core.Ppr Methods pprBndr :: BindingSite -> TaggedBndr b -> SDoc # pprPrefixOcc :: TaggedBndr b -> SDoc # pprInfixOcc :: TaggedBndr b -> SDoc # bndrIsJoin_maybe :: TaggedBndr b -> Maybe Int # | |
deTagExpr :: TaggedExpr t -> CoreExpr #
In/Out type synonyms
type InCoercion = Coercion #
type OutCoercion = Coercion #
type MOutCoercion = MCoercion #
Expr construction
mkLets :: [Bind b] -> Expr b -> Expr b #
Bind all supplied binding groups over an expression in a nested let expression. Assumes
that the rhs satisfies the let/app invariant. Prefer to use mkCoreLets if
possible, which does guarantee the invariant
mkLetNonRec :: b -> Expr b -> Expr b -> Expr b #
mkLetNonRec bndr rhs body wraps body in a let binding bndr.
mkLetRec :: [(b, Expr b)] -> Expr b -> Expr b #
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 #
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 #
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 #
Apply a list of type argument expressions to a function expression in a nested fashion
mkCoApps :: Expr b -> [Coercion] -> Expr b infixl 4 #
Apply a list of coercion argument expressions to a function expression in a nested fashion
mkVarApps :: Expr b -> [Var] -> Expr b infixl 4 #
Apply a list of type or value variables to a function expression in a nested fashion
mkIntLit :: Platform -> Integer -> Expr b #
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 #
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 #
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 #
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 #
mkWord64LitWord64 :: Word64 -> Expr b #
mkInt64LitInt64 :: Int64 -> Expr b #
Create a machine character literal expression of type Char#.
If you want an expression of type Char use mkCharExpr
mkStringLit :: String -> Expr b #
Create a machine string literal expression of type Addr#.
If you want an expression of type String use mkStringExpr
mkFloatLit :: Rational -> Expr b #
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 #
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 #
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 #
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 #
Apply a list of argument expressions to a data constructor in a nested fashion. Prefer to
use mkCoreConApps if possible
mkTyBind :: TyVar -> Type -> CoreBind #
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 #
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
varsToCoreExprs :: [CoreBndr] -> [Expr b] #
Is this a value-level (i.e., computationally relevant) Varentifier?
Satisfies isId = not . isTyVar.
cmpAltCon :: AltCon -> AltCon -> Ordering #
Compares AltCons 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] #
bindersOf applied to a list of binding groups
rhssOfBind :: Bind b -> [Expr b] #
rhssOfAlts :: [Alt b] -> [Expr b] #
collectBinders :: Expr b -> ([b], Expr b) #
We often want to strip off leading lambdas before getting down to
business. Variants are collectTyBinders, collectValBinders,
and collectTyAndValBinders
collectTyBinders :: CoreExpr -> ([TyVar], CoreExpr) #
collectNBinders :: Int -> Expr b -> ([b], Expr b) #
Strip off exactly N leading lambdas (type or value). Good for use with join points.
collectArgs :: Expr b -> (Expr b, [Arg b]) #
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) #
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]) #
Like collectArgs, but also collects looks through floatable
ticks if it means that we can find more arguments.
flattenBinds :: [Bind b] -> [(b, Expr b)] #
Collapse all the bindings in the supplied groups into a single
list of lhs/rhs pairs suitable for binding in a Rec binding group
exprToType :: CoreExpr -> Type #
applyTypeToArg :: Type -> CoreExpr -> Type #
Determines the type resulting from applying an expression with given type to a given argument expression
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).
valArgCount :: [Arg b] -> Int #
The number of argument expressions that are values rather than types at their top level
valBndrCount :: [CoreBndr] -> Int #
The number of binders that bind values rather than types
isRuntimeArg :: CoreExpr -> Bool #
Will this argument expression exist at runtime?
isRuntimeVar :: Var -> Bool #
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
Constructors
| 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 |
Fields
| |
Instances
| Outputable Unfolding # | |
Defined in GHC.Core.Ppr | |
data UnfoldingGuidance #
UnfoldingGuidance says when unfolding should take place
Constructors
| UnfWhen | |
Fields
| |
| UnfIfGoodArgs | |
| UnfNever | |
Instances
| Outputable UnfoldingGuidance # | |
Defined in GHC.Core.Ppr Methods ppr :: UnfoldingGuidance -> SDoc # | |
| Eq UnfoldingGuidance # | |
Defined in GHC.Core Methods (==) :: UnfoldingGuidance -> UnfoldingGuidance -> Bool # (/=) :: UnfoldingGuidance -> UnfoldingGuidance -> Bool # | |
data UnfoldingSource #
Constructors
| InlineRhs | |
| InlineStable | |
| InlineCompulsory |
Instances
| Outputable UnfoldingSource # | |
Defined in GHC.Core.Ppr Methods ppr :: UnfoldingSource -> SDoc # | |
Constructing Unfoldings
There is no known Unfolding
There is no known Unfolding, because this came from an
hi-boot file.
This unfolding marks the associated thing as being evaluated
mkOtherCon :: [AltCon] -> Unfolding #
unSaturatedOk :: Bool #
needSaturated :: Bool #
boringCxtOk :: Bool #
boringCxtNotOk :: Bool #
Predicates and deconstruction on Unfolding
unfoldingTemplate :: Unfolding -> CoreExpr #
Retrieves the template of an unfolding: panics if none is known
maybeUnfoldingTemplate :: Unfolding -> Maybe CoreExpr #
Retrieves the template of an unfolding if possible maybeUnfoldingTemplate is used mainly wnen specialising, and we do want to specialise DFuns, so it's important to return a template for DFunUnfoldings
otherCons :: Unfolding -> [AltCon] #
The constructors that the unfolding could never be:
returns [] if no information is available
isValueUnfolding :: Unfolding -> Bool #
Determines if it is certainly the case that the unfolding will
yield a value (something in HNF): returns False if unsure
isEvaldUnfolding :: Unfolding -> Bool #
Determines if it possibly the case that the unfolding will
yield a value. Unlike isValueUnfolding it returns True
for OtherCon
isCheapUnfolding :: Unfolding -> Bool #
Is the thing we will unfold into certainly cheap?
isExpandableUnfolding :: Unfolding -> Bool #
isConLikeUnfolding :: Unfolding -> Bool #
True if the unfolding is a constructor application, the application
of a CONLIKE function or OtherCon
isCompulsoryUnfolding :: Unfolding -> Bool #
isStableUnfolding :: Unfolding -> Bool #
hasCoreUnfolding :: Unfolding -> Bool #
hasSomeUnfolding :: Unfolding -> Bool #
Only returns False if there is no unfolding information available at all
isBootUnfolding :: Unfolding -> Bool #
isStableSource :: UnfoldingSource -> Bool #
Annotated expression data types
type AnnExpr bndr annot = (annot, AnnExpr' bndr annot) #
Annotated core: allows annotation at every node in the tree
A clone of the Expr type but allowing annotation at every tree node
Constructors
| 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 |
A clone of the Bind type but allowing annotation at every tree node
A clone of the Alt type but allowing annotation at every tree node
Operations on annotated expressions
collectAnnArgs :: AnnExpr b a -> (AnnExpr b a, [AnnExpr b a]) #
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]) #
Operations on annotations
deAnnotate :: AnnExpr bndr annot -> Expr bndr #
deAnnotate' :: AnnExpr' bndr annot -> Expr bndr #
collectAnnBndrs :: AnnExpr bndr annot -> ([bndr], AnnExpr bndr annot) #
As collectBinders but for AnnExpr rather than Expr
collectNAnnBndrs :: Int -> AnnExpr bndr annot -> ([bndr], AnnExpr bndr annot) #
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
| Data IsOrphan # | |
Defined in GHC.Core Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IsOrphan -> c IsOrphan Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c IsOrphan Source # toConstr :: IsOrphan -> Constr Source # dataTypeOf :: IsOrphan -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c IsOrphan) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IsOrphan) Source # gmapT :: (forall b. Data b => b -> b) -> IsOrphan -> IsOrphan Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IsOrphan -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IsOrphan -> r Source # gmapQ :: (forall d. Data d => d -> u) -> IsOrphan -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> IsOrphan -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> IsOrphan -> m IsOrphan Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IsOrphan -> m IsOrphan Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IsOrphan -> m IsOrphan Source # | |
| Binary IsOrphan # | |
chooseOrphanAnchor :: NameSet -> IsOrphan #
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
Constructors
| Rule | |
Fields
| |
| 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.) |
Fields | |
Instances
| Outputable CoreRule # | |
Defined in GHC.Core.Ppr | |
type RuleName = FastString #
type IdUnfoldingFun = Id -> Unfolding #
type InScopeEnv = (InScopeSet, IdUnfoldingFun) #
A full rule environment which we can apply rules from. Like a RuleBase,
but it also includes the set of visible orphans we use to filter out orphan
rules which are not visible (even though we can see them...)
Constructors
| RuleEnv | |
Fields | |
Rule options
Constructors
| RuleOpts | |
Fields
| |
emptyRuleEnv :: RuleEnv #
Operations on CoreRules
ruleArity :: CoreRule -> Int #
The number of arguments the ru_fn must be applied
to before the rule can match on it
ruleActivation :: CoreRule -> Activation #
setRuleIdName :: Name -> CoreRule -> CoreRule #
ruleModule :: CoreRule -> Maybe Module #
isBuiltinRule :: CoreRule -> Bool #
isLocalRule :: CoreRule -> Bool #
isAutoRule :: CoreRule -> Bool #