GHC.Types.Var.Env

Var, Id and TyVar environments (maps)

type VarEnv elt = UniqFM Var elt

Variable Environment

type IdEnv elt = UniqFM Id elt

Identifier Environment

type TyVarEnv elt = UniqFM Var elt

Type Variable Environment

type CoVarEnv elt = UniqFM CoVar elt

Coercion Variable Environment

type TyCoVarEnv elt = UniqFM TyCoVar elt

Type or Coercion Variable Environment

Manipulating these environments

emptyVarEnv :: VarEnv a

unitVarEnv :: Var -> a -> VarEnv a

mkVarEnv :: [(Var, a)] -> VarEnv a

mkVarEnv_Directly :: [(Unique, a)] -> VarEnv a

elemVarEnv :: Var -> VarEnv a -> Bool

disjointVarEnv :: VarEnv a -> VarEnv a -> Bool

anyVarEnv :: (elt -> Bool) -> UniqFM key elt -> Bool

extendVarEnv :: VarEnv a -> Var -> a -> VarEnv a

extendVarEnv_C :: (a -> a -> a) -> VarEnv a -> Var -> a -> VarEnv a

extendVarEnv_Acc :: (a -> b -> b) -> (a -> b) -> VarEnv b -> Var -> a -> VarEnv b

extendVarEnvList :: VarEnv a -> [(Var, a)] -> VarEnv a

plusVarEnv :: VarEnv a -> VarEnv a -> VarEnv a

plusVarEnv_C :: (a -> a -> a) -> VarEnv a -> VarEnv a -> VarEnv a

plusVarEnv_CD :: (a -> a -> a) -> VarEnv a -> a -> VarEnv a -> a -> VarEnv a

plusMaybeVarEnv_C :: (a -> a -> Maybe a) -> VarEnv a -> VarEnv a -> VarEnv a

plusVarEnvList :: [VarEnv a] -> VarEnv a

alterVarEnv :: (Maybe a -> Maybe a) -> VarEnv a -> Var -> VarEnv a

delVarEnvList :: VarEnv a -> [Var] -> VarEnv a

delVarEnv :: VarEnv a -> Var -> VarEnv a

minusVarEnv :: VarEnv a -> VarEnv b -> VarEnv a

lookupVarEnv :: VarEnv a -> Var -> Maybe a

lookupVarEnv_NF :: VarEnv a -> Var -> a

lookupWithDefaultVarEnv :: VarEnv a -> a -> Var -> a

lookupVarEnv_Directly :: VarEnv a -> Unique -> Maybe a

mapVarEnv :: (a -> b) -> VarEnv a -> VarEnv b

zipVarEnv :: [Var] -> [a] -> VarEnv a

modifyVarEnv :: (a -> a) -> VarEnv a -> Var -> VarEnv a

modifyVarEnv_Directly :: (a -> a) -> UniqFM key a -> Unique -> UniqFM key a

isEmptyVarEnv :: VarEnv a -> Bool

elemVarEnvByKey :: Unique -> VarEnv a -> Bool

filterVarEnv :: (a -> Bool) -> VarEnv a -> VarEnv a

restrictVarEnv :: VarEnv a -> VarSet -> VarEnv a

Only keep variables contained in the VarSet

partitionVarEnv :: (a -> Bool) -> VarEnv a -> (VarEnv a, VarEnv a)

varEnvDomain :: VarEnv elt -> UnVarSet

nonDetStrictFoldVarEnv_Directly :: (Unique -> a -> r -> r) -> r -> VarEnv a -> r

Deterministic Var environments (maps)

type DVarEnv elt = UniqDFM Var elt

Deterministic Variable Environment

type DIdEnv elt = UniqDFM Var elt

Deterministic Identifier Environment Sadly not always indexed by Id, but it is in the common case.

type DTyVarEnv elt = UniqDFM TyVar elt

Deterministic Type Variable Environment

Manipulating these environments

emptyDVarEnv :: DVarEnv a

mkDVarEnv :: [(Var, a)] -> DVarEnv a

dVarEnvElts :: DVarEnv a -> [a]

extendDVarEnv :: DVarEnv a -> Var -> a -> DVarEnv a

