CoreSubst

ghc-7.10.3: The GHC API

Safe Haskell | None
Language | Haskell2010

CoreSubst

Contents

- Main data types
  - Substituting into expressions and related types
  - Operations on substitutions
  - Substituting and cloning binders
  - Simple expression optimiser

Synopsis

- data Subst = Subst InScopeSet IdSubstEnv TvSubstEnv CvSubstEnv
- type TvSubstEnv = TyVarEnv Type
- data IdSubstEnv
- data InScopeSet
- deShadowBinds :: CoreProgram -> CoreProgram
- substSpec :: Subst -> Id -> SpecInfo -> SpecInfo
- substRulesForImportedIds :: Subst -> [CoreRule] -> [CoreRule]
- substTy :: Subst -> Type -> Type
- substCo :: Subst -> Coercion -> Coercion
- substExpr :: SDoc -> Subst -> CoreExpr -> CoreExpr
- substExprSC :: SDoc -> Subst -> CoreExpr -> CoreExpr
- substBind :: Subst -> CoreBind -> (Subst, CoreBind)
- substBindSC :: Subst -> CoreBind -> (Subst, CoreBind)
- substUnfolding :: Subst -> Unfolding -> Unfolding
- substUnfoldingSC :: Subst -> Unfolding -> Unfolding
- lookupIdSubst :: SDoc -> Subst -> Id -> CoreExpr
- lookupTvSubst :: Subst -> TyVar -> Type
- lookupCvSubst :: Subst -> CoVar -> Coercion
- substIdOcc :: Subst -> Id -> Id
- substTickish :: Subst -> Tickish Id -> Tickish Id
- substVarSet :: Subst -> VarSet -> VarSet
- emptySubst :: Subst
- mkEmptySubst :: InScopeSet -> Subst
- mkGblSubst :: InScopeSet -> TvSubstEnv -> CvSubstEnv -> (InScopeSet -> Id -> Maybe CoreExpr) -> Subst
- mkOpenSubst :: InScopeSet -> [(Var, CoreArg)] -> Subst
- substInScope :: Subst -> InScopeSet
- isEmptySubst :: Subst -> Bool
- extendIdSubst :: Subst -> Id -> CoreExpr -> Subst
- extendIdSubstList :: Subst -> [(Id, CoreExpr)] -> Subst
- extendTvSubst :: Subst -> TyVar -> Type -> Subst
- extendTvSubstList :: Subst -> [(TyVar, Type)] -> Subst
- extendCvSubst :: Subst -> CoVar -> Coercion -> Subst
- extendCvSubstList :: Subst -> [(CoVar, Coercion)] -> Subst
- extendSubst :: Subst -> Var -> CoreArg -> Subst
- extendSubstList :: Subst -> [(Var, CoreArg)] -> Subst
- extendSubstWithVar :: Subst -> Var -> Var -> Subst
- zapSubstEnv :: Subst -> Subst
- addInScopeSet :: Subst -> VarSet -> Subst
- extendInScope :: Subst -> Var -> Subst
- extendInScopeList :: Subst -> [Var] -> Subst
- extendInScopeIds :: Subst -> [Id] -> Subst
- isInScope :: Var -> Subst -> Bool
- setInScope :: Subst -> InScopeSet -> Subst
- delBndr :: Subst -> Var -> Subst
- delBndrs :: Subst -> [Var] -> Subst
- substBndr :: Subst -> Var -> (Subst, Var)
- substBndrs :: Subst -> [Var] -> (Subst, [Var])
- substRecBndrs :: Subst -> [Id] -> (Subst, [Id])
- cloneBndr :: Subst -> Unique -> Var -> (Subst, Var)
- cloneBndrs :: Subst -> UniqSupply -> [Var] -> (Subst, [Var])
- cloneIdBndr :: Subst -> UniqSupply -> Id -> (Subst, Id)
- cloneIdBndrs :: Subst -> UniqSupply -> [Id] -> (Subst, [Id])
- cloneRecIdBndrs :: Subst -> UniqSupply -> [Id] -> (Subst, [Id])
- simpleOptPgm :: DynFlags -> Module -> CoreProgram -> [CoreRule] -> [CoreVect] -> IO (CoreProgram, [CoreRule], [CoreVect])
- simpleOptExpr :: CoreExpr -> CoreExpr
- simpleOptExprWith :: Subst -> InExpr -> OutExpr
- exprIsConApp_maybe :: InScopeEnv -> CoreExpr -> Maybe (DataCon, [Type], [CoreExpr])
- exprIsLiteral_maybe :: InScopeEnv -> CoreExpr -> Maybe Literal
- exprIsLambda_maybe :: InScopeEnv -> CoreExpr -> Maybe (Var, CoreExpr, [Tickish Id])

