Var

GHC uses several kinds of name internally:

• OccName: see OccName
• RdrName: see RdrName
• Name: see Name
• Id: see Id
• Var is a synonym for the Id type but it may additionally potentially contain type variables, which have a Kind rather than a Type and 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.

The main data type and synonyms

data Var

Variable

Essentially a typed Name, that may also contain some additional information about the Var and its use sites.

Instances

Eq Var

Defined in Var

Methods

(==) :: Var -> Var -> Bool

(/=) :: Var -> Var -> Bool

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

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Var

toConstr :: Var -> Constr

dataTypeOf :: Var -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Var)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Var)

gmapT :: (forall b. Data b => b -> b) -> Var -> Var

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Var -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Var -> r

gmapQ :: (forall d. Data d => d -> u) -> Var -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Var -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Var -> m Var

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Var -> m Var

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Var -> m Var

Ord Var

Defined in Var

Methods

compare :: Var -> Var -> Ordering

(<) :: Var -> Var -> Bool

(<=) :: Var -> Var -> Bool

(>) :: Var -> Var -> Bool

(>=) :: Var -> Var -> Bool

max :: Var -> Var -> Var

min :: Var -> Var -> Var

OutputableBndr Var

Defined in PprCore

Methods

pprBndr :: BindingSite -> Var -> SDoc

pprPrefixOcc :: Var -> SDoc

pprInfixOcc :: Var -> SDoc

bndrIsJoin_maybe :: Var -> Maybe Int

Outputable Var

Defined in Var

Methods

ppr :: Var -> SDoc

pprPrec :: Rational -> Var -> SDoc

Uniquable Var

Defined in Var

Methods

getUnique :: Var -> Unique

HasOccName Var

Defined in Var

Methods

occName :: Var -> OccName

NamedThing Var

Defined in Var

Methods

getOccName :: Var -> OccName

getName :: Var -> Name

type CoVar = Id

Coercion Variable

type Id = Var

Identifier

type NcId = Id

type DictId = EvId

Dictionary Identifier

type DFunId = Id

Dictionary Function Identifier

type EvVar = EvId

Evidence Variable

type EqVar = EvId

Equality Variable

type EvId = Id

Evidence Identifier

type IpId = EvId

Implicit parameter Identifier

type JoinId = Id

type TyVar = Var

Type or kind Variable

type TcTyVar = Var

Type variable that might be a metavariable

type TypeVar = Var

Type Variable

type KindVar = Var

Kind Variable

type TKVar = Var

Type or Kind Variable

type TyCoVar = Id

Type or Coercion Variable

In and Out variants

type InVar = Var

type InCoVar = CoVar

type InId = Id

type InTyVar = TyVar

type OutVar = Var

type OutCoVar = CoVar

type OutId = Id

type OutTyVar = TyVar

Taking Vars apart

varName :: Var -> Name

varUnique :: Var -> Unique

varType :: Var -> Kind

The type or kind of the Var in question

Modifying Vars

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

Constructing, taking apart, modifying Ids

mkGlobalVar :: IdDetails -> Name -> Type -> IdInfo -> Id

mkLocalVar :: IdDetails -> Name -> Type -> IdInfo -> Id

mkExportedLocalVar :: IdDetails -> Name -> Type -> IdInfo -> Id

Exported Vars will not be removed as dead code

mkCoVar :: Name -> Type -> CoVar

idInfo :: HasDebugCallStack => Id -> IdInfo

idDetails :: Id -> IdDetails

lazySetIdInfo :: Id -> IdInfo -> Var

setIdDetails :: Id -> IdDetails -> Id

globaliseId :: Id -> Id

If it's a local, make it global

setIdExported :: Id -> Id

Exports the given local Id. Can also be called on global Ids, such as data constructors and class operations, which are born as global Ids and automatically exported

setIdNotExported :: Id -> Id

We can only do this to LocalIds

Predicates

isId :: Var -> Bool

isTyVar :: Var -> Bool

isTcTyVar :: Var -> Bool

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.

isLocalId :: Var -> Bool

isCoVar :: Var -> Bool

isNonCoVarId :: Var -> Bool

isTyCoVar :: Var -> Bool

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

TyVar's

data VarBndr var argf

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)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (VarBndr var argf)

toConstr :: VarBndr var argf -> Constr

