ghc-8.2.2: The GHC API

Safe Haskell | None
Language | Haskell2010

Name

Contents

- The main types
  - Creating `Name`s
  - Manipulating and deconstructing `Name`s
  - Predicates on `Name`s
- Class `NamedThing` and overloaded friends

Description

GHC uses several kinds of name internally:

- `OccName`: see OccName
- `RdrName`: see RdrName
- `Name` is the type of names that have had their scoping and binding resolved. They have an `OccName` but also a `Unique` that disambiguates Names that have the same `OccName` and indeed is used for all `Name` comparison. Names also contain information about where they originated from, see Name
- `Id`: see Id
- `Var`: see Var

Names are one of:

- External, if they name things declared in other modules. Some external Names are wired in, i.e. they name primitives defined in the compiler itself
- Internal, if they name things in the module being compiled. Some internal Names are system names, if they are names manufactured by the compiler

Synopsis

- data Name
- data BuiltInSyntax
  - = BuiltInSyntax
  - | UserSyntax
- mkSystemName :: Unique -> OccName -> Name
- mkSystemNameAt :: Unique -> OccName -> SrcSpan -> Name
- mkInternalName :: Unique -> OccName -> SrcSpan -> Name
- mkClonedInternalName :: Unique -> Name -> Name
- mkDerivedInternalName :: (OccName -> OccName) -> Unique -> Name -> Name
- mkSystemVarName :: Unique -> FastString -> Name
- mkSysTvName :: Unique -> FastString -> Name
- mkFCallName :: Unique -> String -> Name
- mkExternalName :: Unique -> Module -> OccName -> SrcSpan -> Name
- mkWiredInName :: Module -> OccName -> Unique -> TyThing -> BuiltInSyntax -> Name
- nameUnique :: Name -> Unique
- setNameUnique :: Name -> Unique -> Name
- nameOccName :: Name -> OccName
- nameModule :: Name -> Module
- nameModule_maybe :: Name -> Maybe Module
- setNameLoc :: Name -> SrcSpan -> Name
- tidyNameOcc :: Name -> OccName -> Name
- localiseName :: Name -> Name
- mkLocalisedOccName :: Module -> (Maybe String -> OccName -> OccName) -> Name -> OccName
- nameSrcLoc :: Name -> SrcLoc
- nameSrcSpan :: Name -> SrcSpan
- pprNameDefnLoc :: Name -> SDoc
- pprDefinedAt :: Name -> SDoc
- isSystemName :: Name -> Bool
- isInternalName :: Name -> Bool
- isExternalName :: Name -> Bool
- isTyVarName :: Name -> Bool
- isTyConName :: Name -> Bool
- isDataConName :: Name -> Bool
- isValName :: Name -> Bool
- isVarName :: Name -> Bool
- isWiredInName :: Name -> Bool
- isBuiltInSyntax :: Name -> Bool
- isHoleName :: Name -> Bool
- wiredInNameTyThing_maybe :: Name -> Maybe TyThing
- nameIsLocalOrFrom :: Module -> Name -> Bool
- nameIsHomePackage :: Module -> Name -> Bool
- nameIsHomePackageImport :: Module -> Name -> Bool
- nameIsFromExternalPackage :: UnitId -> Name -> Bool
- stableNameCmp :: Name -> Name -> Ordering
- class NamedThing a where
- getSrcLoc :: NamedThing a => a -> SrcLoc
- getSrcSpan :: NamedThing a => a -> SrcSpan
- getOccString :: NamedThing a => a -> String
- getOccFS :: NamedThing a => a -> FastString
- pprInfixName :: (Outputable a, NamedThing a) => a -> SDoc
- pprPrefixName :: NamedThing a => a -> SDoc
- pprModulePrefix :: PprStyle -> Module -> OccName -> SDoc
- nameStableString :: Name -> String
- module OccName

# The main types

data Name #

A unique, unambiguous name for something, containing information about where that thing originated.

Instances

Eq Name # |
Methods (==) :: Name -> Name -> Bool # (/=) :: Name -> Name -> Bool #
Data Name # |

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Name -> c Name Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Name Source #

toConstr :: Name -> Constr Source #

dataTypeOf :: Name -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Name) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name) Source #

