Distribution.Package

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".

Package ids

newtype PackageName

Constructors

PackageName

Fields

• unPackageName :: String

Instances

Eq PackageName

Methods

(==) :: PackageName -> PackageName -> Bool

(/=) :: PackageName -> PackageName -> Bool

Data PackageName

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

Methods

compare :: PackageName -> PackageName -> Ordering

(<) :: PackageName -> PackageName -> Bool

(<=) :: PackageName -> PackageName -> Bool

(>) :: PackageName -> PackageName -> Bool

(>=) :: PackageName -> PackageName -> Bool

max :: PackageName -> PackageName -> PackageName

min :: PackageName -> PackageName -> PackageName

Read PackageName

Methods

readsPrec :: Int -> ReadS PackageName

readList :: ReadS [PackageName]

readPrec :: ReadPrec PackageName

readListPrec :: ReadPrec [PackageName]

Show PackageName

Methods

showsPrec :: Int -> PackageName -> ShowS

show :: PackageName -> String

showList :: [PackageName] -> ShowS

Generic PackageName

Associated Types

type Rep PackageName :: * -> *

Methods

from :: PackageName -> Rep PackageName x

to :: Rep PackageName x -> PackageName

Binary PackageName

Methods

put :: PackageName -> Put

get :: Get PackageName

putList :: [PackageName] -> Put

NFData PackageName

Methods

rnf :: PackageName -> ()

Text PackageName

Methods

disp :: PackageName -> Doc

parse :: ReadP r PackageName

type Rep PackageName