# Main data types

data Subst

A substitution environment, containing both `Id` and `TyVar` substitutions.

Some invariants apply to how you use the substitution:

1. The in-scope set contains at least those `Id`s and `TyVar`s that will be in scope after applying the substitution to a term. Precisely, the in-scope set must be a superset of the free vars of the substitution range that might possibly clash with locally-bound variables in the thing being substituted in.
2. You may apply the substitution only once

There are various ways of setting up the in-scope set such that the first of these invariants hold:

- Arrange that the in-scope set really is all the things in scope
- Arrange that it's the free vars of the range of the substitution
- Make it empty, if you know that all the free vars of the substitution are fresh, and hence can't possibly clash

Constructors

Subst InScopeSet IdSubstEnv TvSubstEnv CvSubstEnv |

Instances

Outputable Subst |

type TvSubstEnv = TyVarEnv Type

A substitution of `Type`s for `TyVar`s and `Kind`s for `KindVar`s

data IdSubstEnv

An environment for substituting for `Id`s See Note [IdSubstEnv]

Instances

Outputable IdSubstEnv |

data InScopeSet

A set of variables that are in scope at some point

Instances

Outputable InScopeSet |

## Substituting into expressions and related types

deShadowBinds :: CoreProgram -> CoreProgram

De-shadowing the program is sometimes a useful pre-pass. It can be done simply by running over the bindings with an empty substitution, because substitution returns a result that has no-shadowing guaranteed.

