    module Distribution.Types.AnnotatedId (
        AnnotatedId(..)
    ) where

    import Prelude ()
    import Distribution.Compat.Prelude

    import Distribution.Package
    import Distribution.Types.ComponentName

    -- | An 'AnnotatedId' is a 'ComponentId', 'UnitId', etc.
    -- which is annotated with some other useful information
    -- that is useful for printing to users, etc.
    --
    -- Invariant: if ann_id x == ann_id y, then ann_pid x == ann_pid y
    -- and ann_cname x == ann_cname y
    data AnnotatedId id = AnnotatedId {
            forall id. AnnotatedId id -> PackageId
    ann_pid   :: PackageId,
            forall id. AnnotatedId id -> ComponentName
    ann_cname :: ComponentName,
            forall id. AnnotatedId id -> id
    ann_id    :: id
        }
        deriving (Int -> AnnotatedId id -> ShowS
    [AnnotatedId id] -> ShowS
    AnnotatedId id -> String
    (Int -> AnnotatedId id -> ShowS)
    -> (AnnotatedId id -> String)
    -> ([AnnotatedId id] -> ShowS)
    -> Show (AnnotatedId id)
    forall id. Show id => Int -> AnnotatedId id -> ShowS
    forall id. Show id => [AnnotatedId id] -> ShowS
    forall id. Show id => AnnotatedId id -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall id. Show id => Int -> AnnotatedId id -> ShowS
    showsPrec :: Int -> AnnotatedId id -> ShowS
    $cshow :: forall id. Show id => AnnotatedId id -> String
    show :: AnnotatedId id -> String
    $cshowList :: forall id. Show id => [AnnotatedId id] -> ShowS
    showList :: [AnnotatedId id] -> ShowS
    Show)

    instance Eq id => Eq (AnnotatedId id) where
        AnnotatedId id
    x == :: AnnotatedId id -> AnnotatedId id -> Bool
    == AnnotatedId id
    y = AnnotatedId id -> id
    forall id. AnnotatedId id -> id
    ann_id AnnotatedId id
    x id -> id -> Bool
    forall a. Eq a => a -> a -> Bool
    == AnnotatedId id -> id
    forall id. AnnotatedId id -> id
    ann_id AnnotatedId id
    y

    instance Ord id => Ord (AnnotatedId id) where
        compare :: AnnotatedId id -> AnnotatedId id -> Ordering
    compare AnnotatedId id
    x AnnotatedId id
    y = id -> id -> Ordering
    forall a. Ord a => a -> a -> Ordering
    compare (AnnotatedId id -> id
    forall id. AnnotatedId id -> id
    ann_id AnnotatedId id
    x) (AnnotatedId id -> id
    forall id. AnnotatedId id -> id
    ann_id AnnotatedId id
    y)

    instance Package (AnnotatedId id) where
        packageId :: AnnotatedId id -> PackageId
    packageId = AnnotatedId id -> PackageId
    forall id. AnnotatedId id -> PackageId
    ann_pid

    instance Functor AnnotatedId where
        fmap :: forall a b. (a -> b) -> AnnotatedId a -> AnnotatedId b
    fmap a -> b
    f (AnnotatedId PackageId
    pid ComponentName
    cn a
    x) = PackageId -> ComponentName -> b -> AnnotatedId b
    forall id. PackageId -> ComponentName -> id -> AnnotatedId id
    AnnotatedId PackageId
    pid ComponentName
    cn (a -> b
    f a
    x)