dataTypeOf :: VarBndr var argf -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (VarBndr var argf))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (VarBndr var argf))

gmapT :: (forall b. Data b => b -> b) -> VarBndr var argf -> VarBndr var argf

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VarBndr var argf -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VarBndr var argf -> r

gmapQ :: (forall d. Data d => d -> u) -> VarBndr var argf -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> VarBndr var argf -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> VarBndr var argf -> m (VarBndr var argf)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VarBndr var argf -> m (VarBndr var argf)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VarBndr var argf -> m (VarBndr var argf)

Outputable tv => Outputable (VarBndr tv ArgFlag)

Defined in Var

Methods

ppr :: VarBndr tv ArgFlag -> SDoc

pprPrec :: Rational -> VarBndr tv ArgFlag -> SDoc

Outputable tv => Outputable (VarBndr tv TyConBndrVis)

Defined in TyCon

Methods

ppr :: VarBndr tv TyConBndrVis -> SDoc

pprPrec :: Rational -> VarBndr tv TyConBndrVis -> SDoc

(Binary tv, Binary vis) => Binary (VarBndr tv vis)

Defined in Var

Methods

put_ :: BinHandle -> VarBndr tv vis -> IO ()

put :: BinHandle -> VarBndr tv vis -> IO (Bin (VarBndr tv vis))

get :: BinHandle -> IO (VarBndr tv vis)

NamedThing tv => NamedThing (VarBndr tv flag)

Defined in Var

Methods

getOccName :: VarBndr tv flag -> OccName

getName :: VarBndr tv flag -> Name

data ArgFlag

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

Constructors

Inferred

Specified

Required

Instances

Eq ArgFlag

Defined in Var

Methods

(==) :: ArgFlag -> ArgFlag -> Bool

(/=) :: ArgFlag -> ArgFlag -> Bool

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

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ArgFlag

toConstr :: ArgFlag -> Constr

dataTypeOf :: ArgFlag -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ArgFlag)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ArgFlag)

gmapT :: (forall b. Data b => b -> b) -> ArgFlag -> ArgFlag

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ArgFlag -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ArgFlag -> r

gmapQ :: (forall d. Data d => d -> u) -> ArgFlag -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ArgFlag -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ArgFlag -> m ArgFlag

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ArgFlag -> m ArgFlag

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ArgFlag -> m ArgFlag

Ord ArgFlag

Defined in Var

Methods

compare :: ArgFlag -> ArgFlag -> Ordering

(<) :: ArgFlag -> ArgFlag -> Bool

(<=) :: ArgFlag -> ArgFlag -> Bool

(>) :: ArgFlag -> ArgFlag -> Bool

(>=) :: ArgFlag -> ArgFlag -> Bool

max :: ArgFlag -> ArgFlag -> ArgFlag

min :: ArgFlag -> ArgFlag -> ArgFlag

Outputable ArgFlag

Defined in Var

Methods

ppr :: ArgFlag -> SDoc

pprPrec :: Rational -> ArgFlag -> SDoc

Binary ArgFlag

Defined in Var

Methods

put_ :: BinHandle -> ArgFlag -> IO ()

put :: BinHandle -> ArgFlag -> IO (Bin ArgFlag)

get :: BinHandle -> IO ArgFlag

Outputable tv => Outputable (VarBndr tv ArgFlag)

Defined in Var

Methods

ppr :: VarBndr tv ArgFlag -> SDoc

pprPrec :: Rational -> VarBndr tv ArgFlag -> SDoc

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

binderVar :: VarBndr tv argf -> tv

binderVars :: [VarBndr tv argf] -> [tv]

binderArgFlag :: VarBndr tv argf -> argf

binderType :: VarBndr TyCoVar argf -> Type

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?

sameVis :: ArgFlag -> ArgFlag -> Bool

Do these denote the same level of visibility? Required arguments are visible, others are not. So this function equates Specified and Inferred. Used for printing.

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

mkTyVar :: Name -> Kind -> TyVar

mkTcTyVar :: Name -> Kind -> TcTyVarDetails -> TyVar

Taking TyVars apart

tyVarName :: TyVar -> Name

tyVarKind :: TyVar -> Kind

tcTyVarDetails :: TyVar -> TcTyVarDetails

setTcTyVarDetails :: TyVar -> TcTyVarDetails -> TyVar

Modifying TyVars

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

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]