Safe Haskell	None
Language	Haskell2010

Distribution.Types.UnitId

Synopsis

data UnitId
unUnitId :: UnitId -> String
mkUnitId :: String -> UnitId
data DefUnitId
unsafeMkDefUnitId :: UnitId -> DefUnitId
unDefUnitId :: DefUnitId -> UnitId
newSimpleUnitId :: ComponentId -> UnitId
mkLegacyUnitId :: PackageId -> UnitId
getHSLibraryName :: UnitId -> String
type InstalledPackageId = UnitId

Documentation

data UnitId #

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.

Instances

Eq UnitId #
Instance details Methods (==) :: UnitId -> UnitId -> Bool # (/=) :: UnitId -> UnitId -> Bool #
Data UnitId #
Instance details 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 #
Instance details 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 #
Instance details Methods readsPrec :: Int -> ReadS UnitId # readList :: ReadS [UnitId] # readPrec :: ReadPrec UnitId # readListPrec :: ReadPrec [UnitId] #
Show UnitId #
Instance details Methods showsPrec :: Int -> UnitId -> ShowS # show :: UnitId -> String # showList :: [UnitId] -> ShowS #
IsString UnitId #	`mkUnitId` Since: 2.0.0.2
Instance details Methods fromString :: String -> UnitId #
Generic UnitId #
Instance details Associated Types type Rep UnitId :: * -> * # Methods from :: UnitId -> Rep UnitId x # to :: Rep UnitId x -> UnitId #
Binary UnitId #
Instance details Methods put :: UnitId -> Put # get :: Get UnitId # putList :: [UnitId] -> Put #
NFData UnitId #
Instance details Methods rnf :: UnitId -> () #
Pretty UnitId #	The textual format for `UnitId` coincides with the format GHC accepts for `-package-id`.
Instance details Methods pretty :: UnitId -> Doc #
Parsec UnitId #	The textual format for `UnitId` coincides with the format GHC accepts for `-package-id`.
Instance details Methods parsec :: CabalParsing m => m UnitId #
Text UnitId #
Instance details Methods disp :: UnitId -> Doc # parse :: ReadP r UnitId #
type Rep UnitId #
Instance details type Rep UnitId = D1 (MetaData "UnitId" "Distribution.Types.UnitId" "Cabal-2.2.0.1-JS0vobxWxH7sbYKd0omMO" True) (C1 (MetaCons "UnitId" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ShortText)))

unUnitId :: UnitId -> String #

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

mkUnitId :: String -> UnitId #

data DefUnitId #

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.

Instances

Eq DefUnitId #
Instance details Methods (==) :: DefUnitId -> DefUnitId -> Bool # (/=) :: DefUnitId -> DefUnitId -> Bool #
Data DefUnitId #
Instance details Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DefUnitId -> c DefUnitId # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DefUnitId # toConstr :: DefUnitId -> Constr # dataTypeOf :: DefUnitId -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DefUnitId) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DefUnitId) # gmapT :: (forall b. Data b => b -> b) -> DefUnitId -> DefUnitId # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DefUnitId -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DefUnitId -> r # gmapQ :: (forall d. Data d => d -> u) -> DefUnitId -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DefUnitId -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DefUnitId -> m DefUnitId # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DefUnitId -> m DefUnitId # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DefUnitId -> m DefUnitId #
Ord DefUnitId #
Instance details Methods compare :: DefUnitId -> DefUnitId -> Ordering # (<) :: DefUnitId -> DefUnitId -> Bool # (<=) :: DefUnitId -> DefUnitId -> Bool # (>) :: DefUnitId -> DefUnitId -> Bool # (>=) :: DefUnitId -> DefUnitId -> Bool # max :: DefUnitId -> DefUnitId -> DefUnitId # min :: DefUnitId -> DefUnitId -> DefUnitId #
Read DefUnitId #
Instance details Methods readsPrec :: Int -> ReadS DefUnitId # readList :: ReadS [DefUnitId] # readPrec :: ReadPrec DefUnitId # readListPrec :: ReadPrec [DefUnitId] #
Show DefUnitId #
Instance details Methods showsPrec :: Int -> DefUnitId -> ShowS # show :: DefUnitId -> String # showList :: [DefUnitId] -> ShowS #
Generic DefUnitId #
Instance details Associated Types type Rep DefUnitId :: * -> * # Methods from :: DefUnitId -> Rep DefUnitId x # to :: Rep DefUnitId x -> DefUnitId #
Binary DefUnitId #
Instance details Methods put :: DefUnitId -> Put # get :: Get DefUnitId # putList :: [DefUnitId] -> Put #
NFData DefUnitId #
Instance details Methods rnf :: DefUnitId -> () #
Pretty DefUnitId #
Instance details Methods pretty :: DefUnitId -> Doc #
Parsec DefUnitId #
Instance details Methods parsec :: CabalParsing m => m DefUnitId #
Text DefUnitId #
Instance details Methods disp :: DefUnitId -> Doc # parse :: ReadP r DefUnitId #
type Rep DefUnitId #
Instance details type Rep DefUnitId = D1 (MetaData "DefUnitId" "Distribution.Types.UnitId" "Cabal-2.2.0.1-JS0vobxWxH7sbYKd0omMO" True) (C1 (MetaCons "DefUnitId" PrefixI True) (S1 (MetaSel (Just "unDefUnitId") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 UnitId)))

unsafeMkDefUnitId :: UnitId -> DefUnitId #

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

unDefUnitId :: DefUnitId -> UnitId #

newSimpleUnitId :: ComponentId -> UnitId #

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

mkLegacyUnitId :: PackageId -> UnitId #

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

getHSLibraryName :: UnitId -> String #

Returns library name prefixed with HS, suitable for filenames

type InstalledPackageId = UnitId #

Deprecated: Use UnitId instead. This symbol will be removed in Cabal-3.0 (est. Oct 2018).