Distribution.Make

Construct a AbiHash from a String

mkAbiHash is the inverse to unAbiHash

Note: No validations are performed to ensure that the resulting AbiHash is valid

Convert AbiHash to String

Construct a ComponentId from a String

mkComponentId is the inverse to unComponentId

Note: No validations are performed to ensure that the resulting ComponentId is valid

Convert ComponentId to String

Library set with main library.

Smart constructor of Dependency.

If PackageName is appears as LSubLibName in a set of sublibraries, it is automatically converted to LMainLibName.

Simplify the VersionRange expression in a Dependency. See simplifyVersionRange.

Construct a PackageName from a String

mkPackageName is the inverse to unPackageName

Note: No validations are performed to ensure that the resulting PackageName is valid

Construct a PackageName from a ShortText

Note: No validations are performed to ensure that the resulting PackageName is valid

Convert PackageName to String

Construct a PkgconfigName from a String

mkPkgconfigName is the inverse to unPkgconfigName

Note: No validations are performed to ensure that the resulting PkgconfigName is valid

Convert PkgconfigName to String

Returns library name prefixed with HS, suitable for filenames

Make an old-style UnitId from a package identifier. Assumed to be for the public library

Create a unit identity with no associated hash directly from a ComponentId.

If you need backwards compatibility, consider using display instead, which is supported by all versions of Cabal.

Unsafely create a DefUnitId from a UnitId. Your responsibility is to ensure that the DefUnitId invariant holds.

Packages that have an installed unit ID

Class of things that have a PackageIdentifier

Types in this class are all notions of a package. This allows us to have different types for the different phases that packages go though, from simple name/id, package description, configured or installed packages.

Not all kinds of packages can be uniquely identified by a PackageIdentifier. In particular, installed packages cannot, there may be many installed instances of the same source package.

Class of installed packages.

The primary data type which is an instance of this package is InstalledPackageInfo, but when we are doing install plans in Cabal install we may have other, installed package-like things which contain more metadata. Installed packages have exact dependencies installedDepends.

ABI Hashes

Use mkAbiHash and unAbiHash to convert from/to a String.

This type is opaque since Cabal-2.0

A ComponentId uniquely identifies the transitive source code closure of a component (i.e. libraries, executables).

For non-Backpack components, this corresponds one to one with the UnitId, which serves as the basis for install paths, linker symbols, etc.

Use mkComponentId and unComponentId to convert from/to a String.

This type is opaque since Cabal-2.0

Describes a dependency on a source package (API)

Invariant: package name does not appear as LSubLibName in set of library names.

A module identity uniquely identifies a Haskell module by qualifying a ModuleName with the UnitId which defined it. This type distinguishes between two packages which provide a module with the same name, or a module from the same package compiled with different dependencies. There are a few cases where Cabal needs to know about module identities, e.g., when writing out reexported modules in the InstalledPackageInfo.

Type alias so we can use the shorter name PackageId.

The name and version of a package.

A package name.

Use mkPackageName and unPackageName to convert from/to a String.

This type is opaque since Cabal-2.0

A pkg-config library name

This is parsed as any valid argument to the pkg-config utility.

A UnitId for a definite package. The DefUnitId invariant says that a UnitId identified this way is definite; i.e., it has no unfilled holes.

A unit identifier identifies a (possibly instantiated) package/component that can be installed the installed package database. There are several types of components that can be installed:

• A traditional library with no holes, so that unitIdHash is Nothing. In the absence of Backpack, UnitId is the same as a ComponentId.

• An indefinite, Backpack library with holes. In this case, unitIdHash is still Nothing, but in the install, there are only interfaces, no compiled objects.

• An instantiated Backpack library with all the holes filled in. unitIdHash is a Just a hash of the instantiating mapping.

A unit is a component plus the additional information on how the holes are filled in. Thus there is a one to many relationship: for a particular component there are many different ways of filling in the holes, and each different combination is a unit (and has a separate UnitId).

UnitId is distinct from OpenUnitId, in that it is always installed, whereas OpenUnitId are intermediate unit identities that arise during mixin linking, and don't necessarily correspond to any actually installed unit. Since the mapping is not actually recorded in a UnitId, you can't actually substitute over them (but you can substitute over OpenUnitId). See also Distribution.Backpack.FullUnitId for a mechanism for expanding an instantiated UnitId to retrieve its mapping.

Backwards compatibility note: if you need to get the string representation of a UnitId to pass, e.g., as a -package-id flag, use the display function, which will work on all versions of Cabal.

Indicates the license under which a package's source code is released. Versions of the licenses not listed here will be rejected by Hackage and cause cabal check to issue a warning.

A Version represents the version of a software entity.

Instances of Eq and Ord are provided, which gives exact equality and lexicographic ordering of the version number components (i.e. 2.1 > 2.0, 1.2.3 > 1.2.2, etc.).

This type is opaque and distinct from the Version type in Data.Version since Cabal-2.0. The difference extends to the Binary instance using a different (and more compact) encoding.