ghc-8.0.2: The GHC API

Safe Haskell | None
Language | Haskell2010

Var

Contents

- The main data type and synonyms
  - Taking `Var`s apart
  - Modifying `Var`s
  - Constructing, taking apart, modifying `Id`s
  - Predicates
  - Constructing `TyVar`s
  - Taking `TyVar`s apart
  - Modifying `TyVar`s

Description

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 `Id`s and `Var`s are those that are imported or correspond to a data constructor, primitive operation, or record selectors. Local `Id`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 TyVar = Var
- type TypeVar = Var
- type KindVar = Var
- type TKVar = Var
- type TyCoVar = Id
- 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 :: 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
- isTKVar :: 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
- 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

data Var Source #

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 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 :: (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 # |
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 #
Outputable Var # |
Methods ppr :: Var -> SDoc Source # pprPrec :: Rational -> Var -> SDoc Source #
Uniquable Var # |
Methods getUnique :: Var -> Unique Source #
NamedThing Var # |
Methods getOccName :: Var -> OccName Source # getName :: Var -> Name Source #
type PostRn Id ty # |
type PostRn Id ty = ty
type PostTc Id ty # |
type PostTc Id ty = ty

type CoVar = Id Source #

type Id = Var Source #

type NcId = Id Source #

type DictId = EvId Source #

type DFunId = Id Source #

type EvVar = EvId Source #

type EqVar = EvId Source #

type EvId = Id Source #

type IpId = EvId Source #

type TyVar = Var Source #

type TypeVar = Var Source #

type KindVar = Var Source #

type TKVar = Var Source #

type TyCoVar = Id Source #

## Taking `Var`s apart

varName :: Var -> Name Source #

varUnique :: Var -> Unique Source #

varType :: Var -> Kind Source #

The type or kind of the `Var` in question

## Modifying `Var`s

setVarName :: Var -> Name -> Var Source #

setVarUnique :: Var -> Unique -> Var Source #

setVarType :: Id -> Type -> Id Source #

updateVarType :: (Type -> Type) -> Id -> Id Source #

updateVarTypeM :: Monad m => (Type -> m Type) -> Id -> m Id Source #

## Constructing, taking apart, modifying `Id`s

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

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

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

Exported `Var`s will not be removed as dead code

mkCoVar :: Name -> Type -> CoVar Source #

idInfo :: Id -> IdInfo Source #

idDetails :: Id -> IdDetails Source #

lazySetIdInfo :: Id -> IdInfo -> Var Source #

setIdDetails :: Id -> IdDetails -> Id Source #

globaliseId :: Id -> Id Source #

If it's a local, make it global

setIdExported :: Id -> Id Source #

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

setIdNotExported :: Id -> Id Source #

We can only do this to LocalIds

## Predicates

isId :: Var -> Bool Source #

isTKVar :: Var -> Bool Source #

isTyVar :: Var -> Bool Source #

isTcTyVar :: Var -> Bool Source #

isLocalVar :: Var -> Bool Source #

`isLocalVar` returns `True` for type variables as well as local `Id`s These are the variables that we need to pay attention to when finding free variables, or doing dependency analysis.

isLocalId :: Var -> Bool Source #

isCoVar :: Var -> Bool Source #

isNonCoVarId :: Var -> Bool Source #

isTyCoVar :: Var -> Bool Source #

isGlobalId :: Var -> Bool Source #

isExportedId :: Var -> Bool Source #

`isExportedIdVar` means "don't throw this away"

mustHaveLocalBinding :: Var -> Bool Source #

`mustHaveLocalBinding` returns `True` of `Id`s and `TyVar`s that must have a binding in this module. The converse is not quite right: there are some global `Id`s that must have bindings, such as record selectors. But that doesn't matter, because it's only used for assertions

## Constructing `TyVar`s

mkTyVar :: Name -> Kind -> TyVar Source #

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

## Taking `TyVar`s apart

tyVarName :: TyVar -> Name Source #

tyVarKind :: TyVar -> Kind Source #

tcTyVarDetails :: TyVar -> TcTyVarDetails Source #

setTcTyVarDetails :: TyVar -> TcTyVarDetails -> TyVar Source #

## Modifying `TyVar`s

setTyVarName :: TyVar -> Name -> TyVar Source #

setTyVarUnique :: TyVar -> Unique -> TyVar Source #

setTyVarKind :: TyVar -> Kind -> TyVar Source #

updateTyVarKind :: (Kind -> Kind) -> TyVar -> TyVar Source #

updateTyVarKindM :: Monad m => (Kind -> m Kind) -> TyVar -> m TyVar Source #

nonDetCmpVar :: Var -> Var -> Ordering Source #

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]