|
|
|
|
|
|
| Synopsis |
|
|
|
|
| Var, Id and TyVar environments (maps)
|
|
| type VarEnv elt = UniqFM elt |
|
| type IdEnv elt = VarEnv elt |
|
| type TyVarEnv elt = VarEnv elt |
|
| Manipulating these environments
|
|
| emptyVarEnv :: VarEnv a |
|
| unitVarEnv :: Var -> a -> VarEnv a |
|
| mkVarEnv :: [(Var, a)] -> VarEnv a |
|
| elemVarEnv :: Var -> VarEnv a -> Bool |
|
| varEnvElts :: VarEnv a -> [a] |
|
| varEnvKeys :: VarEnv a -> [Unique] |
|
| extendVarEnv :: VarEnv a -> Var -> a -> VarEnv a |
|
| extendVarEnv_C :: (a -> a -> a) -> VarEnv a -> Var -> a -> VarEnv a |
|
| 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 |
|
| delVarEnvList :: VarEnv a -> [Var] -> VarEnv a |
|
| delVarEnv :: VarEnv a -> Var -> 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 a -> Unique -> UniqFM a |
|
| isEmptyVarEnv :: VarEnv a -> Bool |
|
| foldVarEnv :: (a -> b -> b) -> b -> VarEnv a -> b |
|
| elemVarEnvByKey :: Unique -> VarEnv a -> Bool |
|
| lookupVarEnv_Directly :: VarEnv a -> Unique -> Maybe a |
|
| filterVarEnv_Directly :: (Unique -> a -> Bool) -> VarEnv a -> VarEnv a |
|
| The InScopeSet type
|
|
| data InScopeSet |
| A set of variables that are in scope at some point
|  Instances | |
|
|
| Operations on InScopeSets
|
|
| emptyInScopeSet :: InScopeSet |
|
| mkInScopeSet :: VarEnv Var -> InScopeSet |
|
| delInScopeSet :: InScopeSet -> Var -> InScopeSet |
|
| extendInScopeSet :: InScopeSet -> Var -> InScopeSet |
|
| extendInScopeSetList :: InScopeSet -> [Var] -> InScopeSet |
|
| extendInScopeSetSet :: InScopeSet -> VarEnv Var -> InScopeSet |
|
| modifyInScopeSet :: InScopeSet -> Var -> Var -> InScopeSet |
| Replace the first Var with the second in the set of in-scope variables
|
|
| getInScopeVars :: InScopeSet -> VarEnv Var |
|
| lookupInScope :: InScopeSet -> Var -> Maybe Var |
| If the given variable was even added to the InScopeSet, or if it was the "from" argument
of any modifyInScopeSet operation, returns that variable with all appropriate modifications
applied to it. Otherwise, return Nothing
|
|
| 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.
|
|
| The RnEnv2 type
|
|
| data RnEnv2 |
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
|
|
| rnOccL :: RnEnv2 -> Var -> Var |
| Look up the renaming of an occurrence in the left or right term
|
|
| rnOccR :: RnEnv2 -> Var -> Var |
|
| inRnEnvL :: RnEnv2 -> Var -> Bool |
| Tells whether a variable is locally bound
|
|
| inRnEnvR :: RnEnv2 -> Var -> Bool |
|
| rnBndrL :: RnEnv2 -> Var -> (RnEnv2, Var) |
| Similar to rnBndr2 but used when there's a binder on the left
side only. Useful when eta-expanding
|
|
| rnBndrR :: RnEnv2 -> Var -> (RnEnv2, Var) |
| Similar to rnBndr2 but used when there's a binder on the right
side only. Useful when eta-expanding
|
|
| nukeRnEnvL :: RnEnv2 -> RnEnv2 |
| Wipe the left or right side renaming
|
|
| nukeRnEnvR :: RnEnv2 -> RnEnv2 |
|
| extendRnInScopeList :: RnEnv2 -> [Var] -> RnEnv2 |
|
| rnInScope :: Var -> RnEnv2 -> Bool |
|
| rnInScopeSet :: RnEnv2 -> InScopeSet |
|
| lookupRnInScope :: RnEnv2 -> Var -> Var |
|
| TidyEnv and its operation
|
|
| type TidyEnv = (TidyOccEnv, VarEnv Var) |
| 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 |
|
| Produced by Haddock version 2.4.2 |
