Safe Haskell | Safe-Inferred |
---|---|
Language | Haskell2010 |
GHC.Types.Var
Description
GHC uses several kinds of name internally:
OccName
: see GHC.Types.Name.OccurrenceRdrName
: see GHC.Types.Name.ReaderName
: see GHC.Types.NameId
: see GHC.Types.IdVar
is a synonym for theId
type but it may additionally potentially contain type variables, which have aKind
rather than aType
and only contain some extra details during typechecking.
These Var
names may either be global or local, see GHC.Types.Var
Global Var
s and Var
s are those that are imported or correspond
to a data constructor, primitive operation, or record selectors.
Local Var
s and Var
s 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
- varMult :: Var -> Mult
- varMultMaybe :: Id -> Maybe Mult
- setVarName :: Var -> Name -> Var
- setVarUnique :: Var -> Unique -> Var
- setVarType :: Var -> Type -> Var
- updateVarType :: (Type -> Type) -> Var -> Var
- updateVarTypeM :: Monad m => (Type -> m Type) -> Var -> m Var
- mkGlobalVar :: IdDetails -> Name -> Type -> IdInfo -> Id
- mkLocalVar :: IdDetails -> Name -> Mult -> 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
- setIdMult :: Id -> Mult -> Id
- updateIdTypeButNotMult :: (Type -> Type) -> Id -> Id
- updateIdTypeAndMult :: (Type -> Type) -> Id -> Id
- updateIdTypeAndMultM :: Monad m => (Type -> m Type) -> Id -> m 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 where
- data AnonArgFlag
- data Specificity
- isVisibleArgFlag :: ArgFlag -> Bool
- isInvisibleArgFlag :: ArgFlag -> Bool
- isInferredArgFlag :: ArgFlag -> Bool
- sameVis :: ArgFlag -> ArgFlag -> Bool
- data VarBndr var argf = Bndr var argf
- type TyCoVarBinder = VarBndr TyCoVar ArgFlag
- type TyVarBinder = VarBndr TyVar ArgFlag
- type InvisTVBinder = VarBndr TyVar Specificity
- type ReqTVBinder = VarBndr TyVar ()
- binderVar :: VarBndr tv argf -> tv
- binderVars :: [VarBndr tv argf] -> [tv]
- binderArgFlag :: VarBndr tv argf -> argf
- binderType :: VarBndr TyCoVar argf -> Type
- mkTyCoVarBinder :: vis -> TyCoVar -> VarBndr TyCoVar vis
- mkTyCoVarBinders :: vis -> [TyCoVar] -> [VarBndr TyCoVar vis]
- mkTyVarBinder :: vis -> TyVar -> VarBndr TyVar vis
- mkTyVarBinders :: vis -> [TyVar] -> [VarBndr TyVar vis]
- isTyVarBinder :: TyCoVarBinder -> Bool
- tyVarSpecToBinder :: VarBndr a Specificity -> VarBndr a ArgFlag
- tyVarSpecToBinders :: [VarBndr a Specificity] -> [VarBndr a ArgFlag]
- tyVarReqToBinder :: VarBndr a () -> VarBndr a ArgFlag
- tyVarReqToBinders :: [VarBndr a ()] -> [VarBndr a ArgFlag]
- mapVarBndr :: (var -> var') -> VarBndr var flag -> VarBndr var' flag
- mapVarBndrs :: (var -> var') -> [VarBndr var flag] -> [VarBndr var' flag]
- lookupVarBndr :: Eq var => var -> [VarBndr var flag] -> Maybe flag
- 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
Data Var # | |
Defined in GHC.Types.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 # | |
NamedThing Var # | |
HasOccName Var # | |
Uniquable Var # | |
Outputable Var # | |
OutputableBndr Var # | |
Defined in GHC.Core.Ppr | |
Eq Var # | |
Ord Var # | |
Eq (DeBruijn CoreAlt) # | |
Eq (DeBruijn CoreExpr) # | |
type Anno Id # | |
Defined in GHC.Hs.Extension | |
type Anno (LocatedN Id) # | |
Defined in GHC.Hs.Binds | |
type Anno [LocatedN Id] # | |
Defined in GHC.Hs.Binds |
In and Out variants
Taking Var
s apart
Modifying Var
s
Constructing, taking apart, modifying Var
s
mkExportedLocalVar :: IdDetails -> Name -> Type -> IdInfo -> Id Source #
Exported Var
s will not be removed as dead code
globaliseId :: Id -> Id Source #
If it's a local, make it global
setIdExported :: Id -> Id Source #
setIdNotExported :: Id -> Id Source #
We can only do this to LocalIds
Predicates
Is this a value-level (i.e., computationally relevant) Var
entifier?
Satisfies isId = not . isTyVar
.
isTyVar :: Var -> Bool Source #
Is this a type-level (i.e., computationally irrelevant, thus erasable)
variable? Satisfies isTyVar = not . isId
.
isLocalVar :: Var -> Bool Source #
isLocalVar
returns True
for type variables as well as local Var
s
These are the variables that we need to pay attention to when finding free
variables, or doing dependency analysis.
isCoVar :: Var -> Bool Source #
Is this a coercion variable?
Satisfies
.isId
v ==> isCoVar
v == not (isNonCoVarId
v)
isNonCoVarId :: Var -> Bool Source #
Is this a term variable (Var
) that is not a coercion variable?
Satisfies
.isId
v ==> isCoVar
v == not (isNonCoVarId
v)
isGlobalId :: Var -> Bool Source #
isExportedId :: Var -> Bool Source #
isExportedIdVar
means "don't throw this away"
mustHaveLocalBinding :: Var -> Bool Source #
mustHaveLocalBinding
returns True
of Var
s and Var
s
that must have a binding in this module. The converse
is not quite right: there are some global Var
s 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 GHC.Core.TyCo.Rep
Constructors
Invisible Specificity | |
Required |
Instances
Data ArgFlag # | |
Defined in GHC.Types.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 # | |
Binary ArgFlag # | |
Outputable ArgFlag # | |
Eq ArgFlag # | |
Ord ArgFlag # | |
Outputable tv => Outputable (VarBndr tv ArgFlag) # | |
data AnonArgFlag Source #
The non-dependent version of ArgFlag
.
See Note [AnonArgFlag]
Appears here partly so that it's together with its friends ArgFlag
and ForallVisFlag, but also because it is used in IfaceType, rather
early in the compilation chain
Constructors
VisArg | Used for |
InvisArg | Used for |
Instances
data Specificity Source #
Whether an Invisible
argument may appear in source Haskell.
Constructors
InferredSpec | the argument may not appear in source Haskell, it is only inferred. |
SpecifiedSpec | the argument may appear in source Haskell, but isn't required. |
Instances
isVisibleArgFlag :: ArgFlag -> Bool Source #
Does this ArgFlag
classify an argument that is written in Haskell?
isInvisibleArgFlag :: ArgFlag -> Bool Source #
Does this ArgFlag
classify an argument that is not written in Haskell?
isInferredArgFlag :: ArgFlag -> Bool Source #
TyVar's
data VarBndr var argf Source #
Constructors
Bndr var argf |
Instances
(Data var, Data argf) => Data (VarBndr var argf) # | |
Defined in GHC.Types.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 # | |
NamedThing tv => NamedThing (VarBndr tv flag) # | |
(Binary tv, Binary vis) => Binary (VarBndr tv vis) # | |
OutputableBndr tv => Outputable (VarBndr tv TyConBndrVis) # | |
Defined in GHC.Core.TyCon | |
Outputable tv => Outputable (VarBndr tv ArgFlag) # | |
Outputable tv => Outputable (VarBndr tv Specificity) # | |
Defined in GHC.Types.Var |
type TyCoVarBinder = VarBndr TyCoVar ArgFlag Source #
Variable Binder
A TyCoVarBinder
is the binder of a ForAllTy
It's convenient to define this synonym here rather its natural
home in GHC.Core.TyCo.Rep, because it's used in GHC.Core.DataCon.hs-boot
A TyVarBinder
is a binder with only TyVar
type InvisTVBinder = VarBndr TyVar Specificity Source #
type ReqTVBinder = VarBndr TyVar () Source #
binderVars :: [VarBndr tv argf] -> [tv] Source #
binderArgFlag :: VarBndr tv argf -> argf Source #
mkTyVarBinder :: vis -> TyVar -> VarBndr TyVar vis Source #
Make a named binder
var
should be a type variable
mkTyVarBinders :: vis -> [TyVar] -> [VarBndr TyVar vis] Source #
Make many named binders Input vars should be type variables
isTyVarBinder :: TyCoVarBinder -> Bool Source #
tyVarSpecToBinder :: VarBndr a Specificity -> VarBndr a ArgFlag Source #
tyVarSpecToBinders :: [VarBndr a Specificity] -> [VarBndr a ArgFlag] Source #
mapVarBndr :: (var -> var') -> VarBndr var flag -> VarBndr var' flag Source #
mapVarBndrs :: (var -> var') -> [VarBndr var flag] -> [VarBndr var' flag] Source #
Constructing TyVar's
Taking Var
s apart
tcTyVarDetails :: TyVar -> TcTyVarDetails Source #
setTcTyVarDetails :: TyVar -> TcTyVarDetails -> TyVar Source #