| Safe Haskell | Safe-Inferred | 
|---|---|
| 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
Documentation
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 unitIdHashisNothing. In the absence of Backpack,UnitIdis the same as aComponentId.
- An indefinite, Backpack library with holes.  In this case,
    unitIdHashis stillNothing, but in the install, there are only interfaces, no compiled objects.
- An instantiated Backpack library with all the holes
    filled in.  unitIdHashis aJusta 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
| Parsec UnitId # | The textual format for  | 
| Defined in Distribution.Types.UnitId Methods parsec :: CabalParsing m => m UnitId # | |
| Pretty UnitId # | The textual format for  | 
| Defined in Distribution.Types.UnitId | |
| Structured UnitId # | |
| Defined in Distribution.Types.UnitId | |
| Data UnitId # | |
| Defined in Distribution.Types.UnitId Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UnitId -> c UnitId Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c UnitId Source # toConstr :: UnitId -> Constr Source # dataTypeOf :: UnitId -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c UnitId) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UnitId) Source # gmapT :: (forall b. Data b => b -> b) -> UnitId -> UnitId Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UnitId -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UnitId -> r Source # gmapQ :: (forall d. Data d => d -> u) -> UnitId -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> UnitId -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> UnitId -> m UnitId Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UnitId -> m UnitId Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UnitId -> m UnitId Source # | |
| IsString UnitId # | Since: Cabal-2.0.0.2 | 
| Defined in Distribution.Types.UnitId Methods fromString :: String -> UnitId Source # | |
| Generic UnitId # | |
| Read UnitId # | |
| Show UnitId # | |
| Binary UnitId # | |
| NFData UnitId # | |
| Defined in Distribution.Types.UnitId | |
| Eq UnitId # | |
| Ord UnitId # | |
| type Rep UnitId # | |
| Defined in Distribution.Types.UnitId | |
unUnitId :: UnitId -> String #
If you need backwards compatibility, consider using display
 instead, which is supported by all versions of Cabal.
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
unsafeMkDefUnitId :: UnitId -> DefUnitId #
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