extendDVarEnv_C :: (a -> a -> a) -> DVarEnv a -> Var -> a -> DVarEnv a

extendDVarEnvList :: DVarEnv a -> [(Var, a)] -> DVarEnv a

lookupDVarEnv :: DVarEnv a -> Var -> Maybe a

elemDVarEnv :: Var -> DVarEnv a -> Bool

isEmptyDVarEnv :: DVarEnv a -> Bool

foldDVarEnv :: (a -> b -> b) -> b -> DVarEnv a -> b

nonDetStrictFoldDVarEnv :: (a -> b -> b) -> b -> DVarEnv a -> b

mapDVarEnv :: (a -> b) -> DVarEnv a -> DVarEnv b

filterDVarEnv :: (a -> Bool) -> DVarEnv a -> DVarEnv a

modifyDVarEnv :: (a -> a) -> DVarEnv a -> Var -> DVarEnv a

alterDVarEnv :: (Maybe a -> Maybe a) -> DVarEnv a -> Var -> DVarEnv a

plusDVarEnv :: DVarEnv a -> DVarEnv a -> DVarEnv a

plusDVarEnv_C :: (a -> a -> a) -> DVarEnv a -> DVarEnv a -> DVarEnv a

unitDVarEnv :: Var -> a -> DVarEnv a

delDVarEnv :: DVarEnv a -> Var -> DVarEnv a

delDVarEnvList :: DVarEnv a -> [Var] -> DVarEnv a

minusDVarEnv :: DVarEnv a -> DVarEnv a' -> DVarEnv a

partitionDVarEnv :: (a -> Bool) -> DVarEnv a -> (DVarEnv a, DVarEnv a)

anyDVarEnv :: (a -> Bool) -> DVarEnv a -> Bool

The InScopeSet type

newtype InScopeSet

A set of variables that are in scope at some point.

Note that this is a superset of the variables that are currently in scope. See Note [The InScopeSet invariant].

"Secrets of the Glasgow Haskell Compiler inliner" Section 3.2 provides the motivation for this abstraction.

Constructors

InScope VarSet

Instances

Outputable InScopeSet

Defined in GHC.Types.Var.Env

Methods

ppr :: InScopeSet -> SDoc

Operations on InScopeSets

emptyInScopeSet :: InScopeSet

mkInScopeSet :: VarSet -> InScopeSet

mkInScopeSetList :: [Var] -> InScopeSet

delInScopeSet :: InScopeSet -> Var -> InScopeSet

extendInScopeSet :: InScopeSet -> Var -> InScopeSet

extendInScopeSetList :: InScopeSet -> [Var] -> InScopeSet

extendInScopeSetSet :: InScopeSet -> VarSet -> InScopeSet

getInScopeVars :: InScopeSet -> VarSet

lookupInScope :: InScopeSet -> Var -> Maybe Var

Look up a variable the InScopeSet. This lets you map from the variable's identity (unique) to its full value.

lookupInScope_Directly :: InScopeSet -> Unique -> Maybe Var

unionInScope :: InScopeSet -> InScopeSet -> InScopeSet

elemInScopeSet :: Var -> InScopeSet -> Bool

uniqAway :: InScopeSet -> Var -> Var

uniqAway in_scope v finds a unique that is not used in the in-scope set, and gives that to v. See Note [Local uniques] and Note [The InScopeSet invariant].

varSetInScope :: VarSet -> InScopeSet -> Bool

unsafeGetFreshLocalUnique :: InScopeSet -> Unique

unsafeGetFreshUnique in_scope finds a unique that is not in-scope in the given InScopeSet. This must be used very carefully since one can very easily introduce non-unique Uniques this way. See Note [Local uniques].

The RnEnv2 type

data RnEnv2

Rename Environment 2

When we are comparing (or matching) types or terms, we are faced with "going under" corresponding binders. E.g. when comparing:

\x. e1     ~   \y. e2

Basically we want to rename [x -> y] or [y -> x], but there are lots of things we must be careful of. In particular, x might be free in e2, or y in e1. So the idea is that we come up with a fresh binder that is free in neither, and rename x and y respectively. That means we must maintain:

