Documentation

Fields

• unitId :: uid

  Unique unit identifier that is used during compilation (e.g. to generate symbols).

• unitInstanceOf :: compid

  Identifier of an indefinite unit (i.e. with module holes) that this unit is an instance of.

• unitInstantiations :: [(modulename, mod)]

  How this unit instantiates some of its module holes. Map hole module names to actual module

• unitPackageId :: srcpkgid

  Source package identifier.

  Cabal instantiates this with Distribution.Types.PackageId.PackageId type which only contains the source package name and version. Notice that it doesn't contain the Hackage revision, nor any kind of hash.

• unitPackageName :: srcpkgname

  Source package name

• unitPackageVersion :: Version

  Source package version

• unitComponentName :: Maybe srcpkgname

  Name of the component.

  Cabal supports more than one components (libraries, executables, testsuites) in the same package. Each component has a name except the default one (that can only be a library component) for which we use Nothing.

  GHC only deals with "library" components as they are the only kind of components that can be registered in a database and used by other modules.

• unitAbiHash :: String

  ABI hash used to avoid mixing up units compiled with different dependencies, compiler, options, etc.

• unitDepends :: [uid]

  Identifiers of the units this one depends on

• unitAbiDepends :: [(uid, String)]

  Like unitDepends, but each dependency is annotated with the ABI hash we expect the dependency to respect.

• unitImportDirs :: [FilePath]

  Directories containing module interfaces

• unitLibraries :: [String]

  Names of the Haskell libraries provided by this unit

• unitExtDepLibsSys :: [String]

  Names of the external system libraries that this unit depends on. See also unitExtDepLibsGhc field.

• unitExtDepLibsGhc :: [String]

  Because of slight differences between the GHC dynamic linker (in GHC.Runtime.Linker) and the native system linker, some packages have to link with a different list of libraries when using GHC's. Examples include: libs that are actually gnu ld scripts, and the possibility that the .a libs do not exactly match the .so/.dll equivalents.

  If this field is set, then we use that instead of the unitExtDepLibsSys field.

• unitLibraryDirs :: [FilePath]

  Directories containing libraries provided by this unit. See also unitLibraryDynDirs.

  It seems to be used to store paths to external library dependencies too.

• unitLibraryDynDirs :: [FilePath]

  Directories containing the dynamic libraries provided by this unit. See also unitLibraryDirs.

  It seems to be used to store paths to external dynamic library dependencies too.

• unitExtDepFrameworks :: [String]

  Names of the external MacOS frameworks that this unit depends on.

• unitExtDepFrameworkDirs :: [FilePath]

  Directories containing MacOS frameworks that this unit depends on.

• unitLinkerOptions :: [String]

  Linker (e.g. ld) command line options

• unitCcOptions :: [String]

  C compiler options that needs to be passed to the C compiler when we compile some C code against this unit.

• unitIncludes :: [String]

  C header files that are required by this unit (provided by this unit or external)

• unitIncludeDirs :: [FilePath]

  Directories containing C header files that this unit depends on.

• unitHaddockInterfaces :: [FilePath]

  Paths to Haddock interface files for this unit

• unitHaddockHTMLs :: [FilePath]

  Paths to Haddock directories containing HTML files

• unitExposedModules :: [(modulename, Maybe mod)]

  Modules exposed by the unit.

  A module can be re-exported from another package. In this case, we indicate the module origin in the second parameter.

• unitHiddenModules :: [modulename]

  Hidden modules.

  These are useful for error reporting (e.g. if a hidden module is imported)

• unitIsIndefinite :: Bool

  True if this unit has some module holes that need to be instantiated with real modules to make the unit usable (a.k.a. Backpack).

• unitIsExposed :: Bool

  True if the unit is exposed. A unit could be installed in a database by "disabled" by not being exposed.

• unitIsTrusted :: Bool

  True if the unit is trusted (cf Safe Haskell)

Fields

• unPackageName :: FastString
   

Fields

• versionBranch :: [Int]

  The numeric branch for this version. This reflects the fact that most software versions are tree-structured; there is a main trunk which is tagged with versions at various points (1,2,3...), and the first branch off the trunk after version 3 is 3.1, the second branch off the trunk after version 3 is 3.2, and so on. The tree can be branched arbitrarily, just by adding more digits.

  We represent the branch as a list of Int, so version 3.2.1 becomes [3,2,1]. Lexicographic ordering (i.e. the default instance of Ord for [Int]) gives the natural ordering of branches.

• versionTags :: [String]

  A version can be tagged with an arbitrary list of strings. The interpretation of the list of tags is entirely dependent on the entity that this version applies to.