Cabal-1.22.6.0: A framework for packaging Haskell software

CopyrightIsaac Jones 2003-2004
LicenseBSD3
Maintainercabal-devel@haskell.org
Portabilityportable
Safe HaskellSafe
LanguageHaskell98

Distribution.Package

Contents

Description

Defines a package identifier along with a parser and pretty printer for it. PackageIdentifiers consist of a name and an exact version. It also defines a Dependency data type. A dependency is a package name and a version range, like "foo >= 1.2 && < 2".

Synopsis

Package ids

newtype PackageName Source

Constructors

PackageName 

Instances

Eq PackageName Source 
Data PackageName Source 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PackageName -> c PackageName

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PackageName

toConstr :: PackageName -> Constr

dataTypeOf :: PackageName -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> PackageName -> PackageName

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PackageName -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PackageName -> r

gmapQ :: (forall d. Data d => d -> u) -> PackageName -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> PackageName -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> PackageName -> m PackageName

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PackageName -> m PackageName

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PackageName -> m PackageName

Ord PackageName Source 
Read PackageName Source 
Show PackageName Source 
Generic PackageName Source 

Associated Types

type Rep PackageName :: * -> *

Binary PackageName Source 
NFData PackageName Source 

Methods

rnf :: PackageName -> ()

Text PackageName Source 
type Rep PackageName Source 

data PackageIdentifier Source

The name and version of a package.

Constructors

PackageIdentifier 

Fields

Instances

Eq PackageIdentifier Source 
Data PackageIdentifier Source 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PackageIdentifier -> c PackageIdentifier

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PackageIdentifier

toConstr :: PackageIdentifier -> Constr

dataTypeOf :: PackageIdentifier -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> PackageIdentifier -> PackageIdentifier

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PackageIdentifier -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PackageIdentifier -> r

gmapQ :: (forall d. Data d => d -> u) -> PackageIdentifier -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> PackageIdentifier -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> PackageIdentifier -> m PackageIdentifier

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PackageIdentifier -> m PackageIdentifier

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PackageIdentifier -> m PackageIdentifier

Ord PackageIdentifier Source 
Read PackageIdentifier Source 
Show PackageIdentifier Source 
Generic PackageIdentifier Source 
Binary PackageIdentifier Source 
NFData PackageIdentifier Source 

Methods

rnf :: PackageIdentifier -> ()

Text PackageIdentifier Source 
Package PackageIdentifier Source 
type Rep PackageIdentifier Source 

type PackageId = PackageIdentifier Source

Type alias so we can use the shorter name PackageId.

Installed package identifiers

newtype InstalledPackageId Source

An InstalledPackageId uniquely identifies an instance of an installed package. There can be at most one package with a given InstalledPackageId in a package database, or overlay of databases.

Instances

Eq InstalledPackageId Source 
Data InstalledPackageId Source 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InstalledPackageId -> c InstalledPackageId

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c InstalledPackageId

toConstr :: InstalledPackageId -> Constr

dataTypeOf :: InstalledPackageId -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> InstalledPackageId -> InstalledPackageId

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> InstalledPackageId -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> InstalledPackageId -> r

gmapQ :: (forall d. Data d => d -> u) -> InstalledPackageId -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> InstalledPackageId -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> InstalledPackageId -> m InstalledPackageId

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InstalledPackageId -> m InstalledPackageId

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InstalledPackageId -> m InstalledPackageId

Ord InstalledPackageId Source 
Read InstalledPackageId Source 
Show InstalledPackageId Source 
Generic InstalledPackageId Source 
Binary InstalledPackageId Source 
Text InstalledPackageId Source 
type Rep InstalledPackageId Source 

Package keys (used for linker symbols and library name)

data PackageKey Source

A PackageKey is the notion of "package ID" which is visible to the compiler. Why is this not a PackageId? The PackageId is a user-visible concept written explicity in Cabal files; on the other hand, a PackageKey may contain, for example, information about the transitive dependency tree of a package. Why is this not an InstalledPackageId? A PackageKey affects the ABI because it is used for linker symbols; however, an InstalledPackageId can be used to distinguish two ABI-compatible versions of a library.