1. A renaming for the left-hand expression
2. A renaming for the right-hand expressions
3. An in-scope set

Furthermore, when matching, we want to be able to have an 'occurs check', to prevent:

\x. f   ~   \y. y

matching with [f -> y]. So for each expression we want to know that set of locally-bound variables. That is precisely the domain of the mappings 1. and 2., but we must ensure that we always extend the mappings as we go in.

All of this information is bundled up in the RnEnv2

Operations on RnEnv2s

mkRnEnv2 :: InScopeSet -> RnEnv2

rnBndr2 :: RnEnv2 -> Var -> Var -> RnEnv2

rnBndr2 env bL bR goes under a binder bL in the Left term, and binder bR in the Right term. It finds a new binder, new_b, and returns an environment mapping bL -> new_b and bR -> new_b

rnBndrs2 :: RnEnv2 -> [Var] -> [Var] -> RnEnv2

Applies rnBndr2 to several variables: the two variable lists must be of equal length

rnBndr2_var :: RnEnv2 -> Var -> Var -> (RnEnv2, Var)

Similar to rnBndr2 but returns the new variable as well as the new environment. Postcondition: the type of the returned Var is that of bR

rnOccL :: RnEnv2 -> Var -> Var

Look up the renaming of an occurrence in the left or right term

rnOccR :: RnEnv2 -> Var -> Var

Look up the renaming of an occurrence in the left or right term

inRnEnvL :: RnEnv2 -> Var -> Bool

Tells whether a variable is locally bound

inRnEnvR :: RnEnv2 -> Var -> Bool

Tells whether a variable is locally bound

anyInRnEnvR :: RnEnv2 -> VarSet -> Bool

`anyInRnEnvR env set` == `any (inRnEnvR rn_env) (toList set)` but lazy in the second argument if the right side of the env is empty.

rnOccL_maybe :: RnEnv2 -> Var -> Maybe Var

Look up the renaming of an occurrence in the left or right term

rnOccR_maybe :: RnEnv2 -> Var -> Maybe Var

Look up the renaming of an occurrence in the left or right term

rnBndrL :: RnEnv2 -> Var -> (RnEnv2, Var)

Similar to rnBndr2 but used when there's a binder on the left side only.

rnBndrR :: RnEnv2 -> Var -> (RnEnv2, Var)

Similar to rnBndr2 but used when there's a binder on the right side only.

nukeRnEnvL :: RnEnv2 -> RnEnv2

Wipe the left or right side renaming

nukeRnEnvR :: RnEnv2 -> RnEnv2

Wipe the left or right side renaming

rnSwap :: RnEnv2 -> RnEnv2

swap the meaning of left and right

delBndrL :: RnEnv2 -> Var -> RnEnv2

delBndrR :: RnEnv2 -> Var -> RnEnv2

delBndrsL :: RnEnv2 -> [Var] -> RnEnv2

delBndrsR :: RnEnv2 -> [Var] -> RnEnv2

extendRnInScopeSetList :: RnEnv2 -> [Var] -> RnEnv2

rnEtaL :: RnEnv2 -> Var -> (RnEnv2, Var)

Similar to rnBndrL but used for eta expansion See Note [Eta expansion]

rnEtaR :: RnEnv2 -> Var -> (RnEnv2, Var)

Similar to rnBndr2 but used for eta expansion See Note [Eta expansion]

rnInScope :: Var -> RnEnv2 -> Bool

rnInScopeSet :: RnEnv2 -> InScopeSet

lookupRnInScope :: RnEnv2 -> Var -> Var

rnEnvL :: RnEnv2 -> VarEnv Var

Retrieve the left mapping

rnEnvR :: RnEnv2 -> VarEnv Var

Retrieve the right mapping

TidyEnv and its operation

type TidyEnv = (TidyOccEnv, VarEnv Var)

Tidy Environment

When tidying up print names, we keep a mapping of in-scope occ-names (the TidyOccEnv) and a Var-to-Var of the current renamings

emptyTidyEnv :: TidyEnv

mkEmptyTidyEnv :: TidyOccEnv -> TidyEnv

delTidyEnvList :: TidyEnv -> [Var] -> TidyEnv