Distribution.Types.MungedPackageName

Documentation

data MungedPackageName

A combination of a package and component name used in various legacy interfaces, chiefly bundled with a version as MungedPackageId. It's generally better to use a UnitId to opaquely refer to some compilation/packing unit, but that doesn't always work, e.g. where a "name" is needed, in which case this can be used as a fallback.

Use mkMungedPackageName and unMungedPackageName to convert from/to a String.

Since: 2.0.0.2

Instances

Eq MungedPackageName

Methods

(==) :: MungedPackageName -> MungedPackageName -> Bool

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

Data MungedPackageName

Methods

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

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

toConstr :: MungedPackageName -> Constr

dataTypeOf :: MungedPackageName -> DataType

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

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

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

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

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

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

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

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

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

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

Ord MungedPackageName

Methods

compare :: MungedPackageName -> MungedPackageName -> Ordering

(<) :: MungedPackageName -> MungedPackageName -> Bool

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

(>) :: MungedPackageName -> MungedPackageName -> Bool

(>=) :: MungedPackageName -> MungedPackageName -> Bool

max :: MungedPackageName -> MungedPackageName -> MungedPackageName

min :: MungedPackageName -> MungedPackageName -> MungedPackageName

Read MungedPackageName

Methods

readsPrec :: Int -> ReadS MungedPackageName

readList :: ReadS [MungedPackageName]

readPrec :: ReadPrec MungedPackageName

readListPrec :: ReadPrec [MungedPackageName]

Show MungedPackageName

Methods

showsPrec :: Int -> MungedPackageName -> ShowS

show :: MungedPackageName -> String

showList :: [MungedPackageName] -> ShowS

IsString MungedPackageName

mkMungedPackageName

Since: 2.0.0.2

Methods

fromString :: String -> MungedPackageName

Generic MungedPackageName

Associated Types

type Rep MungedPackageName :: * -> *

Methods

from :: MungedPackageName -> Rep MungedPackageName x

to :: Rep MungedPackageName x -> MungedPackageName

Binary MungedPackageName

Methods

put :: MungedPackageName -> Put

get :: Get MungedPackageName

putList :: [MungedPackageName] -> Put

NFData MungedPackageName

Methods

rnf :: MungedPackageName -> ()

Text MungedPackageName

Methods

disp :: MungedPackageName -> Doc

parse :: ReadP r MungedPackageName

type Rep MungedPackageName

type Rep MungedPackageName = D1 (MetaData "MungedPackageName" "Distribution.Types.MungedPackageName" "Cabal-2.0.1.0-Fpcf4XP791MK0bLoYSsg8W" True) (C1 (MetaCons "MungedPackageName" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ShortText)))

unMungedPackageName :: MungedPackageName -> String

Convert MungedPackageName to String

mkMungedPackageName :: String -> MungedPackageName

Construct a MungedPackageName from a String

mkMungedPackageName is the inverse to unMungedPackageName

Note: No validations are performed to ensure that the resulting MungedPackageName is valid

Since: 2.0.0.2

computeCompatPackageName :: PackageName -> Maybe UnqualComponentName -> MungedPackageName

Computes the package name for a library. If this is the public library, it will just be the original package name; otherwise, it will be a munged package name recording the original package name as well as the name of the internal library.

A lot of tooling in the Haskell ecosystem assumes that if something is installed to the package database with the package name foo, then it actually is an entry for the (only public) library in package foo. With internal packages, this is not necessarily true: a public library as well as arbitrarily many internal libraries may come from the same package. To prevent tools from getting confused in this case, the package name of these internal libraries is munged so that they do not conflict the public library proper. A particular case where this matters is ghc-pkg: if we don't munge the package name, the inplace registration will OVERRIDE a different internal library.

We munge into a reserved namespace, "z-", and encode both the component name and the package name of an internal library using the following format:

compat-pkg-name ::= "z-" package-name "-z-" library-name

where package-name and library-name have "-" ( "z" + ) "-" segments encoded by adding an extra "z".

When we have the public library, the compat-pkg-name is just the package-name, no surprises there!

decodeCompatPackageName :: MungedPackageName -> (PackageName, Maybe UnqualComponentName)