    {-# LANGUAGE DeriveDataTypeable #-}
    {-# LANGUAGE DeriveGeneric #-}
    module Distribution.Types.ExposedModule where

    import Distribution.Compat.Prelude
    import Prelude ()

    import Distribution.Backpack
    import Distribution.ModuleName
    import Distribution.Parsec
    import Distribution.Pretty

    import qualified Distribution.Compat.CharParsing as P
    import qualified Text.PrettyPrint                as Disp

    data ExposedModule
       = ExposedModule {
           ExposedModule -> ModuleName
    exposedName      :: ModuleName,
           ExposedModule -> Maybe OpenModule
    exposedReexport  :: Maybe OpenModule
         }
      deriving (ExposedModule -> ExposedModule -> Bool
    (ExposedModule -> ExposedModule -> Bool)
    -> (ExposedModule -> ExposedModule -> Bool) -> Eq ExposedModule
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ExposedModule -> ExposedModule -> Bool
    == :: ExposedModule -> ExposedModule -> Bool
    $c/= :: ExposedModule -> ExposedModule -> Bool
    /= :: ExposedModule -> ExposedModule -> Bool
    Eq, (forall x. ExposedModule -> Rep ExposedModule x)
    -> (forall x. Rep ExposedModule x -> ExposedModule)
    -> Generic ExposedModule
    forall x. Rep ExposedModule x -> ExposedModule
    forall x. ExposedModule -> Rep ExposedModule x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. ExposedModule -> Rep ExposedModule x
    from :: forall x. ExposedModule -> Rep ExposedModule x
    $cto :: forall x. Rep ExposedModule x -> ExposedModule
    to :: forall x. Rep ExposedModule x -> ExposedModule
    Generic, ReadPrec [ExposedModule]
    ReadPrec ExposedModule
    Int -> ReadS ExposedModule
    ReadS [ExposedModule]
    (Int -> ReadS ExposedModule)
    -> ReadS [ExposedModule]
    -> ReadPrec ExposedModule
    -> ReadPrec [ExposedModule]
    -> Read ExposedModule
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS ExposedModule
    readsPrec :: Int -> ReadS ExposedModule
    $creadList :: ReadS [ExposedModule]
    readList :: ReadS [ExposedModule]
    $creadPrec :: ReadPrec ExposedModule
    readPrec :: ReadPrec ExposedModule
    $creadListPrec :: ReadPrec [ExposedModule]
    readListPrec :: ReadPrec [ExposedModule]
    Read, Int -> ExposedModule -> ShowS
    [ExposedModule] -> ShowS
    ExposedModule -> String
    (Int -> ExposedModule -> ShowS)
    -> (ExposedModule -> String)
    -> ([ExposedModule] -> ShowS)
    -> Show ExposedModule
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ExposedModule -> ShowS
    showsPrec :: Int -> ExposedModule -> ShowS
    $cshow :: ExposedModule -> String
    show :: ExposedModule -> String
    $cshowList :: [ExposedModule] -> ShowS
    showList :: [ExposedModule] -> ShowS
    Show, Typeable)

    instance Pretty ExposedModule where
        pretty :: ExposedModule -> Doc
    pretty (ExposedModule ModuleName
    m Maybe OpenModule
    reexport) =
            [Doc] -> Doc
    Disp.hsep [ ModuleName -> Doc
    forall a. Pretty a => a -> Doc
    pretty ModuleName
    m
                      , case Maybe OpenModule
    reexport of
                         Just OpenModule
    m' -> [Doc] -> Doc
    Disp.hsep [String -> Doc
    Disp.text String
    "from", OpenModule -> Doc
    forall a. Pretty a => a -> Doc
    pretty OpenModule
    m']
                         Maybe OpenModule
    Nothing -> Doc
    Disp.empty
                      ]

    instance Parsec ExposedModule where
        parsec :: forall (m :: * -> *). CabalParsing m => m ExposedModule
    parsec = do
            ModuleName
    m <- m ModuleName -> m ModuleName
    forall (m :: * -> *) a. CabalParsing m => m a -> m a
    parsecMaybeQuoted m ModuleName
    forall a (m :: * -> *). (Parsec a, CabalParsing m) => m a
    forall (m :: * -> *). CabalParsing m => m ModuleName
    parsec
            m ()
    forall (m :: * -> *). CharParsing m => m ()
    P.spaces

            Maybe OpenModule
    reexport <- m OpenModule -> m (Maybe OpenModule)
    forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
    P.optional (m OpenModule -> m (Maybe OpenModule))
    -> m OpenModule -> m (Maybe OpenModule)
    forall a b. (a -> b) -> a -> b
    $ do
                String
    _ <- String -> m String
    forall (m :: * -> *). CharParsing m => String -> m String
    P.string String
    "from"
                m ()
    forall (m :: * -> *). CharParsing m => m ()
    P.skipSpaces1
                m OpenModule
    forall a (m :: * -> *). (Parsec a, CabalParsing m) => m a
    forall (m :: * -> *). CabalParsing m => m OpenModule
    parsec

            ExposedModule -> m ExposedModule
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (ModuleName -> Maybe OpenModule -> ExposedModule
    ExposedModule ModuleName
    m Maybe OpenModule
    reexport)

    instance Binary ExposedModule
    instance Structured ExposedModule
    instance NFData ExposedModule where rnf :: ExposedModule -> ()
    rnf = ExposedModule -> ()
    forall a. (Generic a, GNFData (Rep a)) => a -> ()
    genericRnf