(Actually, within a single type there might still be shadowing, because `substTy` is a no-op for the empty substitution, but that's probably OK.)

Aug 09
  This function is not used in GHC at the moment, but seems so short and simple that I'm going to leave it here

substSpec :: Subst -> Id -> SpecInfo -> SpecInfo

Substitutes for the `Id`s within the `WorkerInfo` given the new function `Id`

substRulesForImportedIds :: Subst -> [CoreRule] -> [CoreRule]

substTy :: Subst -> Type -> Type

See `substTy`

substCo :: Subst -> Coercion -> Coercion

See `substCo`

substExpr :: SDoc -> Subst -> CoreExpr -> CoreExpr

substExprSC :: SDoc -> Subst -> CoreExpr -> CoreExpr

Apply a substitution to an entire `CoreExpr`. Remember, you may only apply the substitution once: see CoreSubst

Do *not* attempt to short-cut in the case of an empty substitution! See Note [Extending the Subst]

substBind :: Subst -> CoreBind -> (Subst, CoreBind)

Apply a substitution to an entire `CoreBind`, additionally returning an updated `Subst` that should be used by subsequent substitutions.

substBindSC :: Subst -> CoreBind -> (Subst, CoreBind)

Apply a substitution to an entire `CoreBind`, additionally returning an updated `Subst` that should be used by subsequent substitutions.

substUnfolding :: Subst -> Unfolding -> Unfolding

Substitutes for the `Id`s within an unfolding

substUnfoldingSC :: Subst -> Unfolding -> Unfolding

Substitutes for the `Id`s within an unfolding

lookupIdSubst :: SDoc -> Subst -> Id -> CoreExpr

Find the substitution for an `Id` in the `Subst`

lookupTvSubst :: Subst -> TyVar -> Type

Find the substitution for a `TyVar` in the `Subst`

lookupCvSubst :: Subst -> CoVar -> Coercion

Find the coercion substitution for a `CoVar` in the `Subst`

substIdOcc :: Subst -> Id -> Id

substTickish :: Subst -> Tickish Id -> Tickish Id

substVarSet :: Subst -> VarSet -> VarSet

## Operations on substitutions

emptySubst :: Subst

mkEmptySubst :: InScopeSet -> Subst

mkGblSubst :: InScopeSet -> TvSubstEnv -> CvSubstEnv -> (InScopeSet -> Id -> Maybe CoreExpr) -> Subst

mkOpenSubst :: InScopeSet -> [(Var, CoreArg)] -> Subst

Simultaneously substitute for a bunch of variables No left-right shadowing ie the substitution for (x y. e) a1 a2 so neither x nor y scope over a1 a2

substInScope :: Subst -> InScopeSet

Find the in-scope set: see CoreSubst

isEmptySubst :: Subst -> Bool

extendIdSubst :: Subst -> Id -> CoreExpr -> Subst

Add a substitution for an `Id` to the `Subst`: you must ensure that the in-scope set is such that the CoreSubst is true after extending the substitution like this

extendIdSubstList :: Subst -> [(Id, CoreExpr)] -> Subst

Adds multiple `Id` substitutions to the `Subst`: see also `extendIdSubst`

extendTvSubst :: Subst -> TyVar -> Type -> Subst

Add a substitution for a `TyVar` to the `Subst`: you must ensure that the in-scope set is such that the CoreSubst is true after extending the substitution like this

extendTvSubstList :: Subst -> [(TyVar, Type)] -> Subst

Adds multiple `TyVar` substitutions to the `Subst`: see also `extendTvSubst`

extendCvSubst :: Subst -> CoVar -> Coercion -> Subst

Add a substitution from a `CoVar` to a `Coercion` to the `Subst`: you must ensure that the in-scope set is such that the CoreSubst is true after extending the substitution like this

extendCvSubstList :: Subst -> [(CoVar, Coercion)] -> Subst

Adds multiple `CoVar` -> `Coercion` substitutions to the `Subst`: see also `extendCvSubst`

extendSubst :: Subst -> Var -> CoreArg -> Subst

Add a substitution appropriate to the thing being substituted (whether an expression, type, or coercion). See also `extendIdSubst`, `extendTvSubst`, and `extendCvSubst`.

extendSubstList :: Subst -> [(Var, CoreArg)] -> Subst

Add a substitution as appropriate to each of the terms being substituted (whether expressions, types, or coercions). See also `extendSubst`.

extendSubstWithVar :: Subst -> Var -> Var -> Subst

zapSubstEnv :: Subst -> Subst

Remove all substitutions for `Id`s and `Var`s that might have been built up while preserving the in-scope set

addInScopeSet :: Subst -> VarSet -> Subst

Add the `Var` to the in-scope set, but do not remove any existing substitutions for it

extendInScope :: Subst -> Var -> Subst

Add the `Var` to the in-scope set: as a side effect, and remove any existing substitutions for it

extendInScopeList :: Subst -> [Var] -> Subst

Add the `Var`s to the in-scope set: see also `extendInScope`

extendInScopeIds :: Subst -> [Id] -> Subst

Optimized version of `extendInScopeList` that can be used if you are certain all the things being added are `Id`s and hence none are `TyVar`s or `CoVar`s

isInScope :: Var -> Subst -> Bool

setInScope :: Subst -> InScopeSet -> Subst

delBndr :: Subst -> Var -> Subst

delBndrs :: Subst -> [Var] -> Subst

## Substituting and cloning binders

substBndr :: Subst -> Var -> (Subst, Var)

Substitutes a `Var` for another one according to the `Subst` given, returning the result and an updated `Subst` that should be used by subsequent substitutions. `IdInfo` is preserved by this process, although it is substituted into appropriately.

substBndrs :: Subst -> [Var] -> (Subst, [Var])

Applies `substBndr` to a number of `Var`s, accumulating a new `Subst` left-to-right

substRecBndrs :: Subst -> [Id] -> (Subst, [Id])

Substitute in a mutually recursive group of `Id`s

cloneBndr :: Subst -> Unique -> Var -> (Subst, Var)

cloneBndrs :: Subst -> UniqSupply -> [Var] -> (Subst, [Var])

cloneIdBndr :: Subst -> UniqSupply -> Id -> (Subst, Id)

Very similar to `substBndr`, but it always allocates a new `Unique` for each variable in its output. It substitutes the IdInfo though.

cloneIdBndrs :: Subst -> UniqSupply -> [Id] -> (Subst, [Id])

Applies `cloneIdBndr` to a number of `Id`s, accumulating a final substitution from left to right

cloneRecIdBndrs :: Subst -> UniqSupply -> [Id] -> (Subst, [Id])

Clone a mutually recursive group of `Id`s

## Simple expression optimiser

simpleOptPgm :: DynFlags -> Module -> CoreProgram -> [CoreRule] -> [CoreVect] -> IO (CoreProgram, [CoreRule], [CoreVect])

simpleOptExpr :: CoreExpr -> CoreExpr

simpleOptExprWith :: Subst -> InExpr -> OutExpr

exprIsConApp_maybe :: InScopeEnv -> CoreExpr -> Maybe (DataCon, [Type], [CoreExpr])

Returns `Just (dc, [t1..tk], [x1..xn])` if the argument expression is a *saturated* constructor application of the form `dc t1..tk x1 .. xn`, where t1..tk are the *universally-qantified* type args of `dc`

exprIsLiteral_maybe :: InScopeEnv -> CoreExpr -> Maybe Literal

exprIsLambda_maybe :: InScopeEnv -> CoreExpr -> Maybe (Var, CoreExpr, [Tickish Id])