type Rep PackageName = D1 (MetaData "PackageName" "Distribution.Package" "Cabal-1.24.0.0-3JM9vM0gd2WB0sWdRR0T8c" True) (C1 (MetaCons "PackageName" PrefixI True) (S1 (MetaSel (Just Symbol "unPackageName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)))

data PackageIdentifier

The name and version of a package.

Constructors

PackageIdentifier

Fields

• pkgName :: PackageName

  The name of this package, eg. foo

• pkgVersion :: Version

  the version of this package, eg 1.2

Instances

Eq PackageIdentifier

Methods

(==) :: PackageIdentifier -> PackageIdentifier -> Bool

(/=) :: PackageIdentifier -> PackageIdentifier -> Bool

Data PackageIdentifier

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

Methods

compare :: PackageIdentifier -> PackageIdentifier -> Ordering

(<) :: PackageIdentifier -> PackageIdentifier -> Bool

(<=) :: PackageIdentifier -> PackageIdentifier -> Bool

(>) :: PackageIdentifier -> PackageIdentifier -> Bool

(>=) :: PackageIdentifier -> PackageIdentifier -> Bool

max :: PackageIdentifier -> PackageIdentifier -> PackageIdentifier

min :: PackageIdentifier -> PackageIdentifier -> PackageIdentifier

Read PackageIdentifier

Methods

readsPrec :: Int -> ReadS PackageIdentifier

readList :: ReadS [PackageIdentifier]

readPrec :: ReadPrec PackageIdentifier

readListPrec :: ReadPrec [PackageIdentifier]

Show PackageIdentifier

Methods

showsPrec :: Int -> PackageIdentifier -> ShowS

show :: PackageIdentifier -> String

showList :: [PackageIdentifier] -> ShowS

Generic PackageIdentifier

Associated Types

type Rep PackageIdentifier :: * -> *

Methods

from :: PackageIdentifier -> Rep PackageIdentifier x

to :: Rep PackageIdentifier x -> PackageIdentifier

Binary PackageIdentifier

Methods

put :: PackageIdentifier -> Put

get :: Get PackageIdentifier

putList :: [PackageIdentifier] -> Put

NFData PackageIdentifier

Methods

rnf :: PackageIdentifier -> ()

Text PackageIdentifier

Methods

disp :: PackageIdentifier -> Doc

parse :: ReadP r PackageIdentifier

Package PackageIdentifier

Methods

packageId :: PackageIdentifier -> PackageIdentifier

type Rep PackageIdentifier

type Rep PackageIdentifier = D1 (MetaData "PackageIdentifier" "Distribution.Package" "Cabal-1.24.0.0-3JM9vM0gd2WB0sWdRR0T8c" False) (C1 (MetaCons "PackageIdentifier" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "pkgName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 PackageName)) (S1 (MetaSel (Just Symbol "pkgVersion") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Version))))

type PackageId = PackageIdentifier

Type alias so we can use the shorter name PackageId.

Package keys/installed package IDs (used for linker symbols)

data ComponentId

A ComponentId uniquely identifies the transitive source code closure of a component. For non-Backpack components, it also serves as the basis for install paths, symbols, etc.

Constructors

ComponentId String

Instances

Eq ComponentId

Methods

(==) :: ComponentId -> ComponentId -> Bool

(/=) :: ComponentId -> ComponentId -> Bool

Data ComponentId

Methods

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

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

toConstr :: ComponentId -> Constr

dataTypeOf :: ComponentId -> DataType

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

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

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

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

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

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

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

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

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

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

Ord ComponentId

Methods

compare :: ComponentId -> ComponentId -> Ordering

(<) :: ComponentId -> ComponentId -> Bool

(<=) :: ComponentId -> ComponentId -> Bool

(>) :: ComponentId -> ComponentId -> Bool

(>=) :: ComponentId -> ComponentId -> Bool

max :: ComponentId -> ComponentId -> ComponentId

min :: ComponentId -> ComponentId -> ComponentId

Read ComponentId

Methods

readsPrec :: Int -> ReadS ComponentId

readList :: ReadS [ComponentId]

readPrec :: ReadPrec ComponentId

readListPrec :: ReadPrec [ComponentId]

Show ComponentId

Methods

showsPrec :: Int -> ComponentId -> ShowS

show :: ComponentId -> String

showList :: [ComponentId] -> ShowS

Generic ComponentId

Associated Types

type Rep ComponentId :: * -> *

Methods

from :: ComponentId -> Rep ComponentId x

to :: Rep ComponentId x -> ComponentId

Binary ComponentId

Methods

put :: ComponentId -> Put

get :: Get ComponentId

putList :: [ComponentId] -> Put

NFData ComponentId

Methods

rnf :: ComponentId -> ()

Text ComponentId

Methods

disp :: ComponentId -> Doc

parse :: ReadP r ComponentId

type Rep ComponentId

type Rep ComponentId = D1 (MetaData "ComponentId" "Distribution.Package" "Cabal-1.24.0.0-3JM9vM0gd2WB0sWdRR0T8c" False) (C1 (MetaCons "ComponentId" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)))

newtype UnitId

For now, there is no distinction between component IDs and unit IDs in Cabal.

Constructors

SimpleUnitId ComponentId

Instances

Eq UnitId

Methods

(==) :: UnitId -> UnitId -> Bool

(/=) :: UnitId -> UnitId -> Bool

Data UnitId

Methods

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

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

toConstr :: UnitId -> Constr

dataTypeOf :: UnitId -> DataType

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

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

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

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

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

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

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

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

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

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

Ord UnitId

Methods

compare :: UnitId -> UnitId -> Ordering

(<) :: UnitId -> UnitId -> Bool

(<=) :: UnitId -> UnitId -> Bool

(>) :: UnitId -> UnitId -> Bool

(>=) :: UnitId -> UnitId -> Bool

max :: UnitId -> UnitId -> UnitId

min :: UnitId -> UnitId -> UnitId

Read UnitId

Methods

readsPrec :: Int -> ReadS UnitId

readList :: ReadS [UnitId]

readPrec :: ReadPrec UnitId

readListPrec :: ReadPrec [UnitId]

Show UnitId

Methods

showsPrec :: Int -> UnitId -> ShowS

show :: UnitId -> String

showList :: [UnitId] -> ShowS

Generic UnitId

Associated Types

type Rep UnitId :: * -> *

Methods

from :: UnitId -> Rep UnitId x

to :: Rep UnitId x -> UnitId

Binary UnitId

Methods

put :: UnitId -> Put

get :: Get UnitId

putList :: [UnitId] -> Put

NFData UnitId

Methods

rnf :: UnitId -> ()

Text UnitId

Methods

disp :: UnitId -> Doc

parse :: ReadP r UnitId

type Rep UnitId

type Rep UnitId = D1 (MetaData "UnitId" "Distribution.Package" "Cabal-1.24.0.0-3JM9vM0gd2WB0sWdRR0T8c" True) (C1 (MetaCons "SimpleUnitId" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ComponentId)))

mkUnitId :: String -> UnitId

Makes a simple-style UnitId from a string.

mkLegacyUnitId :: PackageId -> UnitId

Make an old-style UnitId from a package identifier

getHSLibraryName :: UnitId -> String

Returns library name prefixed with HS, suitable for filenames

type InstalledPackageId = UnitId

Deprecated: Use UnitId instead

ABI hash

newtype AbiHash

Constructors

AbiHash String

Instances

Eq AbiHash

Methods

(==) :: AbiHash -> AbiHash -> Bool

(/=) :: AbiHash -> AbiHash -> Bool

Read AbiHash

Methods

readsPrec :: Int -> ReadS AbiHash

readList :: ReadS [AbiHash]

readPrec :: ReadPrec AbiHash

readListPrec :: ReadPrec [AbiHash]

Show AbiHash

Methods

showsPrec :: Int -> AbiHash -> ShowS

show :: AbiHash -> String

showList :: [AbiHash] -> ShowS

Generic AbiHash

Associated Types

type Rep AbiHash :: * -> *

Methods

from :: AbiHash -> Rep AbiHash x

to :: Rep AbiHash x -> AbiHash

Binary AbiHash

Methods

put :: AbiHash -> Put

get :: Get AbiHash

putList :: [AbiHash] -> Put

Text AbiHash

Methods

disp :: AbiHash -> Doc

parse :: ReadP r AbiHash

type Rep AbiHash

type Rep AbiHash = D1 (MetaData "AbiHash" "Distribution.Package" "Cabal-1.24.0.0-3JM9vM0gd2WB0sWdRR0T8c" True) (C1 (MetaCons "AbiHash" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)))

Package source dependencies

data Dependency

Describes a dependency on a source package (API)

Constructors

Dependency PackageName VersionRange

Instances

Eq Dependency

Methods

(==) :: Dependency -> Dependency -> Bool

(/=) :: Dependency -> Dependency -> Bool

Data Dependency

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

Methods

readsPrec :: Int -> ReadS Dependency

readList :: ReadS [Dependency]

readPrec :: ReadPrec Dependency

readListPrec :: ReadPrec [Dependency]

Show Dependency

Methods

showsPrec :: Int -> Dependency -> ShowS

show :: Dependency -> String

showList :: [Dependency] -> ShowS

Generic Dependency

Associated Types

type Rep Dependency :: * -> *

Methods

from :: Dependency -> Rep Dependency x

to :: Rep Dependency x -> Dependency

Binary Dependency

Methods

put :: Dependency -> Put

get :: Get Dependency

putList :: [Dependency] -> Put

Text Dependency

Methods

disp :: Dependency -> Doc

parse :: ReadP r Dependency

type Rep Dependency

type Rep Dependency = D1 (MetaData "Dependency" "Distribution.Package" "Cabal-1.24.0.0-3JM9vM0gd2WB0sWdRR0T8c" False) (C1 (MetaCons "Dependency" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 PackageName)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VersionRange))))

