    -- | Parsers for unit/module identifiers
    module GHC.Unit.Parser
       ( parseUnit
       , parseUnitId
       , parseHoleyModule
       , parseModSubst
       )
    where

    import GHC.Prelude

    import GHC.Unit.Types
    import GHC.Unit.Module.Name
    import GHC.Data.FastString

    import qualified Text.ParserCombinators.ReadP as Parse
    import Text.ParserCombinators.ReadP (ReadP, (<++))
    import Data.Char (isAlphaNum)

    parseUnit :: ReadP Unit
    parseUnit :: ReadP Unit
    parseUnit = ReadP Unit
    parseVirtUnitId ReadP Unit -> ReadP Unit -> ReadP Unit
    forall a. ReadP a -> ReadP a -> ReadP a
    <++ ReadP Unit
    parseDefUnitId
      where
        parseVirtUnitId :: ReadP Unit
    parseVirtUnitId = do
            UnitId
    uid   <- ReadP UnitId
    parseUnitId
            [(ModuleName, Module)]
    insts <- ReadP [(ModuleName, Module)]
    parseModSubst
            Unit -> ReadP Unit
    forall a. a -> ReadP a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (UnitId -> [(ModuleName, Module)] -> Unit
    forall u.
    IsUnitId u =>
    u -> [(ModuleName, GenModule (GenUnit u))] -> GenUnit u
    mkVirtUnit UnitId
    uid [(ModuleName, Module)]
    insts)
        parseDefUnitId :: ReadP Unit
    parseDefUnitId = do
            UnitId
    s <- ReadP UnitId
    parseUnitId
            Unit -> ReadP Unit
    forall a. a -> ReadP a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Definite UnitId -> Unit
    forall uid. Definite uid -> GenUnit uid
    RealUnit (UnitId -> Definite UnitId
    forall unit. unit -> Definite unit
    Definite UnitId
    s))

    parseUnitId :: ReadP UnitId
    parseUnitId :: ReadP UnitId
    parseUnitId = do
       String
    s <- (Char -> Bool) -> ReadP String
    Parse.munch1 (\Char
    c -> Char -> Bool
    isAlphaNum Char
    c Bool -> Bool -> Bool
    || Char
    c Char -> String -> Bool
    forall a. Eq a => a -> [a] -> Bool
    forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
    `elem` String
    "-_.+")
       UnitId -> ReadP UnitId
    forall a. a -> ReadP a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (FastString -> UnitId
    UnitId (String -> FastString
    mkFastString String
    s))

    parseHoleyModule :: ReadP Module
    parseHoleyModule :: ReadP Module
    parseHoleyModule = ReadP Module
    forall {uid}. ReadP (GenModule (GenUnit uid))
    parseModuleVar ReadP Module -> ReadP Module -> ReadP Module
    forall a. ReadP a -> ReadP a -> ReadP a
    <++ ReadP Module
    parseModule
        where
          parseModuleVar :: ReadP (GenModule (GenUnit uid))
    parseModuleVar = do
            Char
    _ <- Char -> ReadP Char
    Parse.char Char
    '<'
            ModuleName
    modname <- ReadP ModuleName
    parseModuleName
            Char
    _ <- Char -> ReadP Char
    Parse.char Char
    '>'
            GenModule (GenUnit uid) -> ReadP (GenModule (GenUnit uid))
    forall a. a -> ReadP a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (GenUnit uid -> ModuleName -> GenModule (GenUnit uid)
    forall unit. unit -> ModuleName -> GenModule unit
    Module GenUnit uid
    forall uid. GenUnit uid
    HoleUnit ModuleName
    modname)
          parseModule :: ReadP Module
    parseModule = do
            Unit
    uid <- ReadP Unit
    parseUnit
            Char
    _ <- Char -> ReadP Char
    Parse.char Char
    ':'
            ModuleName
    modname <- ReadP ModuleName
    parseModuleName
            Module -> ReadP Module
    forall a. a -> ReadP a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Unit -> ModuleName -> Module
    forall unit. unit -> ModuleName -> GenModule unit
    Module Unit
    uid ModuleName
    modname)

    parseModSubst :: ReadP [(ModuleName, Module)]
    parseModSubst :: ReadP [(ModuleName, Module)]
    parseModSubst = ReadP Char
    -> ReadP Char
    -> ReadP [(ModuleName, Module)]
    -> ReadP [(ModuleName, Module)]
    forall open close a.
    ReadP open -> ReadP close -> ReadP a -> ReadP a
    Parse.between (Char -> ReadP Char
    Parse.char Char
    '[') (Char -> ReadP Char
    Parse.char Char
    ']')
          (ReadP [(ModuleName, Module)] -> ReadP [(ModuleName, Module)])
    -> (ReadP (ModuleName, Module) -> ReadP [(ModuleName, Module)])
    -> ReadP (ModuleName, Module)
    -> ReadP [(ModuleName, Module)]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (ReadP (ModuleName, Module)
     -> ReadP Char -> ReadP [(ModuleName, Module)])
    -> ReadP Char
    -> ReadP (ModuleName, Module)
    -> ReadP [(ModuleName, Module)]
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip ReadP (ModuleName, Module)
    -> ReadP Char -> ReadP [(ModuleName, Module)]
    forall a sep. ReadP a -> ReadP sep -> ReadP [a]
    Parse.sepBy (Char -> ReadP Char
    Parse.char Char
    ',')
          (ReadP (ModuleName, Module) -> ReadP [(ModuleName, Module)])
    -> ReadP (ModuleName, Module) -> ReadP [(ModuleName, Module)]
    forall a b. (a -> b) -> a -> b
    $ do ModuleName
    k <- ReadP ModuleName
    parseModuleName
               Char
    _ <- Char -> ReadP Char
    Parse.char Char
    '='
               Module
    v <- ReadP Module
    parseHoleyModule
               (ModuleName, Module) -> ReadP (ModuleName, Module)
    forall a. a -> ReadP a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (ModuleName
    k, Module
    v)