gmapT :: (forall b. Data b => b -> b) -> Name -> Name Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Name -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Name -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Name -> m Name Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Name -> m Name Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Name -> m Name Source #

Ord Name # |
Methods compare :: Name -> Name -> Ordering # (<) :: Name -> Name -> Bool # (<=) :: Name -> Name -> Bool # (>) :: Name -> Name -> Bool # (>=) :: Name -> Name -> Bool # max :: Name -> Name -> Name # min :: Name -> Name -> Name #
NFData Name # |
Methods rnf :: Name -> () Source #
OutputableBndr Name # |
Methods pprBndr :: BindingSite -> Name -> SDoc # pprPrefixOcc :: Name -> SDoc # pprInfixOcc :: Name -> SDoc # bndrIsJoin_maybe :: Name -> Maybe Int #
Outputable Name # |
Methods ppr :: Name -> SDoc # pprPrec :: Rational -> Name -> SDoc #
Uniquable Name # |
Methods getUnique :: Name -> Unique #
Binary Name # | Assumes that the `Name` is a non-binding one. See `putIfaceTopBndr` and `getIfaceTopBndr` for serializing binding `Name`s. See `UserData` for the rationale for this distinction.
Methods put_ :: BinHandle -> Name -> IO () # put :: BinHandle -> Name -> IO (Bin * Name) # get :: BinHandle -> IO Name #
HasOccName Name # |
Methods occName :: Name -> OccName #
NamedThing Name # |
Methods getOccName :: Name -> OccName # getName :: Name -> Name #
type PostRn Name ty # |
type PostRn Name ty = ty
type PostTc Name ty # |
type PostTc Name ty = PlaceHolder

data BuiltInSyntax #

BuiltInSyntax is for things like `(:)`, `[]` and tuples, which have special syntactic forms. They aren't in scope as such.

Constructors

BuiltInSyntax |
UserSyntax |

## Creating `Name`s

mkSystemName :: Unique -> OccName -> Name #

Create a name brought into being by the compiler

mkSystemNameAt :: Unique -> OccName -> SrcSpan -> Name #

mkInternalName :: Unique -> OccName -> SrcSpan -> Name #

Create a name which is (for now at least) local to the current module and hence does not need a `Module` to disambiguate it from other `Name`s

mkClonedInternalName :: Unique -> Name -> Name #

mkDerivedInternalName :: (OccName -> OccName) -> Unique -> Name -> Name #

mkSystemVarName :: Unique -> FastString -> Name #

mkSysTvName :: Unique -> FastString -> Name #

mkFCallName :: Unique -> String -> Name #

Make a name for a foreign call

mkExternalName :: Unique -> Module -> OccName -> SrcSpan -> Name #

Create a name which definitely originates in the given module

mkWiredInName :: Module -> OccName -> Unique -> TyThing -> BuiltInSyntax -> Name #

Create a name which is actually defined by the compiler itself

## Manipulating and deconstructing `Name`s

nameUnique :: Name -> Unique #

setNameUnique :: Name -> Unique -> Name #

nameOccName :: Name -> OccName #

nameModule :: Name -> Module #

nameModule_maybe :: Name -> Maybe Module #

setNameLoc :: Name -> SrcSpan -> Name #

tidyNameOcc :: Name -> OccName -> Name #

localiseName :: Name -> Name #

Make the `Name` into an internal name, regardless of what it was to begin with

mkLocalisedOccName :: Module -> (Maybe String -> OccName -> OccName) -> Name -> OccName #

Create a localised variant of a name.

If the name is external, encode the original's module name to disambiguate. SPJ says: this looks like a rather odd-looking function; but it seems to be used only during vectorisation, so I'm not going to worry

nameSrcLoc :: Name -> SrcLoc #

nameSrcSpan :: Name -> SrcSpan #

pprNameDefnLoc :: Name -> SDoc #

pprDefinedAt :: Name -> SDoc #

## Predicates on `Name`s

isSystemName :: Name -> Bool #

isInternalName :: Name -> Bool #

isExternalName :: Name -> Bool #

isTyVarName :: Name -> Bool #

isTyConName :: Name -> Bool #

isDataConName :: Name -> Bool #

isValName :: Name -> Bool #