thisPackageVersion :: PackageIdentifier -> Dependency

notThisPackageVersion :: PackageIdentifier -> Dependency

simplifyDependency :: Dependency -> Dependency

Simplify the VersionRange expression in a Dependency. See simplifyVersionRange.

Package classes

class Package pkg where

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.

Minimal complete definition

packageId

Methods

packageId :: pkg -> PackageIdentifier

Instances

Package PackageIdentifier

Methods

packageId :: PackageIdentifier -> PackageIdentifier

Package GenericPackageDescription

Methods

packageId :: GenericPackageDescription -> PackageIdentifier

Package PackageDescription

Methods

packageId :: PackageDescription -> PackageIdentifier

Package InstalledPackageInfo

Methods

packageId :: InstalledPackageInfo -> PackageIdentifier

packageName :: Package pkg => pkg -> PackageName

packageVersion :: Package pkg => pkg -> Version

class Package pkg => HasUnitId pkg where

Packages that have an installed package ID

Minimal complete definition

installedUnitId

Methods

installedUnitId :: pkg -> UnitId

Instances

HasUnitId InstalledPackageInfo

Methods

installedUnitId :: InstalledPackageInfo -> UnitId

installedPackageId :: HasUnitId pkg => pkg -> UnitId

Deprecated: Use installedUnitId instead

Compatibility wrapper for Cabal pre-1.24.

class HasUnitId pkg => PackageInstalled pkg where

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.

Minimal complete definition

installedDepends

Methods

installedDepends :: pkg -> [UnitId]

Instances

PackageInstalled InstalledPackageInfo

Methods

installedDepends :: InstalledPackageInfo -> [UnitId]