| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Var
Description
GHC uses several kinds of name internally:
OccName: see OccNameRdrName: see RdrNameName: see NameId: see IdVaris a synonym for theIdtype but it may additionally potentially contain type variables, which have aKindrather than aTypeand only contain some extra details during typechecking.
These Var names may either be global or local, see Var
Global Ids and Vars are those that are imported or correspond
to a data constructor, primitive operation, or record selectors.
Local Ids and Vars are those bound within an expression
(e.g. by a lambda) or at the top level of the module being compiled.
Synopsis
- data Var
- type CoVar = Id
- type Id = Var
- type NcId = Id
- type DictId = EvId
- type DFunId = Id
- type EvVar = EvId
- type EqVar = EvId
- type EvId = Id
- type IpId = EvId
- type JoinId = Id
- type TyVar = Var
- type TcTyVar = Var
- type TypeVar = Var
- type KindVar = Var
- type TKVar = Var
- type TyCoVar = Id
- type InVar = Var
- type InCoVar = CoVar
- type InId = Id
- type InTyVar = TyVar
- type OutVar = Var
- type OutCoVar = CoVar
- type OutId = Id
- type OutTyVar = TyVar
- varName :: Var -> Name
- varUnique :: Var -> Unique
- varType :: Var -> Kind
- setVarName :: Var -> Name -> Var
- setVarUnique :: Var -> Unique -> Var
- setVarType :: Id -> Type -> Id
- updateVarType :: (Type -> Type) -> Id -> Id
- updateVarTypeM :: Monad m => (Type -> m Type) -> Id -> m Id
- mkGlobalVar :: IdDetails -> Name -> Type -> IdInfo -> Id
- mkLocalVar :: IdDetails -> Name -> Type -> IdInfo -> Id
- mkExportedLocalVar :: IdDetails -> Name -> Type -> IdInfo -> Id
- mkCoVar :: Name -> Type -> CoVar
- idInfo :: HasDebugCallStack => Id -> IdInfo
- idDetails :: Id -> IdDetails
- lazySetIdInfo :: Id -> IdInfo -> Var
- setIdDetails :: Id -> IdDetails -> Id
- globaliseId :: Id -> Id
- setIdExported :: Id -> Id
- setIdNotExported :: Id -> Id
- isId :: Var -> Bool
- isTyVar :: Var -> Bool
- isTcTyVar :: Var -> Bool
- isLocalVar :: Var -> Bool
- isLocalId :: Var -> Bool
- isCoVar :: Var -> Bool
- isNonCoVarId :: Var -> Bool
- isTyCoVar :: Var -> Bool
- isGlobalId :: Var -> Bool
- isExportedId :: Var -> Bool
- mustHaveLocalBinding :: Var -> Bool
- data ArgFlag
- isVisibleArgFlag :: ArgFlag -> Bool
- isInvisibleArgFlag :: ArgFlag -> Bool
- sameVis :: ArgFlag -> ArgFlag -> Bool
- data AnonArgFlag
- data ForallVisFlag
- argToForallVisFlag :: ArgFlag -> ForallVisFlag
- data VarBndr var argf = Bndr var argf
- type TyCoVarBinder = VarBndr TyCoVar ArgFlag
- type TyVarBinder = VarBndr TyVar ArgFlag
- binderVar :: VarBndr tv argf -> tv
- binderVars :: [VarBndr tv argf] -> [tv]
- binderArgFlag :: VarBndr tv argf -> argf
- binderType :: VarBndr TyCoVar argf -> Type
- mkTyCoVarBinder :: ArgFlag -> TyCoVar -> TyCoVarBinder
- mkTyCoVarBinders :: ArgFlag -> [TyCoVar] -> [TyCoVarBinder]
- mkTyVarBinder :: ArgFlag -> TyVar -> TyVarBinder
- mkTyVarBinders :: ArgFlag -> [TyVar] -> [TyVarBinder]
- isTyVarBinder :: TyCoVarBinder -> Bool
- mkTyVar :: Name -> Kind -> TyVar
- mkTcTyVar :: Name -> Kind -> TcTyVarDetails -> TyVar
- tyVarName :: TyVar -> Name
- tyVarKind :: TyVar -> Kind
- tcTyVarDetails :: TyVar -> TcTyVarDetails
- setTcTyVarDetails :: TyVar -> TcTyVarDetails -> TyVar
- setTyVarName :: TyVar -> Name -> TyVar
- setTyVarUnique :: TyVar -> Unique -> TyVar
- setTyVarKind :: TyVar -> Kind -> TyVar
- updateTyVarKind :: (Kind -> Kind) -> TyVar -> TyVar
- updateTyVarKindM :: Monad m => (Kind -> m Kind) -> TyVar -> m TyVar
- nonDetCmpVar :: Var -> Var -> Ordering
The main data type and synonyms
Variable
Essentially a typed Name, that may also contain some additional information
about the Var and its use sites.
Instances
| Eq Var # | |
| Data Var # | |
Defined in Var Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Var -> c Var Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Var Source # toConstr :: Var -> Constr Source # dataTypeOf :: Var -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Var) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Var) Source # gmapT :: (forall b. Data b => b -> b) -> Var -> Var Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Var -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Var -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Var -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Var -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Var -> m Var Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Var -> m Var Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Var -> m Var Source # | |
| Ord Var # | |
| OutputableBndr Var # | |
Defined in PprCore Methods pprBndr :: BindingSite -> Var -> SDoc # pprPrefixOcc :: Var -> SDoc # pprInfixOcc :: Var -> SDoc # bndrIsJoin_maybe :: Var -> Maybe Int # | |
| Outputable Var # | |
| Uniquable Var # | |
| HasOccName Var # | |
| NamedThing Var # | |
In and Out variants
Taking Vars apart
Modifying Vars
setVarName :: Var -> Name -> Var #
setVarUnique :: Var -> Unique -> Var #
setVarType :: Id -> Type -> Id #
Constructing, taking apart, modifying Ids
mkExportedLocalVar :: IdDetails -> Name -> Type -> IdInfo -> Id #
Exported Vars will not be removed as dead code
idInfo :: HasDebugCallStack => Id -> IdInfo #
lazySetIdInfo :: Id -> IdInfo -> Var #
setIdDetails :: Id -> IdDetails -> Id #
globaliseId :: Id -> Id #
If it's a local, make it global
setIdExported :: Id -> Id #
setIdNotExported :: Id -> Id #
We can only do this to LocalIds
Predicates
Is this a value-level (i.e., computationally relevant) Identifier?
Satisfies isId = not . isTyVar.
Is this a type-level (i.e., computationally irrelevant, thus erasable)
variable? Satisfies isTyVar = not . isId.
isLocalVar :: Var -> Bool #
isLocalVar returns True for type variables as well as local Ids
These are the variables that we need to pay attention to when finding free
variables, or doing dependency analysis.
Is this a coercion variable?
Satisfies .isId v ==> isCoVar v == not (isNonCoVarId v)
isNonCoVarId :: Var -> Bool #
Is this a term variable (Id) that is not a coercion variable?
Satisfies .isId v ==> isCoVar v == not (isNonCoVarId v)
isGlobalId :: Var -> Bool #
isExportedId :: Var -> Bool #
isExportedIdVar means "don't throw this away"
mustHaveLocalBinding :: Var -> Bool #
mustHaveLocalBinding returns True of Ids and TyVars
that must have a binding in this module. The converse
is not quite right: there are some global Ids that must have
bindings, such as record selectors. But that doesn't matter,
because it's only used for assertions
ArgFlags
Argument Flag
Is something required to appear in source Haskell (Required),
permitted by request (Specified) (visible type application), or
prohibited entirely from appearing in source Haskell (Inferred)?
See Note [VarBndrs, TyCoVarBinders, TyConBinders, and visibility] in TyCoRep
Instances
| Eq ArgFlag # | |
| Data ArgFlag # | |
Defined in Var Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ArgFlag -> c ArgFlag Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ArgFlag Source # toConstr :: ArgFlag -> Constr Source # dataTypeOf :: ArgFlag -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ArgFlag) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ArgFlag) Source # gmapT :: (forall b. Data b => b -> b) -> ArgFlag -> ArgFlag Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ArgFlag -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ArgFlag -> r Source # gmapQ :: (forall d. Data d => d -> u) -> ArgFlag -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> ArgFlag -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ArgFlag -> m ArgFlag Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ArgFlag -> m ArgFlag Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ArgFlag -> m ArgFlag Source # | |
| Ord ArgFlag # | |
| Outputable ArgFlag # | |
| Binary ArgFlag # | |
| Outputable tv => Outputable (VarBndr tv ArgFlag) # | |
isVisibleArgFlag :: ArgFlag -> Bool #
Does this ArgFlag classify an argument that is written in Haskell?
isInvisibleArgFlag :: ArgFlag -> Bool #
Does this ArgFlag classify an argument that is not written in Haskell?
data AnonArgFlag #
The non-dependent version of ArgFlag.
Constructors
| VisArg | Used for |
| InvisArg | Used for |
Instances
data ForallVisFlag #
Is a forall invisible (e.g., forall a b. {...}, with a dot) or visible
(e.g., forall a b -> {...}, with an arrow)?
Constructors
| ForallVis | A visible |
| ForallInvis | An invisible |
Instances
argToForallVisFlag :: ArgFlag -> ForallVisFlag #
Convert an ArgFlag to its corresponding ForallVisFlag.
TyVar's
Constructors
| Bndr var argf |
Instances
| (Data var, Data argf) => Data (VarBndr var argf) # | |
Defined in Var Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VarBndr var argf -> c (VarBndr var argf) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (VarBndr var argf) Source # toConstr :: VarBndr var argf -> Constr Source # dataTypeOf :: VarBndr var argf -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (VarBndr var argf)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (VarBndr var argf)) Source # gmapT :: (forall b. Data b => b -> b) -> VarBndr var argf -> VarBndr var argf Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VarBndr var argf -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VarBndr var argf -> r Source # gmapQ :: (forall d. Data d => d -> u) -> VarBndr var argf -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> VarBndr var argf -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VarBndr var argf -> m (VarBndr var argf) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VarBndr var argf -> m (VarBndr var argf) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VarBndr var argf -> m (VarBndr var argf) Source # | |
| Outputable tv => Outputable (VarBndr tv ArgFlag) # | |
| OutputableBndr tv => Outputable (VarBndr tv TyConBndrVis) # | |
| (Binary tv, Binary vis) => Binary (VarBndr tv vis) # | |
| NamedThing tv => NamedThing (VarBndr tv flag) # | |
type TyCoVarBinder = VarBndr TyCoVar ArgFlag #
Variable Binder
A TyCoVarBinder is the binder of a ForAllTy
It's convenient to define this synonym here rather its natural
home in TyCoRep, because it's used in DataCon.hs-boot
A TyVarBinder is a binder with only TyVar
type TyVarBinder = VarBndr TyVar ArgFlag #
binderVars :: [VarBndr tv argf] -> [tv] #
binderArgFlag :: VarBndr tv argf -> argf #
binderType :: VarBndr TyCoVar argf -> Type #
mkTyCoVarBinder :: ArgFlag -> TyCoVar -> TyCoVarBinder #
Make a named binder
mkTyCoVarBinders :: ArgFlag -> [TyCoVar] -> [TyCoVarBinder] #
Make many named binders
mkTyVarBinder :: ArgFlag -> TyVar -> TyVarBinder #
Make a named binder
var should be a type variable
mkTyVarBinders :: ArgFlag -> [TyVar] -> [TyVarBinder] #
Make many named binders Input vars should be type variables
isTyVarBinder :: TyCoVarBinder -> Bool #
Constructing TyVar's
Taking TyVars apart
tcTyVarDetails :: TyVar -> TcTyVarDetails #
setTcTyVarDetails :: TyVar -> TcTyVarDetails -> TyVar #
Modifying TyVars
setTyVarName :: TyVar -> Name -> TyVar #
setTyVarUnique :: TyVar -> Unique -> TyVar #
setTyVarKind :: TyVar -> Kind -> TyVar #
nonDetCmpVar :: Var -> Var -> Ordering #
Compare Vars by their Uniques. This is what Ord Var does, provided here to make it explicit at the call-site that it can introduce non-determinism. See Note [Unique Determinism]