isVarName :: Name -> Bool #

isWiredInName :: Name -> Bool #

isBuiltInSyntax :: Name -> Bool #

isHoleName :: Name -> Bool #

wiredInNameTyThing_maybe :: Name -> Maybe TyThing #

nameIsLocalOrFrom :: Module -> Name -> Bool #

Returns True if the name is (a) Internal (b) External but from the specified module (c) External but from the `interactive` package

The key idea is that False means: the entity is defined in some other module you can find the details (type, fixity, instances) in some interface file those details will be stored in the EPT or HPT

True means: the entity is defined in this module or earlier in the GHCi session you can find details (type, fixity, instances) in the TcGblEnv or TcLclEnv

The isInteractiveModule part is because successive interactions of a GCHi session each give rise to a fresh module (Ghci1, Ghci2, etc), but they all come from the magic `interactive` package; and all the details are kept in the TcLclEnv, TcGblEnv, NOT in the HPT or EPT. See Note [The interactive package] in HscTypes

nameIsHomePackage :: Module -> Name -> Bool #

nameIsHomePackageImport :: Module -> Name -> Bool #

nameIsFromExternalPackage :: UnitId -> Name -> Bool #

Returns True if the Name comes from some other package: neither this pacakge nor the interactive package.

stableNameCmp :: Name -> Name -> Ordering #

Compare Names lexicographically This only works for Names that originate in the source code or have been tidied.

# Class `NamedThing` and overloaded friends

class NamedThing a where #

A class allowing convenient access to the `Name` of various datatypes

Minimal complete definition

getName

Methods

getOccName :: a -> OccName #

getName :: a -> Name #

Instances

NamedThing Name # |
Methods getOccName :: Name -> OccName # getName :: Name -> Name #
NamedThing TyCon # |
Methods getOccName :: TyCon -> OccName # getName :: TyCon -> Name #
NamedThing TyThing # |
Methods getOccName :: TyThing -> OccName # getName :: TyThing -> Name #
NamedThing Var # |
Methods getOccName :: Var -> OccName # getName :: Var -> Name #
NamedThing PatSyn # |
Methods getOccName :: PatSyn -> OccName # getName :: PatSyn -> Name #
NamedThing DataCon # |
Methods getOccName :: DataCon -> OccName # getName :: DataCon -> Name #
NamedThing ConLike # |
Methods getOccName :: ConLike -> OccName # getName :: ConLike -> Name #
NamedThing Class # |
Methods getOccName :: Class -> OccName # getName :: Class -> Name #
NamedThing FamInst # |
Methods getOccName :: FamInst -> OccName # getName :: FamInst -> Name #
NamedThing IfaceConDecl # |
Methods getOccName :: IfaceConDecl -> OccName # getName :: IfaceConDecl -> Name #
NamedThing IfaceClassOp # |
Methods getOccName :: IfaceClassOp -> OccName # getName :: IfaceClassOp -> Name #
NamedThing IfaceDecl # |
Methods getOccName :: IfaceDecl -> OccName # getName :: IfaceDecl -> Name #
NamedThing ClsInst # |
Methods getOccName :: ClsInst -> OccName # getName :: ClsInst -> Name #
NamedThing (CoAxiom br) # |
Methods getOccName :: CoAxiom br -> OccName # getName :: CoAxiom br -> Name #
NamedThing e => NamedThing (GenLocated l e) # |
Methods getOccName :: GenLocated l e -> OccName # getName :: GenLocated l e -> Name #

getSrcLoc :: NamedThing a => a -> SrcLoc #

getSrcSpan :: NamedThing a => a -> SrcSpan #

getOccString :: NamedThing a => a -> String #

getOccFS :: NamedThing a => a -> FastString #

pprInfixName :: (Outputable a, NamedThing a) => a -> SDoc #

pprPrefixName :: NamedThing a => a -> SDoc #

pprModulePrefix :: PprStyle -> Module -> OccName -> SDoc #

nameStableString :: Name -> String #

Get a string representation of a `Name` that's unique and stable across recompilations. Used for deterministic generation of binds for derived instances. eg. "$aeson_70dylHtv1FFGeai1IoxcQr$Data.Aeson.Types.Internal$String"

module OccName