A ModuleName is essentially a simple string, e.g. Data.List.

Returns the string version of the module name, with dots replaced by slashes.

Returns the string version of the module name, with dots replaced by colons.

Get a string representation of a Module that's unique and stable across recompilations. eg. "$aeson_70dylHtv1FFGeai1IoxcQr$Data.Aeson.Types.Internal"

Calculate the free holes of a Module . If this set is non-empty, this module was defined in an indefinite library that had required signatures.

If a module has free holes, that means that substitutions can operate on it; if it has no free holes, substituting over a module has no effect.

A Module is definite if it has no free holes.

Compares module names lexically, rather than by their Unique s

A ComponentId consists of the package name, package version, component ID, the transitive dependencies of the component, and other information to uniquely identify the source code and build configuration of a component.

This used to be known as an InstalledPackageId, but a package can contain multiple components and a ComponentId uniquely identifies a component within a package. When a package only has one component, the ComponentId coincides with the InstalledPackageId

Constructors

A unit identifier identifies a (possibly partially) instantiated library. It is primarily used as part of Module , which in turn is used in Name, which is used to give names to entities when typechecking.

There are two possible forms for a UnitId . It can be a DefiniteUnitId , in which case we just have a string that uniquely identifies some fully compiled, installed library we have on disk. However, when we are typechecking a library with missing holes, we may need to instantiate a library on the fly (in which case we don't have any on-disk representation.) In that case, you have an IndefiniteUnitId , which explicitly records the instantiation, so that we can substitute over it.

Constructors

A unit identifier which identifies an indefinite library (with holes) that has been *on-the-fly* instantiated with a substitution indefUnitIdInsts . In fact, an indefinite unit identifier could have no holes, but we haven't gotten around to compiling the actual library yet.

An indefinite unit identifier pretty-prints to something like p[H=H,A=aimpl:A>] (p is the ComponentId , and the brackets enclose the module substitution).

Constructors

Constructors

Injects an IndefUnitId (indefinite library which was on-the-fly instantiated) to a UnitId (either an indefinite or definite library).

Injects an IndefModule to Module (see also indefUnitIdToUnitId .

An installed unit identifier identifies a library which has been installed to the package database. These strings are provided to us via the -this-unit-id flag. The library in question may be definite or indefinite; if it is indefinite, none of the holes have been filled (we never install partially instantiated libraries.) Put another way, an installed unit id is either fully instantiated, or not instantiated at all.

Installed unit identifiers look something like p+af23SAj2dZ219, or maybe just p if they don't use Backpack.

Constructors

Lossy conversion to the on-disk InstalledUnitId for a component.

Substitution on module variables, mapping module names to module identifiers.

A UnitId is definite if it has no free holes.

Retrieve the set of free holes of a UnitId .

Create a new, un-hashed unit identifier.

Create a new IndefUnitId given an explicit module substitution.

Create a new simple unit identifier (no holes) from a ComponentId .

Generate a uniquely identifying FastString for a unit identifier. This is a one-way function. You can rely on one special property: if a unit identifier is in most general form, its FastString coincides with its ComponentId . This hash is completely internal to GHC and is not used for symbol names or file paths.

Create a new simple unit identifier from a FastString . Internally, this is primarily used to specify wired-in unit identifiers.

Compares package ids lexically, rather than by their Unique s

Substitutes holes in a UnitId , suitable for renaming when an include occurs; see Note [Representation of module/name variable].

p[A=A] maps to p[A=B] with A=B .

Substitutes holes in a Module . NOT suitable for being called directly on a nameModule, see Note [Representation of module/name variable]. p[A=A]:B maps to p[A=q():A]:B with A=q():A; similarly, A maps to q():A.

Like 'renameHoleUnitId, but requires only PackageConfigMap so it can be used by Packages.

Like renameHoleModule , but requires only PackageConfigMap so it can be used by Packages.

Given a possibly on-the-fly instantiated module, split it into a Module that we definitely can find on-disk, as well as an instantiation if we need to instantiate it on the fly. If the instantiation is Nothing no on-the-fly renaming is needed.

See splitModuleInsts .

This is the package Id for the current program. It is the default package Id if you don't specify a package name. We don't add this prefix to symbol names, since there can be only one main package per program.

A Module is a pair of a UnitId and a ModuleName .

Module variables (i.e. H ) which can be instantiated to a specific module at some later point in time are represented with moduleUnitId set to holeUnitId (this allows us to avoid having to make moduleUnitId a partial operation.)

Constructors

Create a module variable at some ModuleName . See Note [Representation of module/name variables]

This gives a stable ordering, as opposed to the Ord instance which gives an ordering based on the Unique s of the components, which may not be stable from run to run of the compiler.

Methods

getModule :: m Module Source #

Methods

extractModule :: t -> Module Source #

A InstalledModule is a Module which contains a InstalledUnitId .

Constructors

A map keyed off of InstalledModule

Test if a Module corresponds to a given InstalledModule , modulo instantiation.

Test if a UnitId corresponds to a given InstalledUnitId , modulo instantiation.

A DefUnitId is an InstalledUnitId with the invariant that it only refers to a definite library; i.e., one we have generated code for.

Constructors

Module Location

Where a module lives on the file system: the actual locations of the .hs, .hi and .o files, if we have them

Constructors

Add the -boot suffix to .hs, .hi and .o files

Add the -boot suffix if the Bool argument is True

Add the -boot suffix to all file paths associated with the module

Add the -boot suffix to all output file paths associated with the module, not including the input file itself

A map keyed off of Module s

A map keyed off of ModuleName s (actually, their Unique s)

A map keyed off of ModuleName s (actually, their Unique s) Has deterministic folds and can be deterministically converted to a list

A set of Module s