| Safe Haskell | Safe-Inferred |
|---|---|
| Language | Haskell2010 |
GHC.Types.Var.Env
Synopsis
- type VarEnv elt = UniqFM Var elt
- type IdEnv elt = UniqFM Id elt
- type TyVarEnv elt = UniqFM Var elt
- type CoVarEnv elt = UniqFM CoVar elt
- type TyCoVarEnv elt = UniqFM TyCoVar elt
- 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
- 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
- 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
- partitionVarEnv :: (a -> Bool) -> VarEnv a -> (VarEnv a, VarEnv a)
- type DVarEnv elt = UniqDFM Var elt
- type DIdEnv elt = UniqDFM Var elt
- type DTyVarEnv elt = UniqDFM TyVar elt
- 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
- data InScopeSet
- emptyInScopeSet :: InScopeSet
- mkInScopeSet :: VarSet -> 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
- lookupInScope_Directly :: InScopeSet -> Unique -> Maybe Var
- unionInScope :: InScopeSet -> InScopeSet -> InScopeSet
- elemInScopeSet :: Var -> InScopeSet -> Bool
- uniqAway :: InScopeSet -> Var -> Var
- varSetInScope :: VarSet -> InScopeSet -> Bool
- unsafeGetFreshLocalUnique :: InScopeSet -> Unique
- data RnEnv2
- mkRnEnv2 :: InScopeSet -> RnEnv2
- rnBndr2 :: RnEnv2 -> Var -> Var -> RnEnv2
- rnBndrs2 :: RnEnv2 -> [Var] -> [Var] -> RnEnv2
- rnBndr2_var :: RnEnv2 -> Var -> Var -> (RnEnv2, Var)
- rnOccL :: RnEnv2 -> Var -> Var
- rnOccR :: RnEnv2 -> Var -> Var
- inRnEnvL :: RnEnv2 -> Var -> Bool
- inRnEnvR :: RnEnv2 -> Var -> Bool
- rnOccL_maybe :: RnEnv2 -> Var -> Maybe Var
- rnOccR_maybe :: RnEnv2 -> Var -> Maybe Var
- rnBndrL :: RnEnv2 -> Var -> (RnEnv2, Var)
- rnBndrR :: RnEnv2 -> Var -> (RnEnv2, Var)
- nukeRnEnvL :: RnEnv2 -> RnEnv2
- nukeRnEnvR :: RnEnv2 -> RnEnv2
- rnSwap :: RnEnv2 -> RnEnv2
- delBndrL :: RnEnv2 -> Var -> RnEnv2
- delBndrR :: RnEnv2 -> Var -> RnEnv2
- delBndrsL :: RnEnv2 -> [Var] -> RnEnv2
- delBndrsR :: RnEnv2 -> [Var] -> RnEnv2
- addRnInScopeSet :: RnEnv2 -> VarSet -> RnEnv2
- rnEtaL :: RnEnv2 -> Var -> (RnEnv2, Var)
- rnEtaR :: RnEnv2 -> Var -> (RnEnv2, Var)
- rnInScope :: Var -> RnEnv2 -> Bool
- rnInScopeSet :: RnEnv2 -> InScopeSet
- lookupRnInScope :: RnEnv2 -> Var -> Var
- rnEnvL :: RnEnv2 -> VarEnv Var
- rnEnvR :: RnEnv2 -> VarEnv Var
- type TidyEnv = (TidyOccEnv, VarEnv Var)
- emptyTidyEnv :: TidyEnv
- mkEmptyTidyEnv :: TidyOccEnv -> TidyEnv
- delTidyEnvList :: TidyEnv -> [Var] -> TidyEnv
Var, Id and TyVar environments (maps)
type TyCoVarEnv elt = UniqFM TyCoVar elt Source #
Type or Coercion Variable Environment
Manipulating these environments
emptyVarEnv :: VarEnv a Source #
unitVarEnv :: Var -> a -> VarEnv a Source #
mkVarEnv_Directly :: [(Unique, a)] -> VarEnv a Source #
plusVarEnvList :: [VarEnv a] -> VarEnv a Source #
lookupVarEnv_NF :: VarEnv a -> Var -> a Source #
lookupWithDefaultVarEnv :: VarEnv a -> a -> Var -> a Source #
isEmptyVarEnv :: VarEnv a -> Bool Source #
Deterministic Var environments (maps)
type DIdEnv elt = UniqDFM Var elt Source #
Deterministic Identifier Environment Sadly not always indexed by Id, but it is in the common case.
Manipulating these environments
emptyDVarEnv :: DVarEnv a Source #
dVarEnvElts :: DVarEnv a -> [a] Source #
isEmptyDVarEnv :: DVarEnv a -> Bool Source #
foldDVarEnv :: (a -> b -> b) -> b -> DVarEnv a -> b Source #
nonDetStrictFoldDVarEnv :: (a -> b -> b) -> b -> DVarEnv a -> b Source #
mapDVarEnv :: (a -> b) -> DVarEnv a -> DVarEnv b Source #
unitDVarEnv :: Var -> a -> DVarEnv a Source #
The InScopeSet type
data InScopeSet Source #
A set of variables that are in scope at some point "Secrets of the Glasgow Haskell Compiler inliner" Section 3.2 provides the motivation for this abstraction.
Instances
| Outputable InScopeSet Source # | |
Defined in GHC.Types.Var.Env Methods ppr :: InScopeSet -> SDoc Source # | |
Operations on InScopeSets
mkInScopeSet :: VarSet -> InScopeSet Source #
delInScopeSet :: InScopeSet -> Var -> InScopeSet Source #
extendInScopeSet :: InScopeSet -> Var -> InScopeSet Source #
extendInScopeSetList :: InScopeSet -> [Var] -> InScopeSet Source #
extendInScopeSetSet :: InScopeSet -> VarSet -> InScopeSet Source #
getInScopeVars :: InScopeSet -> VarSet Source #
lookupInScope :: InScopeSet -> Var -> Maybe Var Source #
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 Source #
unionInScope :: InScopeSet -> InScopeSet -> InScopeSet Source #
elemInScopeSet :: Var -> InScopeSet -> Bool Source #
uniqAway :: InScopeSet -> Var -> Var Source #
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].
varSetInScope :: VarSet -> InScopeSet -> Bool Source #
unsafeGetFreshLocalUnique :: InScopeSet -> Unique Source #
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
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:
- A renaming for the left-hand expression
- A renaming for the right-hand expressions
- 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 Source #
rnBndr2 :: RnEnv2 -> Var -> Var -> RnEnv2 Source #
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 Source #
Applies rnBndr2 to several variables: the two variable lists must be of equal length
rnBndr2_var :: RnEnv2 -> Var -> Var -> (RnEnv2, Var) Source #
Similar to rnBndr2 but returns the new variable as well as the
new environment
rnOccL :: RnEnv2 -> Var -> Var Source #
Look up the renaming of an occurrence in the left or right term
rnOccR :: RnEnv2 -> Var -> Var Source #
Look up the renaming of an occurrence in the left or right term
rnOccL_maybe :: RnEnv2 -> Var -> Maybe Var Source #
Look up the renaming of an occurrence in the left or right term
rnOccR_maybe :: RnEnv2 -> Var -> Maybe Var Source #
Look up the renaming of an occurrence in the left or right term
rnBndrL :: RnEnv2 -> Var -> (RnEnv2, Var) Source #
Similar to rnBndr2 but used when there's a binder on the left
side only.
rnBndrR :: RnEnv2 -> Var -> (RnEnv2, Var) Source #
Similar to rnBndr2 but used when there's a binder on the right
side only.
nukeRnEnvL :: RnEnv2 -> RnEnv2 Source #
Wipe the left or right side renaming
nukeRnEnvR :: RnEnv2 -> RnEnv2 Source #
Wipe the left or right side renaming
rnEtaL :: RnEnv2 -> Var -> (RnEnv2, Var) Source #
Similar to rnBndrL but used for eta expansion
See Note [Eta expansion]
rnEtaR :: RnEnv2 -> Var -> (RnEnv2, Var) Source #
Similar to rnBndr2 but used for eta expansion
See Note [Eta expansion]
rnInScopeSet :: RnEnv2 -> InScopeSet Source #
TidyEnv and its operation
type TidyEnv = (TidyOccEnv, VarEnv Var) Source #
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
mkEmptyTidyEnv :: TidyOccEnv -> TidyEnv Source #