The key is defined to be a 128-bit MD5 hash, separated into two 64-bit components (the most significant component coming first) which are individually base-62 encoded (A-Z, a-z, 0-9).

     key         ::= hash64 hash64
     hash64      ::= [A-Za-z0-9]{11}

The string that is hashed is specified as raw_key:

     raw_key     ::= package_id "n"
                     holes_nl
                     depends_nl
     package_id  ::= package_name "-" package_version
     holes_nl    ::= ""
                   | hole_inst "n" holes_nl
     hole_inst   ::= modulename " " key ":" modulename
     depends_nl  ::= ""
                   | depend "n" depends_nl
     depend      ::= key

The holes list MUST be sorted by the first modulename; the depends list MUST be sorted by the key. holes describes the backing implementations of all holes in the package; depends describes all of the build-depends of a package. A package key MAY be used in holes even if it is not mentioned in depends: depends contains STRICTLY packages which are textually mentioned in the package description.

The trailing newline is MANDATORY.

There is also a variant of package key which is prefixed by a informational string. This key MUST NOT be used in the computation of the hash proper, but it is useful for human-readable consumption.

     infokey     ::= infostring "_" key
     infostring  ::= [A-Za-z0-9-]+

For example, Cabal provides a key with the first five characters of the package name for linker symbols.

Constructors

PackageKey !String !Word64 !Word64

Modern package key which is a hash of the PackageId and the transitive dependency key. Manually inline it here so we can get the instances we need. Also contains a short informative string

OldPackageKey !PackageId

Old-style package key which is just a PackageId. Required because old versions of GHC assume that the sourcePackageId recorded for an installed package coincides with the package key it was compiled with.

Instances

Eq PackageKey Source 
Data PackageKey Source 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PackageKey -> c PackageKey

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PackageKey

toConstr :: PackageKey -> Constr

dataTypeOf :: PackageKey -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> PackageKey -> PackageKey

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PackageKey -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PackageKey -> r

gmapQ :: (forall d. Data d => d -> u) -> PackageKey -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> PackageKey -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> PackageKey -> m PackageKey

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PackageKey -> m PackageKey

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PackageKey -> m PackageKey

Ord PackageKey Source 
Read PackageKey Source 
Show PackageKey Source 
Generic PackageKey Source 

Associated Types

type Rep PackageKey :: * -> *

Binary PackageKey Source 
NFData PackageKey Source 

Methods

rnf :: PackageKey -> ()

Text PackageKey Source 
type Rep PackageKey Source 

mkPackageKey :: Bool -> PackageId -> [PackageKey] -> [(ModuleName, (PackageKey, ModuleName))] -> PackageKey Source

Generates a PackageKey from a PackageId, sorted package keys of the immediate dependencies.

Package source dependencies

data Dependency Source

Describes a dependency on a source package (API)

Instances

Eq Dependency Source 
Data Dependency Source 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Dependency -> c Dependency

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Dependency

toConstr :: Dependency -> Constr

dataTypeOf :: Dependency -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> Dependency -> Dependency

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Dependency -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Dependency -> r

gmapQ :: (forall d. Data d => d -> u) -> Dependency -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Dependency -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Dependency -> m Dependency

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Dependency -> m Dependency

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Dependency -> m Dependency

Read Dependency Source 
Show Dependency Source 
Generic Dependency Source 

Associated Types

type Rep Dependency :: * -> *

Binary Dependency Source 
Text Dependency Source 
type Rep Dependency Source 

Package classes

class Package pkg where Source

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 Package pkg => PackageFixedDeps pkg where Source

Subclass of packages that have specific versioned dependencies.

So for example a not-yet-configured package has dependencies on version ranges, not specific versions. A configured or an already installed package depends on exact versions. Some operations or data structures (like dependency graphs) only make sense on this subclass of package types.

Methods

depends :: pkg -> [PackageIdentifier] Source

class Package pkg => PackageInstalled pkg where Source

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.