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 it's use sites.

Instances

Eq Var

Methods

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

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

Data 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

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

Methods

pprBndr :: BindingSite -> Var -> SDoc

pprPrefixOcc :: Var -> SDoc

pprInfixOcc :: Var -> SDoc

bndrIsJoin_maybe :: Var -> Maybe Int

Outputable Var

Methods

ppr :: Var -> SDoc

pprPrec :: Rational -> Var -> SDoc

Uniquable Var

Methods

getUnique :: Var -> Unique

HasOccName Var

Methods

occName :: Var -> OccName

NamedThing 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 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 TyVarBndr tyvar argf

Constructors

TvBndr tyvar argf

Instances

(Data tyvar, Data argf) => Data (TyVarBndr tyvar argf)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyVarBndr tyvar argf -> c (TyVarBndr tyvar argf)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (TyVarBndr tyvar argf)

toConstr :: TyVarBndr tyvar argf -> Constr

dataTypeOf :: TyVarBndr tyvar argf -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> TyVarBndr tyvar argf -> TyVarBndr tyvar argf

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyVarBndr tyvar argf -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyVarBndr tyvar argf -> r

gmapQ :: (forall d. Data d => d -> u) -> TyVarBndr tyvar argf -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> TyVarBndr tyvar argf -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyVarBndr tyvar argf -> m (TyVarBndr tyvar argf)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyVarBndr tyvar argf -> m (TyVarBndr tyvar argf)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyVarBndr tyvar argf -> m (TyVarBndr tyvar argf)

Outputable tv => Outputable (TyVarBndr tv ArgFlag)

Methods

ppr :: TyVarBndr tv ArgFlag -> SDoc

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

Outputable tv => Outputable (TyVarBndr tv TyConBndrVis)

Methods

ppr :: TyVarBndr tv TyConBndrVis -> SDoc

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

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

Methods

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

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

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

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 [TyVarBndrs, TyVarBinders, TyConBinders, and visibility] in TyCoRep

Constructors

Required

Specified

Inferred

Instances

Eq ArgFlag

Methods

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

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

Data ArgFlag

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

Outputable ArgFlag

Methods

ppr :: ArgFlag -> SDoc

pprPrec :: Rational -> ArgFlag -> SDoc

Binary ArgFlag

Methods

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

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

get :: BinHandle -> IO ArgFlag

Outputable tv => Outputable (TyVarBndr tv ArgFlag)

Methods

ppr :: TyVarBndr tv ArgFlag -> SDoc

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

type TyVarBinder = TyVarBndr TyVar ArgFlag

Type Variable Binder

A TyVarBinder 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

binderVar :: TyVarBndr tv argf -> tv

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

binderArgFlag :: TyVarBndr tv argf -> argf

binderKind :: TyVarBndr TyVar argf -> Kind

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.

mkTyVarBinder :: ArgFlag -> Var -> TyVarBinder

Make a named binder

mkTyVarBinders :: ArgFlag -> [TyVar] -> [TyVarBinder]

Make many named binders

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]