{-# LANGUAGE MultiParamTypeClasses,TypeSynonymInstances,FlexibleInstances,DeriveDataTypeable,CPP #-}
-- | This modules colelct utility routines related to the different
-- incarnations of identifiers in the code.  The basic identifier is
-- always ASCII, but because of the self generated DescriptorProto
-- data structures it is stored in 'Utf8' tagged lazy bytestrings.
--
-- An 'identifier' is a non-empty ASCII string made of [a-zA-Z0-9_]
-- where the first character is never in [0-9].
--
-- A 'field' is a mangled identifer that is a valid Haskell name that
-- begins with lower case, and which may have a single quote at the
-- end if needed to avoid a reserved word.  These may also start with
-- '_', though just a "_" is mangled to "_'".
--
-- A 'module' is a mangled identifier that is a valid Haskell name
-- that begins with upper case.  These never have a single quote.  A
-- leading '_' is replaced with a leading "U'_" to make a valid
-- identifier.
module Text.ProtocolBuffers.Identifiers
  ( unull,toString,fromString
  , IName(..),DIName(..),FIName(..)
  , MName(..),FMName(..),PMName(..)
  , FName(..),FFName(..),PFName(..)
  , Dotted(..),Mangle(..)
  , joinPM,joinPF,difi,splitDI,splitFI,splitFM
  , checkDIString,checkDIUtf8
  , promoteDI,promoteFI,promoteFM,promoteFF,dotFM,dotFF,fqAppend
  ) where

import qualified Data.ByteString.Lazy.Char8 as LC
import qualified Data.ByteString.Lazy.UTF8 as U
import Data.Char
import Data.List hiding (uncons)
import Data.Generics(Data)
import Data.Typeable(Typeable)
import Data.Set(Set)
import qualified Data.Set as S
import Text.ProtocolBuffers.Basic

-- basic utilities to export

unull :: Utf8 -> Bool
unull :: Utf8 -> Bool
unull = ByteString -> Bool
LC.null (ByteString -> Bool) -> (Utf8 -> ByteString) -> Utf8 -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Utf8 -> ByteString
utf8

toString :: Utf8 -> String
toString :: Utf8 -> String
toString = ByteString -> String
U.toString (ByteString -> String) -> (Utf8 -> ByteString) -> Utf8 -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Utf8 -> ByteString
utf8

fromString :: String -> Utf8
fromString :: String -> Utf8
fromString = ByteString -> Utf8
Utf8 (ByteString -> Utf8) -> (String -> ByteString) -> String -> Utf8
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ByteString
U.fromString

-- | Contains one identifier name
newtype IName a = IName {IName a -> a
iName::a} deriving (Typeable (IName a)
DataType
Constr
Typeable (IName a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> IName a -> c (IName a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (IName a))
-> (IName a -> Constr)
-> (IName a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (IName a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (IName a)))
-> ((forall b. Data b => b -> b) -> IName a -> IName a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> IName a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> IName a -> r)
-> (forall u. (forall d. Data d => d -> u) -> IName a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> IName a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> IName a -> m (IName a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> IName a -> m (IName a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> IName a -> m (IName a))
-> Data (IName a)
IName a -> DataType
IName a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (IName a))
(forall b. Data b => b -> b) -> IName a -> IName a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IName a -> c (IName a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (IName a)
forall a. Data a => Typeable (IName a)
forall a. Data a => IName a -> DataType
forall a. Data a => IName a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> IName a -> IName a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> IName a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> IName a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> IName a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> IName a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> IName a -> m (IName a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> IName a -> m (IName a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (IName a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IName a -> c (IName a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (IName a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (IName a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> IName a -> u
forall u. (forall d. Data d => d -> u) -> IName a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> IName a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> IName a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> IName a -> m (IName a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IName a -> m (IName a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (IName a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IName a -> c (IName a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (IName a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (IName a))
$cIName :: Constr
$tIName :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> IName a -> m (IName a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> IName a -> m (IName a)
gmapMp :: (forall d. Data d => d -> m d) -> IName a -> m (IName a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> IName a -> m (IName a)
gmapM :: (forall d. Data d => d -> m d) -> IName a -> m (IName a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> IName a -> m (IName a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> IName a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> IName a -> u
gmapQ :: (forall d. Data d => d -> u) -> IName a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> IName a -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> IName a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> IName a -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> IName a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> IName a -> r
gmapT :: (forall b. Data b => b -> b) -> IName a -> IName a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> IName a -> IName a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (IName a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (IName a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (IName a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (IName a))
dataTypeOf :: IName a -> DataType
$cdataTypeOf :: forall a. Data a => IName a -> DataType
toConstr :: IName a -> Constr
$ctoConstr :: forall a. Data a => IName a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (IName a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (IName a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IName a -> c (IName a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IName a -> c (IName a)
$cp1Data :: forall a. Data a => Typeable (IName a)
Data,Typeable,IName a -> IName a -> Bool
(IName a -> IName a -> Bool)
-> (IName a -> IName a -> Bool) -> Eq (IName a)
forall a. Eq a => IName a -> IName a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IName a -> IName a -> Bool
$c/= :: forall a. Eq a => IName a -> IName a -> Bool
== :: IName a -> IName a -> Bool
$c== :: forall a. Eq a => IName a -> IName a -> Bool
Eq,Eq (IName a)
Eq (IName a)
-> (IName a -> IName a -> Ordering)
-> (IName a -> IName a -> Bool)
-> (IName a -> IName a -> Bool)
-> (IName a -> IName a -> Bool)
-> (IName a -> IName a -> Bool)
-> (IName a -> IName a -> IName a)
-> (IName a -> IName a -> IName a)
-> Ord (IName a)
IName a -> IName a -> Bool
IName a -> IName a -> Ordering
IName a -> IName a -> IName a
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (IName a)
forall a. Ord a => IName a -> IName a -> Bool
forall a. Ord a => IName a -> IName a -> Ordering
forall a. Ord a => IName a -> IName a -> IName a
min :: IName a -> IName a -> IName a
$cmin :: forall a. Ord a => IName a -> IName a -> IName a
max :: IName a -> IName a -> IName a
$cmax :: forall a. Ord a => IName a -> IName a -> IName a
>= :: IName a -> IName a -> Bool
$c>= :: forall a. Ord a => IName a -> IName a -> Bool
> :: IName a -> IName a -> Bool
$c> :: forall a. Ord a => IName a -> IName a -> Bool
<= :: IName a -> IName a -> Bool
$c<= :: forall a. Ord a => IName a -> IName a -> Bool
< :: IName a -> IName a -> Bool
$c< :: forall a. Ord a => IName a -> IName a -> Bool
compare :: IName a -> IName a -> Ordering
$ccompare :: forall a. Ord a => IName a -> IName a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (IName a)
Ord)
-- | Contains one module name, non-empty
newtype MName a = MName {MName a -> a
mName::a} deriving (Typeable (MName a)
DataType
Constr
Typeable (MName a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> MName a -> c (MName a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (MName a))
-> (MName a -> Constr)
-> (MName a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (MName a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (MName a)))
-> ((forall b. Data b => b -> b) -> MName a -> MName a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MName a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MName a -> r)
-> (forall u. (forall d. Data d => d -> u) -> MName a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> MName a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> MName a -> m (MName a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MName a -> m (MName a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MName a -> m (MName a))
-> Data (MName a)
MName a -> DataType
MName a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (MName a))
(forall b. Data b => b -> b) -> MName a -> MName a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MName a -> c (MName a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (MName a)
forall a. Data a => Typeable (MName a)
forall a. Data a => MName a -> DataType
forall a. Data a => MName a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> MName a -> MName a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> MName a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> MName a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MName a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MName a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> MName a -> m (MName a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> MName a -> m (MName a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (MName a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MName a -> c (MName a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (MName a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (MName a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> MName a -> u
forall u. (forall d. Data d => d -> u) -> MName a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MName a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MName a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MName a -> m (MName a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MName a -> m (MName a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (MName a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MName a -> c (MName a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (MName a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (MName a))
$cMName :: Constr
$tMName :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> MName a -> m (MName a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> MName a -> m (MName a)
gmapMp :: (forall d. Data d => d -> m d) -> MName a -> m (MName a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> MName a -> m (MName a)
gmapM :: (forall d. Data d => d -> m d) -> MName a -> m (MName a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> MName a -> m (MName a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> MName a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> MName a -> u
gmapQ :: (forall d. Data d => d -> u) -> MName a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> MName a -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MName a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MName a -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MName a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MName a -> r
gmapT :: (forall b. Data b => b -> b) -> MName a -> MName a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> MName a -> MName a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (MName a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (MName a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (MName a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (MName a))
dataTypeOf :: MName a -> DataType
$cdataTypeOf :: forall a. Data a => MName a -> DataType
toConstr :: MName a -> Constr
$ctoConstr :: forall a. Data a => MName a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (MName a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (MName a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MName a -> c (MName a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MName a -> c (MName a)
$cp1Data :: forall a. Data a => Typeable (MName a)
Data,Typeable,MName a -> MName a -> Bool
(MName a -> MName a -> Bool)
-> (MName a -> MName a -> Bool) -> Eq (MName a)
forall a. Eq a => MName a -> MName a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MName a -> MName a -> Bool
$c/= :: forall a. Eq a => MName a -> MName a -> Bool
== :: MName a -> MName a -> Bool
$c== :: forall a. Eq a => MName a -> MName a -> Bool
Eq,Eq (MName a)
Eq (MName a)
-> (MName a -> MName a -> Ordering)
-> (MName a -> MName a -> Bool)
-> (MName a -> MName a -> Bool)
-> (MName a -> MName a -> Bool)
-> (MName a -> MName a -> Bool)
-> (MName a -> MName a -> MName a)
-> (MName a -> MName a -> MName a)
-> Ord (MName a)
MName a -> MName a -> Bool
MName a -> MName a -> Ordering
MName a -> MName a -> MName a
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (MName a)
forall a. Ord a => MName a -> MName a -> Bool
forall a. Ord a => MName a -> MName a -> Ordering
forall a. Ord a => MName a -> MName a -> MName a
min :: MName a -> MName a -> MName a
$cmin :: forall a. Ord a => MName a -> MName a -> MName a
max :: MName a -> MName a -> MName a
$cmax :: forall a. Ord a => MName a -> MName a -> MName a
>= :: MName a -> MName a -> Bool
$c>= :: forall a. Ord a => MName a -> MName a -> Bool
> :: MName a -> MName a -> Bool
$c> :: forall a. Ord a => MName a -> MName a -> Bool
<= :: MName a -> MName a -> Bool
$c<= :: forall a. Ord a => MName a -> MName a -> Bool
< :: MName a -> MName a -> Bool
$c< :: forall a. Ord a => MName a -> MName a -> Bool
compare :: MName a -> MName a -> Ordering
$ccompare :: forall a. Ord a => MName a -> MName a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (MName a)
Ord)
-- | Contains one field name, non-empty
newtype FName a = FName {FName a -> a
fName::a} deriving (Typeable (FName a)
DataType
Constr
Typeable (FName a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FName a -> c (FName a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FName a))
-> (FName a -> Constr)
-> (FName a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (FName a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FName a)))
-> ((forall b. Data b => b -> b) -> FName a -> FName a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FName a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FName a -> r)
-> (forall u. (forall d. Data d => d -> u) -> FName a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> FName a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FName a -> m (FName a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FName a -> m (FName a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FName a -> m (FName a))
-> Data (FName a)
FName a -> DataType
FName a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (FName a))
(forall b. Data b => b -> b) -> FName a -> FName a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FName a -> c (FName a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FName a)
forall a. Data a => Typeable (FName a)
forall a. Data a => FName a -> DataType
forall a. Data a => FName a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> FName a -> FName a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> FName a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> FName a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FName a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FName a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> FName a -> m (FName a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> FName a -> m (FName a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FName a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FName a -> c (FName a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (FName a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FName a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> FName a -> u
forall u. (forall d. Data d => d -> u) -> FName a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FName a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FName a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FName a -> m (FName a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FName a -> m (FName a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FName a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FName a -> c (FName a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (FName a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FName a))
$cFName :: Constr
$tFName :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> FName a -> m (FName a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> FName a -> m (FName a)
gmapMp :: (forall d. Data d => d -> m d) -> FName a -> m (FName a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> FName a -> m (FName a)
gmapM :: (forall d. Data d => d -> m d) -> FName a -> m (FName a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> FName a -> m (FName a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> FName a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> FName a -> u
gmapQ :: (forall d. Data d => d -> u) -> FName a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> FName a -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FName a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FName a -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FName a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FName a -> r
gmapT :: (forall b. Data b => b -> b) -> FName a -> FName a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> FName a -> FName a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FName a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FName a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (FName a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (FName a))
dataTypeOf :: FName a -> DataType
$cdataTypeOf :: forall a. Data a => FName a -> DataType
toConstr :: FName a -> Constr
$ctoConstr :: forall a. Data a => FName a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FName a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FName a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FName a -> c (FName a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FName a -> c (FName a)
$cp1Data :: forall a. Data a => Typeable (FName a)
Data,Typeable,FName a -> FName a -> Bool
(FName a -> FName a -> Bool)
-> (FName a -> FName a -> Bool) -> Eq (FName a)
forall a. Eq a => FName a -> FName a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FName a -> FName a -> Bool
$c/= :: forall a. Eq a => FName a -> FName a -> Bool
== :: FName a -> FName a -> Bool
$c== :: forall a. Eq a => FName a -> FName a -> Bool
Eq,Eq (FName a)
Eq (FName a)
-> (FName a -> FName a -> Ordering)
-> (FName a -> FName a -> Bool)
-> (FName a -> FName a -> Bool)
-> (FName a -> FName a -> Bool)
-> (FName a -> FName a -> Bool)
-> (FName a -> FName a -> FName a)
-> (FName a -> FName a -> FName a)
-> Ord (FName a)
FName a -> FName a -> Bool
FName a -> FName a -> Ordering
FName a -> FName a -> FName a
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (FName a)
forall a. Ord a => FName a -> FName a -> Bool
forall a. Ord a => FName a -> FName a -> Ordering
forall a. Ord a => FName a -> FName a -> FName a
min :: FName a -> FName a -> FName a
$cmin :: forall a. Ord a => FName a -> FName a -> FName a
max :: FName a -> FName a -> FName a
$cmax :: forall a. Ord a => FName a -> FName a -> FName a
>= :: FName a -> FName a -> Bool
$c>= :: forall a. Ord a => FName a -> FName a -> Bool
> :: FName a -> FName a -> Bool
$c> :: forall a. Ord a => FName a -> FName a -> Bool
<= :: FName a -> FName a -> Bool
$c<= :: forall a. Ord a => FName a -> FName a -> Bool
< :: FName a -> FName a -> Bool
$c< :: forall a. Ord a => FName a -> FName a -> Bool
compare :: FName a -> FName a -> Ordering
$ccompare :: forall a. Ord a => FName a -> FName a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (FName a)
Ord)
-- | '.' separated identifier which may or may start with a dot.  There
-- are never two or more '.'s in a row.  There is always at least one identifier.
newtype DIName a = DIName {DIName a -> a
diName :: a} deriving (Typeable (DIName a)
DataType
Constr
Typeable (DIName a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DIName a -> c (DIName a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (DIName a))
-> (DIName a -> Constr)
-> (DIName a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (DIName a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (DIName a)))
-> ((forall b. Data b => b -> b) -> DIName a -> DIName a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DIName a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DIName a -> r)
-> (forall u. (forall d. Data d => d -> u) -> DIName a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> DIName a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DIName a -> m (DIName a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIName a -> m (DIName a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIName a -> m (DIName a))
-> Data (DIName a)
DIName a -> DataType
DIName a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (DIName a))
(forall b. Data b => b -> b) -> DIName a -> DIName a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIName a -> c (DIName a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DIName a)
forall a. Data a => Typeable (DIName a)
forall a. Data a => DIName a -> DataType
forall a. Data a => DIName a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> DIName a -> DIName a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> DIName a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> DIName a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIName a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIName a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> DIName a -> m (DIName a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> DIName a -> m (DIName a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DIName a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIName a -> c (DIName a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DIName a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (DIName a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> DIName a -> u
forall u. (forall d. Data d => d -> u) -> DIName a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIName a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIName a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIName a -> m (DIName a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIName a -> m (DIName a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DIName a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIName a -> c (DIName a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DIName a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (DIName a))
$cDIName :: Constr
$tDIName :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> DIName a -> m (DIName a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> DIName a -> m (DIName a)
gmapMp :: (forall d. Data d => d -> m d) -> DIName a -> m (DIName a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> DIName a -> m (DIName a)
gmapM :: (forall d. Data d => d -> m d) -> DIName a -> m (DIName a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> DIName a -> m (DIName a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> DIName a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> DIName a -> u
gmapQ :: (forall d. Data d => d -> u) -> DIName a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> DIName a -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIName a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIName a -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIName a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIName a -> r
gmapT :: (forall b. Data b => b -> b) -> DIName a -> DIName a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> DIName a -> DIName a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (DIName a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (DIName a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (DIName a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DIName a))
dataTypeOf :: DIName a -> DataType
$cdataTypeOf :: forall a. Data a => DIName a -> DataType
toConstr :: DIName a -> Constr
$ctoConstr :: forall a. Data a => DIName a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DIName a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DIName a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIName a -> c (DIName a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIName a -> c (DIName a)
$cp1Data :: forall a. Data a => Typeable (DIName a)
Data,Typeable,DIName a -> DIName a -> Bool
(DIName a -> DIName a -> Bool)
-> (DIName a -> DIName a -> Bool) -> Eq (DIName a)
forall a. Eq a => DIName a -> DIName a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DIName a -> DIName a -> Bool
$c/= :: forall a. Eq a => DIName a -> DIName a -> Bool
== :: DIName a -> DIName a -> Bool
$c== :: forall a. Eq a => DIName a -> DIName a -> Bool
Eq,Eq (DIName a)
Eq (DIName a)
-> (DIName a -> DIName a -> Ordering)
-> (DIName a -> DIName a -> Bool)
-> (DIName a -> DIName a -> Bool)
-> (DIName a -> DIName a -> Bool)
-> (DIName a -> DIName a -> Bool)
-> (DIName a -> DIName a -> DIName a)
-> (DIName a -> DIName a -> DIName a)
-> Ord (DIName a)
DIName a -> DIName a -> Bool
DIName a -> DIName a -> Ordering
DIName a -> DIName a -> DIName a
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (DIName a)
forall a. Ord a => DIName a -> DIName a -> Bool
forall a. Ord a => DIName a -> DIName a -> Ordering
forall a. Ord a => DIName a -> DIName a -> DIName a
min :: DIName a -> DIName a -> DIName a
$cmin :: forall a. Ord a => DIName a -> DIName a -> DIName a
max :: DIName a -> DIName a -> DIName a
$cmax :: forall a. Ord a => DIName a -> DIName a -> DIName a
>= :: DIName a -> DIName a -> Bool
$c>= :: forall a. Ord a => DIName a -> DIName a -> Bool
> :: DIName a -> DIName a -> Bool
$c> :: forall a. Ord a => DIName a -> DIName a -> Bool
<= :: DIName a -> DIName a -> Bool
$c<= :: forall a. Ord a => DIName a -> DIName a -> Bool
< :: DIName a -> DIName a -> Bool
$c< :: forall a. Ord a => DIName a -> DIName a -> Bool
compare :: DIName a -> DIName a -> Ordering
$ccompare :: forall a. Ord a => DIName a -> DIName a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (DIName a)
Ord)
-- | Fully qualified identifier: repeated ('.' then identifier)
newtype FIName a = FIName {FIName a -> a
fiName::a} deriving (Typeable (FIName a)
DataType
Constr
Typeable (FIName a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FIName a -> c (FIName a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FIName a))
-> (FIName a -> Constr)
-> (FIName a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (FIName a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (FIName a)))
-> ((forall b. Data b => b -> b) -> FIName a -> FIName a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FIName a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FIName a -> r)
-> (forall u. (forall d. Data d => d -> u) -> FIName a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> FIName a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FIName a -> m (FIName a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FIName a -> m (FIName a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FIName a -> m (FIName a))
-> Data (FIName a)
FIName a -> DataType
FIName a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (FIName a))
(forall b. Data b => b -> b) -> FIName a -> FIName a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FIName a -> c (FIName a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FIName a)
forall a. Data a => Typeable (FIName a)
forall a. Data a => FIName a -> DataType
forall a. Data a => FIName a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> FIName a -> FIName a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> FIName a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> FIName a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FIName a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FIName a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> FIName a -> m (FIName a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> FIName a -> m (FIName a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FIName a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FIName a -> c (FIName a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (FIName a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FIName a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> FIName a -> u
forall u. (forall d. Data d => d -> u) -> FIName a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FIName a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FIName a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FIName a -> m (FIName a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FIName a -> m (FIName a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FIName a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FIName a -> c (FIName a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (FIName a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FIName a))
$cFIName :: Constr
$tFIName :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> FIName a -> m (FIName a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> FIName a -> m (FIName a)
gmapMp :: (forall d. Data d => d -> m d) -> FIName a -> m (FIName a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> FIName a -> m (FIName a)
gmapM :: (forall d. Data d => d -> m d) -> FIName a -> m (FIName a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> FIName a -> m (FIName a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> FIName a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> FIName a -> u
gmapQ :: (forall d. Data d => d -> u) -> FIName a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> FIName a -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FIName a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FIName a -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FIName a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FIName a -> r
gmapT :: (forall b. Data b => b -> b) -> FIName a -> FIName a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> FIName a -> FIName a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FIName a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FIName a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (FIName a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (FIName a))
dataTypeOf :: FIName a -> DataType
$cdataTypeOf :: forall a. Data a => FIName a -> DataType
toConstr :: FIName a -> Constr
$ctoConstr :: forall a. Data a => FIName a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FIName a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FIName a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FIName a -> c (FIName a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FIName a -> c (FIName a)
$cp1Data :: forall a. Data a => Typeable (FIName a)
Data,Typeable,FIName a -> FIName a -> Bool
(FIName a -> FIName a -> Bool)
-> (FIName a -> FIName a -> Bool) -> Eq (FIName a)
forall a. Eq a => FIName a -> FIName a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FIName a -> FIName a -> Bool
$c/= :: forall a. Eq a => FIName a -> FIName a -> Bool
== :: FIName a -> FIName a -> Bool
$c== :: forall a. Eq a => FIName a -> FIName a -> Bool
Eq,Eq (FIName a)
Eq (FIName a)
-> (FIName a -> FIName a -> Ordering)
-> (FIName a -> FIName a -> Bool)
-> (FIName a -> FIName a -> Bool)
-> (FIName a -> FIName a -> Bool)
-> (FIName a -> FIName a -> Bool)
-> (FIName a -> FIName a -> FIName a)
-> (FIName a -> FIName a -> FIName a)
-> Ord (FIName a)
FIName a -> FIName a -> Bool
FIName a -> FIName a -> Ordering
FIName a -> FIName a -> FIName a
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (FIName a)
forall a. Ord a => FIName a -> FIName a -> Bool
forall a. Ord a => FIName a -> FIName a -> Ordering
forall a. Ord a => FIName a -> FIName a -> FIName a
min :: FIName a -> FIName a -> FIName a
$cmin :: forall a. Ord a => FIName a -> FIName a -> FIName a
max :: FIName a -> FIName a -> FIName a
$cmax :: forall a. Ord a => FIName a -> FIName a -> FIName a
>= :: FIName a -> FIName a -> Bool
$c>= :: forall a. Ord a => FIName a -> FIName a -> Bool
> :: FIName a -> FIName a -> Bool
$c> :: forall a. Ord a => FIName a -> FIName a -> Bool
<= :: FIName a -> FIName a -> Bool
$c<= :: forall a. Ord a => FIName a -> FIName a -> Bool
< :: FIName a -> FIName a -> Bool
$c< :: forall a. Ord a => FIName a -> FIName a -> Bool
compare :: FIName a -> FIName a -> Ordering
$ccompare :: forall a. Ord a => FIName a -> FIName a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (FIName a)
Ord)
-- | Full Haskell module name: MNames separated by '.', ending with a module
newtype FMName a = FMName {FMName a -> a
fmName::a} deriving (Typeable (FMName a)
DataType
Constr
Typeable (FMName a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FMName a -> c (FMName a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FMName a))
-> (FMName a -> Constr)
-> (FMName a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (FMName a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (FMName a)))
-> ((forall b. Data b => b -> b) -> FMName a -> FMName a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FMName a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FMName a -> r)
-> (forall u. (forall d. Data d => d -> u) -> FMName a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> FMName a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FMName a -> m (FMName a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FMName a -> m (FMName a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FMName a -> m (FMName a))
-> Data (FMName a)
FMName a -> DataType
FMName a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (FMName a))
(forall b. Data b => b -> b) -> FMName a -> FMName a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FMName a -> c (FMName a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FMName a)
forall a. Data a => Typeable (FMName a)
forall a. Data a => FMName a -> DataType
forall a. Data a => FMName a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> FMName a -> FMName a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> FMName a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> FMName a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FMName a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FMName a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> FMName a -> m (FMName a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> FMName a -> m (FMName a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FMName a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FMName a -> c (FMName a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (FMName a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FMName a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> FMName a -> u
forall u. (forall d. Data d => d -> u) -> FMName a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FMName a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FMName a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FMName a -> m (FMName a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FMName a -> m (FMName a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FMName a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FMName a -> c (FMName a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (FMName a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FMName a))
$cFMName :: Constr
$tFMName :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> FMName a -> m (FMName a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> FMName a -> m (FMName a)
gmapMp :: (forall d. Data d => d -> m d) -> FMName a -> m (FMName a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> FMName a -> m (FMName a)
gmapM :: (forall d. Data d => d -> m d) -> FMName a -> m (FMName a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> FMName a -> m (FMName a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> FMName a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> FMName a -> u
gmapQ :: (forall d. Data d => d -> u) -> FMName a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> FMName a -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FMName a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FMName a -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FMName a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FMName a -> r
gmapT :: (forall b. Data b => b -> b) -> FMName a -> FMName a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> FMName a -> FMName a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FMName a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FMName a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (FMName a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (FMName a))
dataTypeOf :: FMName a -> DataType
$cdataTypeOf :: forall a. Data a => FMName a -> DataType
toConstr :: FMName a -> Constr
$ctoConstr :: forall a. Data a => FMName a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FMName a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FMName a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FMName a -> c (FMName a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FMName a -> c (FMName a)
$cp1Data :: forall a. Data a => Typeable (FMName a)
Data,Typeable,FMName a -> FMName a -> Bool
(FMName a -> FMName a -> Bool)
-> (FMName a -> FMName a -> Bool) -> Eq (FMName a)
forall a. Eq a => FMName a -> FMName a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FMName a -> FMName a -> Bool
$c/= :: forall a. Eq a => FMName a -> FMName a -> Bool
== :: FMName a -> FMName a -> Bool
$c== :: forall a. Eq a => FMName a -> FMName a -> Bool
Eq,Eq (FMName a)
Eq (FMName a)
-> (FMName a -> FMName a -> Ordering)
-> (FMName a -> FMName a -> Bool)
-> (FMName a -> FMName a -> Bool)
-> (FMName a -> FMName a -> Bool)
-> (FMName a -> FMName a -> Bool)
-> (FMName a -> FMName a -> FMName a)
-> (FMName a -> FMName a -> FMName a)
-> Ord (FMName a)
FMName a -> FMName a -> Bool
FMName a -> FMName a -> Ordering
FMName a -> FMName a -> FMName a
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (FMName a)
forall a. Ord a => FMName a -> FMName a -> Bool
forall a. Ord a => FMName a -> FMName a -> Ordering
forall a. Ord a => FMName a -> FMName a -> FMName a
min :: FMName a -> FMName a -> FMName a
$cmin :: forall a. Ord a => FMName a -> FMName a -> FMName a
max :: FMName a -> FMName a -> FMName a
$cmax :: forall a. Ord a => FMName a -> FMName a -> FMName a
>= :: FMName a -> FMName a -> Bool
$c>= :: forall a. Ord a => FMName a -> FMName a -> Bool
> :: FMName a -> FMName a -> Bool
$c> :: forall a. Ord a => FMName a -> FMName a -> Bool
<= :: FMName a -> FMName a -> Bool
$c<= :: forall a. Ord a => FMName a -> FMName a -> Bool
< :: FMName a -> FMName a -> Bool
$c< :: forall a. Ord a => FMName a -> FMName a -> Bool
compare :: FMName a -> FMName a -> Ordering
$ccompare :: forall a. Ord a => FMName a -> FMName a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (FMName a)
Ord)
-- | Full Haskell field name: MNames separated by '.', ending with a field
newtype FFName a = FFName {FFName a -> a
ffName::a} deriving (Typeable (FFName a)
DataType
Constr
Typeable (FFName a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FFName a -> c (FFName a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (FFName a))
-> (FFName a -> Constr)
-> (FFName a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (FFName a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (FFName a)))
-> ((forall b. Data b => b -> b) -> FFName a -> FFName a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FFName a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FFName a -> r)
-> (forall u. (forall d. Data d => d -> u) -> FFName a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> FFName a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FFName a -> m (FFName a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FFName a -> m (FFName a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FFName a -> m (FFName a))
-> Data (FFName a)
FFName a -> DataType
FFName a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (FFName a))
(forall b. Data b => b -> b) -> FFName a -> FFName a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FFName a -> c (FFName a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FFName a)
forall a. Data a => Typeable (FFName a)
forall a. Data a => FFName a -> DataType
forall a. Data a => FFName a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> FFName a -> FFName a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> FFName a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> FFName a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FFName a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FFName a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> FFName a -> m (FFName a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> FFName a -> m (FFName a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FFName a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FFName a -> c (FFName a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (FFName a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FFName a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> FFName a -> u
forall u. (forall d. Data d => d -> u) -> FFName a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FFName a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FFName a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FFName a -> m (FFName a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FFName a -> m (FFName a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FFName a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FFName a -> c (FFName a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (FFName a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FFName a))
$cFFName :: Constr
$tFFName :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> FFName a -> m (FFName a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> FFName a -> m (FFName a)
gmapMp :: (forall d. Data d => d -> m d) -> FFName a -> m (FFName a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> FFName a -> m (FFName a)
gmapM :: (forall d. Data d => d -> m d) -> FFName a -> m (FFName a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> FFName a -> m (FFName a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> FFName a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> FFName a -> u
gmapQ :: (forall d. Data d => d -> u) -> FFName a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> FFName a -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FFName a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FFName a -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FFName a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FFName a -> r
gmapT :: (forall b. Data b => b -> b) -> FFName a -> FFName a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> FFName a -> FFName a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FFName a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FFName a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (FFName a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (FFName a))
dataTypeOf :: FFName a -> DataType
$cdataTypeOf :: forall a. Data a => FFName a -> DataType
toConstr :: FFName a -> Constr
$ctoConstr :: forall a. Data a => FFName a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FFName a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (FFName a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FFName a -> c (FFName a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FFName a -> c (FFName a)
$cp1Data :: forall a. Data a => Typeable (FFName a)
Data,Typeable,FFName a -> FFName a -> Bool
(FFName a -> FFName a -> Bool)
-> (FFName a -> FFName a -> Bool) -> Eq (FFName a)
forall a. Eq a => FFName a -> FFName a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FFName a -> FFName a -> Bool
$c/= :: forall a. Eq a => FFName a -> FFName a -> Bool
== :: FFName a -> FFName a -> Bool
$c== :: forall a. Eq a => FFName a -> FFName a -> Bool
Eq,Eq (FFName a)
Eq (FFName a)
-> (FFName a -> FFName a -> Ordering)
-> (FFName a -> FFName a -> Bool)
-> (FFName a -> FFName a -> Bool)
-> (FFName a -> FFName a -> Bool)
-> (FFName a -> FFName a -> Bool)
-> (FFName a -> FFName a -> FFName a)
-> (FFName a -> FFName a -> FFName a)
-> Ord (FFName a)
FFName a -> FFName a -> Bool
FFName a -> FFName a -> Ordering
FFName a -> FFName a -> FFName a
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (FFName a)
forall a. Ord a => FFName a -> FFName a -> Bool
forall a. Ord a => FFName a -> FFName a -> Ordering
forall a. Ord a => FFName a -> FFName a -> FFName a
min :: FFName a -> FFName a -> FFName a
$cmin :: forall a. Ord a => FFName a -> FFName a -> FFName a
max :: FFName a -> FFName a -> FFName a
$cmax :: forall a. Ord a => FFName a -> FFName a -> FFName a
>= :: FFName a -> FFName a -> Bool
$c>= :: forall a. Ord a => FFName a -> FFName a -> Bool
> :: FFName a -> FFName a -> Bool
$c> :: forall a. Ord a => FFName a -> FFName a -> Bool
<= :: FFName a -> FFName a -> Bool
$c<= :: forall a. Ord a => FFName a -> FFName a -> Bool
< :: FFName a -> FFName a -> Bool
$c< :: forall a. Ord a => FFName a -> FFName a -> Bool
compare :: FFName a -> FFName a -> Ordering
$ccompare :: forall a. Ord a => FFName a -> FFName a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (FFName a)
Ord)
-- | Parsed Haskell name ending with MName.  Good contructor to use.
data PMName a = PMName [MName a] (MName a) deriving (Int -> PMName a -> ShowS
[PMName a] -> ShowS
PMName a -> String
(Int -> PMName a -> ShowS)
-> (PMName a -> String) -> ([PMName a] -> ShowS) -> Show (PMName a)
forall a. Show a => Int -> PMName a -> ShowS
forall a. Show a => [PMName a] -> ShowS
forall a. Show a => PMName a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PMName a] -> ShowS
$cshowList :: forall a. Show a => [PMName a] -> ShowS
show :: PMName a -> String
$cshow :: forall a. Show a => PMName a -> String
showsPrec :: Int -> PMName a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> PMName a -> ShowS
Show,Typeable (PMName a)
DataType
Constr
Typeable (PMName a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> PMName a -> c (PMName a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (PMName a))
-> (PMName a -> Constr)
-> (PMName a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (PMName a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (PMName a)))
-> ((forall b. Data b => b -> b) -> PMName a -> PMName a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PMName a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PMName a -> r)
-> (forall u. (forall d. Data d => d -> u) -> PMName a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> PMName a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PMName a -> m (PMName a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PMName a -> m (PMName a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PMName a -> m (PMName a))
-> Data (PMName a)
PMName a -> DataType
PMName a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (PMName a))
(forall b. Data b => b -> b) -> PMName a -> PMName a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PMName a -> c (PMName a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PMName a)
forall a. Data a => Typeable (PMName a)
forall a. Data a => PMName a -> DataType
forall a. Data a => PMName a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> PMName a -> PMName a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> PMName a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> PMName a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PMName a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PMName a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> PMName a -> m (PMName a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> PMName a -> m (PMName a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PMName a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PMName a -> c (PMName a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (PMName a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (PMName a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> PMName a -> u
forall u. (forall d. Data d => d -> u) -> PMName a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PMName a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PMName a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PMName a -> m (PMName a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PMName a -> m (PMName a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PMName a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PMName a -> c (PMName a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (PMName a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (PMName a))
$cPMName :: Constr
$tPMName :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> PMName a -> m (PMName a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> PMName a -> m (PMName a)
gmapMp :: (forall d. Data d => d -> m d) -> PMName a -> m (PMName a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> PMName a -> m (PMName a)
gmapM :: (forall d. Data d => d -> m d) -> PMName a -> m (PMName a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> PMName a -> m (PMName a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> PMName a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> PMName a -> u
gmapQ :: (forall d. Data d => d -> u) -> PMName a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> PMName a -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PMName a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PMName a -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PMName a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PMName a -> r
gmapT :: (forall b. Data b => b -> b) -> PMName a -> PMName a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> PMName a -> PMName a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (PMName a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (PMName a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (PMName a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (PMName a))
dataTypeOf :: PMName a -> DataType
$cdataTypeOf :: forall a. Data a => PMName a -> DataType
toConstr :: PMName a -> Constr
$ctoConstr :: forall a. Data a => PMName a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PMName a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PMName a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PMName a -> c (PMName a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PMName a -> c (PMName a)
$cp1Data :: forall a. Data a => Typeable (PMName a)
Data,Typeable,ReadPrec [PMName a]
ReadPrec (PMName a)
Int -> ReadS (PMName a)
ReadS [PMName a]
(Int -> ReadS (PMName a))
-> ReadS [PMName a]
-> ReadPrec (PMName a)
-> ReadPrec [PMName a]
-> Read (PMName a)
forall a. Read a => ReadPrec [PMName a]
forall a. Read a => ReadPrec (PMName a)
forall a. Read a => Int -> ReadS (PMName a)
forall a. Read a => ReadS [PMName a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [PMName a]
$creadListPrec :: forall a. Read a => ReadPrec [PMName a]
readPrec :: ReadPrec (PMName a)
$creadPrec :: forall a. Read a => ReadPrec (PMName a)
readList :: ReadS [PMName a]
$creadList :: forall a. Read a => ReadS [PMName a]
readsPrec :: Int -> ReadS (PMName a)
$creadsPrec :: forall a. Read a => Int -> ReadS (PMName a)
Read,PMName a -> PMName a -> Bool
(PMName a -> PMName a -> Bool)
-> (PMName a -> PMName a -> Bool) -> Eq (PMName a)
forall a. Eq a => PMName a -> PMName a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PMName a -> PMName a -> Bool
$c/= :: forall a. Eq a => PMName a -> PMName a -> Bool
== :: PMName a -> PMName a -> Bool
$c== :: forall a. Eq a => PMName a -> PMName a -> Bool
Eq,Eq (PMName a)
Eq (PMName a)
-> (PMName a -> PMName a -> Ordering)
-> (PMName a -> PMName a -> Bool)
-> (PMName a -> PMName a -> Bool)
-> (PMName a -> PMName a -> Bool)
-> (PMName a -> PMName a -> Bool)
-> (PMName a -> PMName a -> PMName a)
-> (PMName a -> PMName a -> PMName a)
-> Ord (PMName a)
PMName a -> PMName a -> Bool
PMName a -> PMName a -> Ordering
PMName a -> PMName a -> PMName a
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (PMName a)
forall a. Ord a => PMName a -> PMName a -> Bool
forall a. Ord a => PMName a -> PMName a -> Ordering
forall a. Ord a => PMName a -> PMName a -> PMName a
min :: PMName a -> PMName a -> PMName a
$cmin :: forall a. Ord a => PMName a -> PMName a -> PMName a
max :: PMName a -> PMName a -> PMName a
$cmax :: forall a. Ord a => PMName a -> PMName a -> PMName a
>= :: PMName a -> PMName a -> Bool
$c>= :: forall a. Ord a => PMName a -> PMName a -> Bool
> :: PMName a -> PMName a -> Bool
$c> :: forall a. Ord a => PMName a -> PMName a -> Bool
<= :: PMName a -> PMName a -> Bool
$c<= :: forall a. Ord a => PMName a -> PMName a -> Bool
< :: PMName a -> PMName a -> Bool
$c< :: forall a. Ord a => PMName a -> PMName a -> Bool
compare :: PMName a -> PMName a -> Ordering
$ccompare :: forall a. Ord a => PMName a -> PMName a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (PMName a)
Ord)
-- | Parsed Haskell name ending with FName.  Good constructor to use.
data PFName a = PFName [MName a] (FName a) deriving (Int -> PFName a -> ShowS
[PFName a] -> ShowS
PFName a -> String
(Int -> PFName a -> ShowS)
-> (PFName a -> String) -> ([PFName a] -> ShowS) -> Show (PFName a)
forall a. Show a => Int -> PFName a -> ShowS
forall a. Show a => [PFName a] -> ShowS
forall a. Show a => PFName a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PFName a] -> ShowS
$cshowList :: forall a. Show a => [PFName a] -> ShowS
show :: PFName a -> String
$cshow :: forall a. Show a => PFName a -> String
showsPrec :: Int -> PFName a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> PFName a -> ShowS
Show,Typeable (PFName a)
DataType
Constr
Typeable (PFName a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> PFName a -> c (PFName a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (PFName a))
-> (PFName a -> Constr)
-> (PFName a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (PFName a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (PFName a)))
-> ((forall b. Data b => b -> b) -> PFName a -> PFName a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PFName a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PFName a -> r)
-> (forall u. (forall d. Data d => d -> u) -> PFName a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> PFName a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PFName a -> m (PFName a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PFName a -> m (PFName a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PFName a -> m (PFName a))
-> Data (PFName a)
PFName a -> DataType
PFName a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (PFName a))
(forall b. Data b => b -> b) -> PFName a -> PFName a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PFName a -> c (PFName a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PFName a)
forall a. Data a => Typeable (PFName a)
forall a. Data a => PFName a -> DataType
forall a. Data a => PFName a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> PFName a -> PFName a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> PFName a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> PFName a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PFName a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PFName a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> PFName a -> m (PFName a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> PFName a -> m (PFName a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PFName a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PFName a -> c (PFName a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (PFName a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (PFName a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> PFName a -> u
forall u. (forall d. Data d => d -> u) -> PFName a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PFName a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PFName a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PFName a -> m (PFName a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PFName a -> m (PFName a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PFName a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PFName a -> c (PFName a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (PFName a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (PFName a))
$cPFName :: Constr
$tPFName :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> PFName a -> m (PFName a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> PFName a -> m (PFName a)
gmapMp :: (forall d. Data d => d -> m d) -> PFName a -> m (PFName a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> PFName a -> m (PFName a)
gmapM :: (forall d. Data d => d -> m d) -> PFName a -> m (PFName a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> PFName a -> m (PFName a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> PFName a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> PFName a -> u
gmapQ :: (forall d. Data d => d -> u) -> PFName a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> PFName a -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PFName a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PFName a -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PFName a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PFName a -> r
gmapT :: (forall b. Data b => b -> b) -> PFName a -> PFName a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> PFName a -> PFName a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (PFName a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (PFName a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (PFName a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (PFName a))
dataTypeOf :: PFName a -> DataType
$cdataTypeOf :: forall a. Data a => PFName a -> DataType
toConstr :: PFName a -> Constr
$ctoConstr :: forall a. Data a => PFName a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PFName a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PFName a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PFName a -> c (PFName a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PFName a -> c (PFName a)
$cp1Data :: forall a. Data a => Typeable (PFName a)
Data,Typeable,ReadPrec [PFName a]
ReadPrec (PFName a)
Int -> ReadS (PFName a)
ReadS [PFName a]
(Int -> ReadS (PFName a))
-> ReadS [PFName a]
-> ReadPrec (PFName a)
-> ReadPrec [PFName a]
-> Read (PFName a)
forall a. Read a => ReadPrec [PFName a]
forall a. Read a => ReadPrec (PFName a)
forall a. Read a => Int -> ReadS (PFName a)
forall a. Read a => ReadS [PFName a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [PFName a]
$creadListPrec :: forall a. Read a => ReadPrec [PFName a]
readPrec :: ReadPrec (PFName a)
$creadPrec :: forall a. Read a => ReadPrec (PFName a)
readList :: ReadS [PFName a]
$creadList :: forall a. Read a => ReadS [PFName a]
readsPrec :: Int -> ReadS (PFName a)
$creadsPrec :: forall a. Read a => Int -> ReadS (PFName a)
Read,PFName a -> PFName a -> Bool
(PFName a -> PFName a -> Bool)
-> (PFName a -> PFName a -> Bool) -> Eq (PFName a)
forall a. Eq a => PFName a -> PFName a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PFName a -> PFName a -> Bool
$c/= :: forall a. Eq a => PFName a -> PFName a -> Bool
== :: PFName a -> PFName a -> Bool
$c== :: forall a. Eq a => PFName a -> PFName a -> Bool
Eq,Eq (PFName a)
Eq (PFName a)
-> (PFName a -> PFName a -> Ordering)
-> (PFName a -> PFName a -> Bool)
-> (PFName a -> PFName a -> Bool)
-> (PFName a -> PFName a -> Bool)
-> (PFName a -> PFName a -> Bool)
-> (PFName a -> PFName a -> PFName a)
-> (PFName a -> PFName a -> PFName a)
-> Ord (PFName a)
PFName a -> PFName a -> Bool
PFName a -> PFName a -> Ordering
PFName a -> PFName a -> PFName a
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (PFName a)
forall a. Ord a => PFName a -> PFName a -> Bool
forall a. Ord a => PFName a -> PFName a -> Ordering
forall a. Ord a => PFName a -> PFName a -> PFName a
min :: PFName a -> PFName a -> PFName a
$cmin :: forall a. Ord a => PFName a -> PFName a -> PFName a
max :: PFName a -> PFName a -> PFName a
$cmax :: forall a. Ord a => PFName a -> PFName a -> PFName a
>= :: PFName a -> PFName a -> Bool
$c>= :: forall a. Ord a => PFName a -> PFName a -> Bool
> :: PFName a -> PFName a -> Bool
$c> :: forall a. Ord a => PFName a -> PFName a -> Bool
<= :: PFName a -> PFName a -> Bool
$c<= :: forall a. Ord a => PFName a -> PFName a -> Bool
< :: PFName a -> PFName a -> Bool
$c< :: forall a. Ord a => PFName a -> PFName a -> Bool
compare :: PFName a -> PFName a -> Ordering
$ccompare :: forall a. Ord a => PFName a -> PFName a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (PFName a)
Ord)

app_prec,max_prec :: Int
app_prec :: Int
app_prec = Int
10
max_prec :: Int
max_prec = Int
11

{-# INLINE readIt #-}
readIt :: (Read a) => (a -> a1) -> String -> Int -> String -> [(a1, String)]
readIt :: (a -> a1) -> String -> Int -> String -> [(a1, String)]
readIt a -> a1
con String
name Int
d  = Bool -> (String -> [(a1, String)]) -> String -> [(a1, String)]
forall a. Bool -> ReadS a -> ReadS a
readParen (Int
d Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
app_prec) (\String
r -> [(a -> a1
con a
m,String
t) | (String
name',String
s) <- ReadS String
lex String
r, String
nameString -> String -> Bool
forall a. Eq a => a -> a -> Bool
==String
name', (a
m,String
t) <- Int -> ReadS a
forall a. Read a => Int -> ReadS a
readsPrec Int
max_prec String
s])

{-# INLINE showIt #-}
showIt :: (Show a) => Int -> [Char] -> a -> String -> String
showIt :: Int -> String -> a -> ShowS
showIt Int
d String
name a
a = Bool -> ShowS -> ShowS
showParen (Int
d Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
app_prec) (ShowS -> ShowS) -> ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$ (String
nameString -> ShowS
forall a. [a] -> [a] -> [a]
++) ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char
' 'Char -> ShowS
forall a. a -> [a] -> [a]
:) ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> a -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec Int
max_prec a
a

instance Read a => Read (IName a) where readsPrec :: Int -> ReadS (IName a)
readsPrec = (a -> IName a) -> String -> Int -> ReadS (IName a)
forall a a1.
Read a =>
(a -> a1) -> String -> Int -> String -> [(a1, String)]
readIt a -> IName a
forall a. a -> IName a
IName String
"IName"
instance Read a => Read (MName a) where readsPrec :: Int -> ReadS (MName a)
readsPrec = (a -> MName a) -> String -> Int -> ReadS (MName a)
forall a a1.
Read a =>
(a -> a1) -> String -> Int -> String -> [(a1, String)]
readIt a -> MName a
forall a. a -> MName a
MName String
"MName"
instance Read a => Read (FName a) where readsPrec :: Int -> ReadS (FName a)
readsPrec = (a -> FName a) -> String -> Int -> ReadS (FName a)
forall a a1.
Read a =>
(a -> a1) -> String -> Int -> String -> [(a1, String)]
readIt a -> FName a
forall a. a -> FName a
FName String
"FName"
instance Read a => Read (DIName a) where readsPrec :: Int -> ReadS (DIName a)
readsPrec = (a -> DIName a) -> String -> Int -> ReadS (DIName a)
forall a a1.
Read a =>
(a -> a1) -> String -> Int -> String -> [(a1, String)]
readIt a -> DIName a
forall a. a -> DIName a
DIName String
"DIName"
instance Read a => Read (FIName a) where readsPrec :: Int -> ReadS (FIName a)
readsPrec = (a -> FIName a) -> String -> Int -> ReadS (FIName a)
forall a a1.
Read a =>
(a -> a1) -> String -> Int -> String -> [(a1, String)]
readIt a -> FIName a
forall a. a -> FIName a
FIName String
"FIName"
instance Read a => Read (FFName a) where readsPrec :: Int -> ReadS (FFName a)
readsPrec = (a -> FFName a) -> String -> Int -> ReadS (FFName a)
forall a a1.
Read a =>
(a -> a1) -> String -> Int -> String -> [(a1, String)]
readIt a -> FFName a
forall a. a -> FFName a
FFName String
"FFName"
instance Read a => Read (FMName a) where readsPrec :: Int -> ReadS (FMName a)
readsPrec = (a -> FMName a) -> String -> Int -> ReadS (FMName a)
forall a a1.
Read a =>
(a -> a1) -> String -> Int -> String -> [(a1, String)]
readIt a -> FMName a
forall a. a -> FMName a
FMName String
"FMName"

instance Show a => Show (IName a) where showsPrec :: Int -> IName a -> ShowS
showsPrec Int
d (IName a
a) = Int -> String -> a -> ShowS
forall a. Show a => Int -> String -> a -> ShowS
showIt Int
d String
"IName" a
a
instance Show a => Show (MName a) where showsPrec :: Int -> MName a -> ShowS
showsPrec Int
d (MName a
a) = Int -> String -> a -> ShowS
forall a. Show a => Int -> String -> a -> ShowS
showIt Int
d String
"MName" a
a
instance Show a => Show (FName a) where showsPrec :: Int -> FName a -> ShowS
showsPrec Int
d (FName a
a) = Int -> String -> a -> ShowS
forall a. Show a => Int -> String -> a -> ShowS
showIt Int
d String
"FName" a
a
instance Show a => Show (DIName a) where showsPrec :: Int -> DIName a -> ShowS
showsPrec Int
d (DIName a
a) = Int -> String -> a -> ShowS
forall a. Show a => Int -> String -> a -> ShowS
showIt Int
d String
"DIName" a
a
instance Show a => Show (FIName a) where showsPrec :: Int -> FIName a -> ShowS
showsPrec Int
d (FIName a
a) = Int -> String -> a -> ShowS
forall a. Show a => Int -> String -> a -> ShowS
showIt Int
d String
"FIName" a
a
instance Show a => Show (FMName a) where showsPrec :: Int -> FMName a -> ShowS
showsPrec Int
d (FMName a
a) = Int -> String -> a -> ShowS
forall a. Show a => Int -> String -> a -> ShowS
showIt Int
d String
"FMName" a
a
instance Show a => Show (FFName a) where showsPrec :: Int -> FFName a -> ShowS
showsPrec Int
d (FFName a
a) = Int -> String -> a -> ShowS
forall a. Show a => Int -> String -> a -> ShowS
showIt Int
d String
"FFName" a
a

-- | This is used to abstract over Utf8 and String.  The important
-- entry point is 'validDI'.
class (Monoid a) => Dotted a where
  uncons :: a -> Maybe (Char,a)
  cons :: Char -> a -> a
  dot :: a -> a -> a
  validI :: a -> Maybe (IName a)
  -- | 'validDI' ensures the DIName is
  validDI :: a -> Maybe (DIName a)
  -- | 'split' returns a list of non-empty 'a' with all '.' characters removed
  split :: a -> [a]

-- These are also part of the external API, they are abstracted over
-- Dotted.

joinPM :: Dotted a => PMName a -> FMName a
joinPM :: PMName a -> FMName a
joinPM (PMName [MName a]
xs (MName a
x)) = a -> FMName a
forall a. a -> FMName a
FMName ((a -> a -> a) -> a -> [a] -> a
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr a -> a -> a
forall a. Dotted a => a -> a -> a
dot a
x ([a] -> a) -> ([MName a] -> [a]) -> [MName a] -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (MName a -> a) -> [MName a] -> [a]
forall a b. (a -> b) -> [a] -> [b]
map MName a -> a
forall a. MName a -> a
mName ([MName a] -> a) -> [MName a] -> a
forall a b. (a -> b) -> a -> b
$ [MName a]
xs)

joinPF :: Dotted a => PFName a -> FFName a
joinPF :: PFName a -> FFName a
joinPF (PFName [MName a]
xs (FName a
x)) = a -> FFName a
forall a. a -> FFName a
FFName ((a -> a -> a) -> a -> [a] -> a
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr a -> a -> a
forall a. Dotted a => a -> a -> a
dot a
x ([a] -> a) -> ([MName a] -> [a]) -> [MName a] -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (MName a -> a) -> [MName a] -> [a]
forall a b. (a -> b) -> [a] -> [b]
map MName a -> a
forall a. MName a -> a
mName ([MName a] -> a) -> [MName a] -> a
forall a b. (a -> b) -> a -> b
$ [MName a]
xs)

-- | 'difi' examines the 'DIName' and prepend a '.' if absent, promoting
-- it to a 'FIName'.
difi :: Dotted a => DIName a -> FIName a
difi :: DIName a -> FIName a
difi (DIName a
a) = case a -> Maybe (Char, a)
forall a. Dotted a => a -> Maybe (Char, a)
uncons a
a of
                    Just (Char
'.',a
_) -> a -> FIName a
forall a. a -> FIName a
FIName a
a
                    Maybe (Char, a)
_ -> a -> FIName a
forall a. a -> FIName a
FIName (Char -> a -> a
forall a. Dotted a => Char -> a -> a
cons Char
'.' a
a)

-- | Typed 'split'
splitDI :: Dotted a => DIName a -> [IName a]
splitDI :: DIName a -> [IName a]
splitDI = (a -> IName a) -> [a] -> [IName a]
forall a b. (a -> b) -> [a] -> [b]
map a -> IName a
forall a. a -> IName a
IName ([a] -> [IName a]) -> (DIName a -> [a]) -> DIName a -> [IName a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> [a]
forall a. Dotted a => a -> [a]
split (a -> [a]) -> (DIName a -> a) -> DIName a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DIName a -> a
forall a. DIName a -> a
diName

-- | Typed 'split'
splitFI :: Dotted a => FIName a -> [IName a]
splitFI :: FIName a -> [IName a]
splitFI = (a -> IName a) -> [a] -> [IName a]
forall a b. (a -> b) -> [a] -> [b]
map a -> IName a
forall a. a -> IName a
IName ([a] -> [IName a]) -> (FIName a -> [a]) -> FIName a -> [IName a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> [a]
forall a. Dotted a => a -> [a]
split (a -> [a]) -> (FIName a -> a) -> FIName a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FIName a -> a
forall a. FIName a -> a
fiName

-- | Typed 'split'
splitFM :: Dotted a => FMName a -> [MName a]
splitFM :: FMName a -> [MName a]
splitFM = (a -> MName a) -> [a] -> [MName a]
forall a b. (a -> b) -> [a] -> [b]
map a -> MName a
forall a. a -> MName a
MName ([a] -> [MName a]) -> (FMName a -> [a]) -> FMName a -> [MName a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> [a]
forall a. Dotted a => a -> [a]
split (a -> [a]) -> (FMName a -> a) -> FMName a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FMName a -> a
forall a. FMName a -> a
fmName

promoteDI :: Dotted a => IName a -> DIName a
promoteDI :: IName a -> DIName a
promoteDI = a -> DIName a
forall a. a -> DIName a
DIName (a -> DIName a) -> (IName a -> a) -> IName a -> DIName a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IName a -> a
forall a. IName a -> a
iName

promoteFI :: Dotted a => IName a -> FIName a
promoteFI :: IName a -> FIName a
promoteFI = a -> FIName a
forall a. a -> FIName a
FIName (a -> FIName a) -> (IName a -> a) -> IName a -> FIName a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> a -> a
forall a. Dotted a => Char -> a -> a
cons Char
'.' (a -> a) -> (IName a -> a) -> IName a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IName a -> a
forall a. IName a -> a
iName

promoteFM :: Dotted a => MName a -> FMName a
promoteFM :: MName a -> FMName a
promoteFM = a -> FMName a
forall a. a -> FMName a
FMName (a -> FMName a) -> (MName a -> a) -> MName a -> FMName a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MName a -> a
forall a. MName a -> a
mName

promoteFF :: Dotted a => FName a -> FFName a
promoteFF :: FName a -> FFName a
promoteFF = a -> FFName a
forall a. a -> FFName a
FFName (a -> FFName a) -> (FName a -> a) -> FName a -> FFName a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FName a -> a
forall a. FName a -> a
fName

dotFM :: Dotted a => FMName a -> FMName a -> FMName a
dotFM :: FMName a -> FMName a -> FMName a
dotFM (FMName a
a) (FMName a
b) = a -> FMName a
forall a. a -> FMName a
FMName (a
a a -> a -> a
forall a. Dotted a => a -> a -> a
`dot` a
b)

dotFF :: Dotted a => FMName a -> FFName a -> FFName a
dotFF :: FMName a -> FFName a -> FFName a
dotFF (FMName a
a) (FFName a
b) = a -> FFName a
forall a. a -> FFName a
FFName (a
a a -> a -> a
forall a. Dotted a => a -> a -> a
`dot` a
b)

fqAppend :: Dotted a => FIName a -> [IName a] -> FIName a
fqAppend :: FIName a -> [IName a] -> FIName a
fqAppend (FIName a
base) [IName a]
xs = a -> FIName a
forall a. a -> FIName a
FIName ((a -> a -> a) -> a -> [a] -> a
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' a -> a -> a
forall a. Dotted a => a -> a -> a
dot a
base ([a] -> a) -> ([IName a] -> [a]) -> [IName a] -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (IName a -> a) -> [IName a] -> [a]
forall a b. (a -> b) -> [a] -> [b]
map IName a -> a
forall a. IName a -> a
iName ([IName a] -> a) -> [IName a] -> a
forall a b. (a -> b) -> a -> b
$ [IName a]
xs)

-- The two checkDI* functions give better error messages than validDI

-- | Right (True,_) means the input is a FIName.
-- Right (False,_) means the input is a DIName (without leading '.')
--
-- This creates useful error messages for the user.
checkDIString :: String -> Either String (Bool,[IName String])
checkDIString :: String -> Either String (Bool, [IName String])
checkDIString String
"" = String -> Either String (Bool, [IName String])
forall a b. a -> Either a b
Left (String -> Either String (Bool, [IName String]))
-> String -> Either String (Bool, [IName String])
forall a b. (a -> b) -> a -> b
$ String
"Invalid empty identifier: "String -> ShowS
forall a. [a] -> [a] -> [a]
++ShowS
forall a. Show a => a -> String
show String
""
checkDIString String
"." = String -> Either String (Bool, [IName String])
forall a b. a -> Either a b
Left (String -> Either String (Bool, [IName String]))
-> String -> Either String (Bool, [IName String])
forall a b. (a -> b) -> a -> b
$ String
"Invalid identifier of just a period: "String -> ShowS
forall a. [a] -> [a] -> [a]
++ShowS
forall a. Show a => a -> String
show String
"."
checkDIString String
xs | (Char
'.':String
ys) <- String
xs = ([IName String] -> (Bool, [IName String]))
-> Either String [IName String]
-> Either String (Bool, [IName String])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((,) Bool
True) (Either String [IName String]
 -> Either String (Bool, [IName String]))
-> Either String [IName String]
-> Either String (Bool, [IName String])
forall a b. (a -> b) -> a -> b
$ ([IName String] -> [IName String])
-> (String, String) -> Either String [IName String]
parts [IName String] -> [IName String]
forall a. a -> a
id ((Char -> Bool) -> String -> (String, String)
forall a. (a -> Bool) -> [a] -> ([a], [a])
span (Char
'.'Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/=) String
ys)
                 | Bool
otherwise = ([IName String] -> (Bool, [IName String]))
-> Either String [IName String]
-> Either String (Bool, [IName String])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((,) Bool
False) (Either String [IName String]
 -> Either String (Bool, [IName String]))
-> Either String [IName String]
-> Either String (Bool, [IName String])
forall a b. (a -> b) -> a -> b
$ ([IName String] -> [IName String])
-> (String, String) -> Either String [IName String]
parts [IName String] -> [IName String]
forall a. a -> a
id ((Char -> Bool) -> String -> (String, String)
forall a. (a -> Bool) -> [a] -> ([a], [a])
span (Char
'.'Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/=) String
xs)
 where parts :: ([IName String] -> [IName String])
-> (String, String) -> Either String [IName String]
parts [IName String] -> [IName String]
_f (String
"",String
"") = String -> Either String [IName String]
forall a b. a -> Either a b
Left (String -> Either String [IName String])
-> String -> Either String [IName String]
forall a b. (a -> b) -> a -> b
$ String
"Invalid identifier because it ends with a period: "String -> ShowS
forall a. [a] -> [a] -> [a]
++ShowS
forall a. Show a => a -> String
show String
xs
       parts [IName String] -> [IName String]
_f (String
"",String
_)  = String -> Either String [IName String]
forall a b. a -> Either a b
Left (String -> Either String [IName String])
-> String -> Either String [IName String]
forall a b. (a -> b) -> a -> b
$ String
"Invalid identifier because is contains two periods in a row: "String -> ShowS
forall a. [a] -> [a] -> [a]
++ShowS
forall a. Show a => a -> String
show String
xs
       parts [IName String] -> [IName String]
f  (String
a,String
"")  = [IName String] -> Either String [IName String]
forall a b. b -> Either a b
Right ([IName String] -> [IName String]
f [String -> IName String
forall a. a -> IName a
IName String
a])
       parts [IName String] -> [IName String]
f  (String
a,String
b)   = ([IName String] -> [IName String])
-> (String, String) -> Either String [IName String]
parts ([IName String] -> [IName String]
f ([IName String] -> [IName String])
-> ([IName String] -> [IName String])
-> [IName String]
-> [IName String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String -> IName String
forall a. a -> IName a
IName String
aIName String -> [IName String] -> [IName String]
forall a. a -> [a] -> [a]
:)) ((Char -> Bool) -> String -> (String, String)
forall a. (a -> Bool) -> [a] -> ([a], [a])
span (Char
'.'Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/=) (ShowS
forall a. [a] -> [a]
tail String
b))

-- | Right (True,_) means the input is a FIName.
-- Right (False,_) means the input is a DIName (without leading '.')
--
-- This creates useful error messages for the user.
checkDIUtf8 :: Utf8 -> Either String (Bool,[IName Utf8])
checkDIUtf8 :: Utf8 -> Either String (Bool, [IName Utf8])
checkDIUtf8 s :: Utf8
s@(Utf8 ByteString
xs) =
  case ByteString -> Maybe (Char, ByteString)
U.uncons ByteString
xs of
    Maybe (Char, ByteString)
Nothing -> String -> Either String (Bool, [IName Utf8])
forall a b. a -> Either a b
Left (String -> Either String (Bool, [IName Utf8]))
-> String -> Either String (Bool, [IName Utf8])
forall a b. (a -> b) -> a -> b
$ String
"Invalid empty identifier: "String -> ShowS
forall a. [a] -> [a] -> [a]
++ShowS
forall a. Show a => a -> String
show String
""
    Just (Char
'.',ByteString
ys) | ByteString -> Bool
LC.null ByteString
ys -> String -> Either String (Bool, [IName Utf8])
forall a b. a -> Either a b
Left (String -> Either String (Bool, [IName Utf8]))
-> String -> Either String (Bool, [IName Utf8])
forall a b. (a -> b) -> a -> b
$ String
"Invalid identifier of just a period: "String -> ShowS
forall a. [a] -> [a] -> [a]
++ShowS
forall a. Show a => a -> String
show String
"."
                  | Bool
otherwise -> ([IName Utf8] -> (Bool, [IName Utf8]))
-> Either String [IName Utf8] -> Either String (Bool, [IName Utf8])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((,) Bool
True) (Either String [IName Utf8] -> Either String (Bool, [IName Utf8]))
-> Either String [IName Utf8] -> Either String (Bool, [IName Utf8])
forall a b. (a -> b) -> a -> b
$ ([IName Utf8] -> [IName Utf8])
-> (ByteString, ByteString) -> Either String [IName Utf8]
parts [IName Utf8] -> [IName Utf8]
forall a. a -> a
id ((Char -> Bool) -> ByteString -> (ByteString, ByteString)
U.span (Char
'.'Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/=) ByteString
ys)
    Just (Char, ByteString)
_ -> ([IName Utf8] -> (Bool, [IName Utf8]))
-> Either String [IName Utf8] -> Either String (Bool, [IName Utf8])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((,) Bool
False) (Either String [IName Utf8] -> Either String (Bool, [IName Utf8]))
-> Either String [IName Utf8] -> Either String (Bool, [IName Utf8])
forall a b. (a -> b) -> a -> b
$ ([IName Utf8] -> [IName Utf8])
-> (ByteString, ByteString) -> Either String [IName Utf8]
parts [IName Utf8] -> [IName Utf8]
forall a. a -> a
id ((Char -> Bool) -> ByteString -> (ByteString, ByteString)
U.span (Char
'.'Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/=) ByteString
xs)
 where parts :: ([IName Utf8] -> [IName Utf8])
-> (ByteString, ByteString) -> Either String [IName Utf8]
parts [IName Utf8] -> [IName Utf8]
f (ByteString
a,ByteString
b) = case (ByteString -> Bool
LC.null ByteString
a,ByteString -> Bool
LC.null ByteString
b) of
                         (Bool
True,Bool
True) -> String -> Either String [IName Utf8]
forall a b. a -> Either a b
Left (String -> Either String [IName Utf8])
-> String -> Either String [IName Utf8]
forall a b. (a -> b) -> a -> b
$ String
"Invalid identifier because it ends with a period: "String -> ShowS
forall a. [a] -> [a] -> [a]
++ShowS
forall a. Show a => a -> String
show (Utf8 -> String
toString Utf8
s)
                         (Bool
True,Bool
_)    -> String -> Either String [IName Utf8]
forall a b. a -> Either a b
Left (String -> Either String [IName Utf8])
-> String -> Either String [IName Utf8]
forall a b. (a -> b) -> a -> b
$ String
"Invalid identifier because is contains two periods in a row: "String -> ShowS
forall a. [a] -> [a] -> [a]
++ShowS
forall a. Show a => a -> String
show (Utf8 -> String
toString Utf8
s)
                         (Bool
_,Bool
True)    -> [IName Utf8] -> Either String [IName Utf8]
forall a b. b -> Either a b
Right ([IName Utf8] -> [IName Utf8]
f [Utf8 -> IName Utf8
forall a. a -> IName a
IName (ByteString -> Utf8
Utf8 ByteString
a)])
                         (Bool, Bool)
_           -> ([IName Utf8] -> [IName Utf8])
-> (ByteString, ByteString) -> Either String [IName Utf8]
parts ([IName Utf8] -> [IName Utf8]
f ([IName Utf8] -> [IName Utf8])
-> ([IName Utf8] -> [IName Utf8]) -> [IName Utf8] -> [IName Utf8]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Utf8 -> IName Utf8
forall a. a -> IName a
IName (ByteString -> Utf8
Utf8 ByteString
a)IName Utf8 -> [IName Utf8] -> [IName Utf8]
forall a. a -> [a] -> [a]
:)) ((Char -> Bool) -> ByteString -> (ByteString, ByteString)
U.span (Char
'.'Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/=) (Int64 -> ByteString -> ByteString
U.drop Int64
1 ByteString
b))

-- | The 'mangle' transformation has instances for several combiantions
-- of input and output.  These allow one to construct the Haskell types
-- of MName/FMName/PMName and FName/FFName/PFName out of the protobuf
-- types IName/DIName/FIName.  Currently, all the Haskell instances
-- are for the String base type.

class Mangle a b where mangle :: a -> b

instance Mangle (IName String) (MName String) where
  mangle :: IName String -> MName String
mangle (IName String
s) = String -> MName String
forall a. a -> MName a
MName (ShowS
fixUp String
s)

instance Mangle (IName Utf8) (MName String) where
  mangle :: IName Utf8 -> MName String
mangle (IName Utf8
s) = String -> MName String
forall a. a -> MName a
MName (ShowS
fixUp ShowS -> (Utf8 -> String) -> Utf8 -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Utf8 -> String
toString (Utf8 -> String) -> Utf8 -> String
forall a b. (a -> b) -> a -> b
$ Utf8
s)

instance Mangle (FName String) (MName String) where
  mangle :: FName String -> MName String
mangle (FName String
s) = String -> MName String
forall a. a -> MName a
MName (ShowS
fixUp String
s)

instance Mangle (IName String) (FName String) where
  mangle :: IName String -> FName String
mangle (IName String
s) = String -> FName String
forall a. a -> FName a
FName (ShowS
fixLow String
s)

instance Mangle (IName Utf8) (FName String) where
  mangle :: IName Utf8 -> FName String
mangle (IName Utf8
s) = String -> FName String
forall a. a -> FName a
FName (ShowS
fixLow ShowS -> (Utf8 -> String) -> Utf8 -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Utf8 -> String
toString (Utf8 -> String) -> Utf8 -> String
forall a b. (a -> b) -> a -> b
$ Utf8
s)

instance Mangle (MName String) (FName String) where
  mangle :: MName String -> FName String
mangle (MName String
s) = String -> FName String
forall a. a -> FName a
FName (ShowS
fixLow String
s)

instance Mangle (DIName Utf8) (PMName String) where
  mangle :: DIName Utf8 -> PMName String
mangle DIName Utf8
s = let ms :: [IName Utf8]
ms = DIName Utf8 -> [IName Utf8]
forall a. Dotted a => DIName a -> [IName a]
splitDI DIName Utf8
s in [MName String] -> MName String -> PMName String
forall a. [MName a] -> MName a -> PMName a
PMName ((IName Utf8 -> MName String) -> [IName Utf8] -> [MName String]
forall a b. (a -> b) -> [a] -> [b]
map IName Utf8 -> MName String
forall a b. Mangle a b => a -> b
mangle ([IName Utf8] -> [MName String]) -> [IName Utf8] -> [MName String]
forall a b. (a -> b) -> a -> b
$ [IName Utf8] -> [IName Utf8]
forall a. [a] -> [a]
init [IName Utf8]
ms) (IName Utf8 -> MName String
forall a b. Mangle a b => a -> b
mangle (IName Utf8 -> MName String) -> IName Utf8 -> MName String
forall a b. (a -> b) -> a -> b
$ [IName Utf8] -> IName Utf8
forall a. [a] -> a
last [IName Utf8]
ms)

instance Mangle (FIName Utf8) (PMName String) where
  mangle :: FIName Utf8 -> PMName String
mangle FIName Utf8
s = let ms :: [IName Utf8]
ms = FIName Utf8 -> [IName Utf8]
forall a. Dotted a => FIName a -> [IName a]
splitFI FIName Utf8
s in [MName String] -> MName String -> PMName String
forall a. [MName a] -> MName a -> PMName a
PMName ((IName Utf8 -> MName String) -> [IName Utf8] -> [MName String]
forall a b. (a -> b) -> [a] -> [b]
map IName Utf8 -> MName String
forall a b. Mangle a b => a -> b
mangle ([IName Utf8] -> [MName String]) -> [IName Utf8] -> [MName String]
forall a b. (a -> b) -> a -> b
$ [IName Utf8] -> [IName Utf8]
forall a. [a] -> [a]
init [IName Utf8]
ms) (IName Utf8 -> MName String
forall a b. Mangle a b => a -> b
mangle (IName Utf8 -> MName String) -> IName Utf8 -> MName String
forall a b. (a -> b) -> a -> b
$ [IName Utf8] -> IName Utf8
forall a. [a] -> a
last [IName Utf8]
ms)

instance Mangle (DIName Utf8) (PFName String) where
  mangle :: DIName Utf8 -> PFName String
mangle DIName Utf8
s = let ms :: [IName Utf8]
ms = DIName Utf8 -> [IName Utf8]
forall a. Dotted a => DIName a -> [IName a]
splitDI DIName Utf8
s in [MName String] -> FName String -> PFName String
forall a. [MName a] -> FName a -> PFName a
PFName ((IName Utf8 -> MName String) -> [IName Utf8] -> [MName String]
forall a b. (a -> b) -> [a] -> [b]
map IName Utf8 -> MName String
forall a b. Mangle a b => a -> b
mangle ([IName Utf8] -> [MName String]) -> [IName Utf8] -> [MName String]
forall a b. (a -> b) -> a -> b
$ [IName Utf8] -> [IName Utf8]
forall a. [a] -> [a]
init [IName Utf8]
ms) (IName Utf8 -> FName String
forall a b. Mangle a b => a -> b
mangle (IName Utf8 -> FName String) -> IName Utf8 -> FName String
forall a b. (a -> b) -> a -> b
$ [IName Utf8] -> IName Utf8
forall a. [a] -> a
last [IName Utf8]
ms)

instance Mangle (FIName Utf8) (PFName String) where
  mangle :: FIName Utf8 -> PFName String
mangle FIName Utf8
s = let ms :: [IName Utf8]
ms =  FIName Utf8 -> [IName Utf8]
forall a. Dotted a => FIName a -> [IName a]
splitFI FIName Utf8
s in [MName String] -> FName String -> PFName String
forall a. [MName a] -> FName a -> PFName a
PFName ((IName Utf8 -> MName String) -> [IName Utf8] -> [MName String]
forall a b. (a -> b) -> [a] -> [b]
map IName Utf8 -> MName String
forall a b. Mangle a b => a -> b
mangle ([IName Utf8] -> [MName String]) -> [IName Utf8] -> [MName String]
forall a b. (a -> b) -> a -> b
$ [IName Utf8] -> [IName Utf8]
forall a. [a] -> [a]
init [IName Utf8]
ms) (IName Utf8 -> FName String
forall a b. Mangle a b => a -> b
mangle (IName Utf8 -> FName String) -> IName Utf8 -> FName String
forall a b. (a -> b) -> a -> b
$ [IName Utf8] -> IName Utf8
forall a. [a] -> a
last [IName Utf8]
ms)

-- implementation details follow

dotUtf8 :: Utf8 -> Utf8 -> Utf8
dotUtf8 :: Utf8 -> Utf8 -> Utf8
dotUtf8 (Utf8 ByteString
a) (Utf8 ByteString
b) = ByteString -> Utf8
Utf8 (ByteString -> ByteString -> ByteString
LC.append ByteString
a (Char -> ByteString -> ByteString
LC.cons Char
'.' ByteString
b))

dotString :: String -> String -> String
dotString :: String -> ShowS
dotString String
a String
b = String
a String -> ShowS
forall a. [a] -> [a] -> [a]
++ (Char
'.'Char -> ShowS
forall a. a -> [a] -> [a]
:String
b)

-- | Return list of nonempty Utf8, with all '.' removed
splitUtf8 :: Utf8 -> [Utf8]
splitUtf8 :: Utf8 -> [Utf8]
splitUtf8 = (ByteString -> Maybe (Utf8, ByteString)) -> ByteString -> [Utf8]
forall b a. (b -> Maybe (a, b)) -> b -> [a]
unfoldr ByteString -> Maybe (Utf8, ByteString)
s (ByteString -> [Utf8]) -> (Utf8 -> ByteString) -> Utf8 -> [Utf8]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Utf8 -> ByteString
utf8 where
  s :: ByteString -> Maybe (Utf8,ByteString)
  s :: ByteString -> Maybe (Utf8, ByteString)
s ByteString
y = case ByteString -> Maybe (Char, ByteString)
LC.uncons ByteString
y of
          Maybe (Char, ByteString)
Nothing -> Maybe (Utf8, ByteString)
forall a. Maybe a
Nothing
          Just (Char
'.',ByteString
xs) -> ByteString -> Maybe (Utf8, ByteString)
s ByteString
xs -- delete all '.' in the input
          Maybe (Char, ByteString)
_ -> (Utf8, ByteString) -> Maybe (Utf8, ByteString)
forall a. a -> Maybe a
Just (let (ByteString
a,ByteString
b) = (Char -> Bool) -> ByteString -> (ByteString, ByteString)
U.span (Char
'.'Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/=) ByteString
y in (ByteString -> Utf8
Utf8 ByteString
a,ByteString
b))

-- | Return list of nonempty String, with all '.' removed
splitString :: String -> [String]
splitString :: String -> [String]
splitString = (String -> Maybe (String, String)) -> String -> [String]
forall b a. (b -> Maybe (a, b)) -> b -> [a]
unfoldr String -> Maybe (String, String)
s where
  s :: String -> Maybe (String, String)
s [] = Maybe (String, String)
forall a. Maybe a
Nothing
  s (Char
'.':String
xs) = String -> Maybe (String, String)
s String
xs -- delete all '.' in the input
  s String
xs = (String, String) -> Maybe (String, String)
forall a. a -> Maybe a
Just ((Char -> Bool) -> String -> (String, String)
forall a. (a -> Bool) -> [a] -> ([a], [a])
span (Char
'.'Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/=) String
xs)

validIUtf8 :: Utf8 -> Maybe (IName Utf8)
validIUtf8 :: Utf8 -> Maybe (IName Utf8)
validIUtf8 Utf8
xs | Utf8 -> Bool
unull Utf8
xs = Maybe (IName Utf8)
forall a. Maybe a
Nothing
validIUtf8 xs :: Utf8
xs@(Utf8 ByteString
bs) = if (Char -> Bool) -> ByteString -> Bool
LC.all (Char -> Set Char -> Bool
forall a. Ord a => a -> Set a -> Bool
`S.member` Set Char
validISet) ByteString
bs
                            then IName Utf8 -> Maybe (IName Utf8)
forall a. a -> Maybe a
Just (Utf8 -> IName Utf8
forall a. a -> IName a
IName Utf8
xs)
                            else Maybe (IName Utf8)
forall a. Maybe a
Nothing

validIString :: String -> Maybe (IName String)
validIString :: String -> Maybe (IName String)
validIString [] = Maybe (IName String)
forall a. Maybe a
Nothing
validIString String
xs = if (Char -> Bool) -> String -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all (Char -> Set Char -> Bool
forall a. Ord a => a -> Set a -> Bool
`S.member` Set Char
validISet) String
xs
                    then IName String -> Maybe (IName String)
forall a. a -> Maybe a
Just (String -> IName String
forall a. a -> IName a
IName String
xs)
                    else Maybe (IName String)
forall a. Maybe a
Nothing

validDIUtf8 :: Utf8 -> Maybe (DIName Utf8)
validDIUtf8 :: Utf8 -> Maybe (DIName Utf8)
validDIUtf8 Utf8
xs | Utf8 -> Bool
unull Utf8
xs = Maybe (DIName Utf8)
forall a. Maybe a
Nothing
validDIUtf8 xs :: Utf8
xs@(Utf8 ByteString
bs) =
  if (Char -> Bool) -> ByteString -> Bool
LC.all (Char -> Set Char -> Bool
forall a. Ord a => a -> Set a -> Bool
`S.member` Set Char
validDISet) ByteString
bs Bool -> Bool -> Bool
&& (Char -> Bool) -> ByteString -> Bool
LC.any (Char
'.'Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/=) ByteString
bs Bool -> Bool -> Bool
&& ByteString -> Char
LC.last ByteString
bs Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= Char
'.'
     Bool -> Bool -> Bool
&& (((Char, Char) -> Bool) -> [(Char, Char)] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all (\(Char
x,Char
y) -> Char
'.'Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/=Char
x Bool -> Bool -> Bool
|| Char
'.'Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/=Char
y) ([(Char, Char)] -> Bool)
-> (Utf8 -> [(Char, Char)]) -> Utf8 -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\String
x -> String -> String -> [(Char, Char)]
forall a b. [a] -> [b] -> [(a, b)]
zip (ShowS
forall a. [a] -> [a]
init String
x) (ShowS
forall a. [a] -> [a]
tail String
x)) (String -> [(Char, Char)])
-> (Utf8 -> String) -> Utf8 -> [(Char, Char)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Utf8 -> String
toString (Utf8 -> Bool) -> Utf8 -> Bool
forall a b. (a -> b) -> a -> b
$ Utf8
xs)
    then DIName Utf8 -> Maybe (DIName Utf8)
forall a. a -> Maybe a
Just (Utf8 -> DIName Utf8
forall a. a -> DIName a
DIName Utf8
xs)
    else Maybe (DIName Utf8)
forall a. Maybe a
Nothing

validDIString :: String -> Maybe (DIName String)
validDIString :: String -> Maybe (DIName String)
validDIString []  = Maybe (DIName String)
forall a. Maybe a
Nothing
validDIString String
xs =
  if (Char -> Bool) -> String -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all (Char -> Set Char -> Bool
forall a. Ord a => a -> Set a -> Bool
`S.member` Set Char
validDISet) String
xs Bool -> Bool -> Bool
&& (Char -> Bool) -> String -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (Char
'.'Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/=) String
xs Bool -> Bool -> Bool
&& String -> Char
forall a. [a] -> a
last String
xs Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= Char
'.'
     Bool -> Bool -> Bool
&& ((Char, Char) -> Bool) -> [(Char, Char)] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all (\(Char
x,Char
y) -> Char
'.'Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/=Char
x Bool -> Bool -> Bool
|| Char
'.'Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/=Char
y) (String -> String -> [(Char, Char)]
forall a b. [a] -> [b] -> [(a, b)]
zip (ShowS
forall a. [a] -> [a]
init String
xs) (ShowS
forall a. [a] -> [a]
tail String
xs))
    then DIName String -> Maybe (DIName String)
forall a. a -> Maybe a
Just (String -> DIName String
forall a. a -> DIName a
DIName String
xs)
    else Maybe (DIName String)
forall a. Maybe a
Nothing

validISet :: Set Char
validISet :: Set Char
validISet = String -> Set Char
forall a. [a] -> Set a
S.fromDistinctAscList String
"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz"

validDISet :: Set Char
validDISet :: Set Char
validDISet = String -> Set Char
forall a. [a] -> Set a
S.fromDistinctAscList String
".0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz"

instance Dotted Utf8 where
  uncons :: Utf8 -> Maybe (Char, Utf8)
uncons Utf8
x = case ByteString -> Maybe (Char, ByteString)
U.uncons (Utf8 -> ByteString
utf8 Utf8
x) of
               Maybe (Char, ByteString)
Nothing -> Maybe (Char, Utf8)
forall a. Maybe a
Nothing
               Just (Char
c,ByteString
b) -> (Char, Utf8) -> Maybe (Char, Utf8)
forall a. a -> Maybe a
Just (Char
c,ByteString -> Utf8
Utf8 ByteString
b)
  cons :: Char -> Utf8 -> Utf8
cons Char
b (Utf8 ByteString
bs) | Char -> Int
forall a. Enum a => a -> Int
fromEnum Char
b Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
128 = ByteString -> Utf8
Utf8 (Char -> ByteString -> ByteString
LC.cons Char
b ByteString
bs)
                   | Bool
otherwise = ByteString -> Utf8
Utf8 ((String -> ByteString
U.fromString [Char
b]) ByteString -> ByteString -> ByteString
forall a. Monoid a => a -> a -> a
`mappend` ByteString
bs)
  dot :: Utf8 -> Utf8 -> Utf8
dot = Utf8 -> Utf8 -> Utf8
dotUtf8
  split :: Utf8 -> [Utf8]
split = Utf8 -> [Utf8]
splitUtf8
  validI :: Utf8 -> Maybe (IName Utf8)
validI = Utf8 -> Maybe (IName Utf8)
validIUtf8
  validDI :: Utf8 -> Maybe (DIName Utf8)
validDI = Utf8 -> Maybe (DIName Utf8)
validDIUtf8

instance Dotted String where
  uncons :: String -> Maybe (Char, String)
uncons [] = Maybe (Char, String)
forall a. Maybe a
Nothing
  uncons (Char
x:String
xs) = (Char, String) -> Maybe (Char, String)
forall a. a -> Maybe a
Just (Char
x,String
xs)
  cons :: Char -> ShowS
cons = (:)
  dot :: String -> ShowS
dot = String -> ShowS
dotString
  split :: String -> [String]
split = String -> [String]
splitString
  validI :: String -> Maybe (IName String)
validI = String -> Maybe (IName String)
validIString
  validDI :: String -> Maybe (DIName String)
validDI = String -> Maybe (DIName String)
validDIString

err :: String -> a
err :: String -> a
err String
s = String -> a
forall a. HasCallStack => String -> a
error (String
"Text.ProtocolBuffers.ProtoCompile.Identifiers: "String -> ShowS
forall a. [a] -> [a] -> [a]
++String
s)

-- make leading upper case letter, and leanding "_" becomes "U'_"
fixUp :: String -> String
fixUp :: ShowS
fixUp String
xs | String -> Char
forall a. [a] -> a
last String
xs Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'\'' = ShowS
fixUp (ShowS
forall a. [a] -> [a]
init String
xs) -- in case this is mangling after "fixLow"
fixUp (Char
'_':String
xs) = String
"U'"String -> ShowS
forall a. [a] -> [a] -> [a]
++String
xs
fixUp i :: String
i@(Char
x:String
xs) | Char -> Bool
isLower Char
x =
  let x' :: Char
x' = Char -> Char
toUpper Char
x
  in if Char -> Bool
isLower Char
x' then ShowS
forall a. String -> a
err (String
"fixUp: stubborn lower case"String -> ShowS
forall a. [a] -> [a] -> [a]
++ShowS
forall a. Show a => a -> String
show String
i)
       else Char
x'Char -> ShowS
forall a. a -> [a] -> [a]
: String
xs
fixUp String
xs = String
xs

-- make leading '_' or lower case letter, may end with added single quote.
fixLow :: String -> String
fixLow :: ShowS
fixLow [] = []
fixLow (Char
'U':Char
'\'':xs :: String
xs@(Char
'_':String
_))= ShowS
fixLow String
xs
fixLow i :: String
i@(Char
x:String
xs) | String
i String -> Set String -> Bool
forall a. Ord a => a -> Set a -> Bool
`S.member` Set String
reserved = String
i String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
"'"
                | Char -> Bool
isUpper Char
x = let x' :: Char
x' = Char -> Char
toLower Char
x
                              in if Char -> Bool
isUpper Char
x' then ShowS
forall a. String -> a
err (String
"fixLow: stubborn upper case: "String -> ShowS
forall a. [a] -> [a] -> [a]
++ShowS
forall a. Show a => a -> String
show String
i)
                                   else let i' :: String
i' = (Char
x'Char -> ShowS
forall a. a -> [a] -> [a]
:String
xs)
                                        in if String
i' String -> Set String -> Bool
forall a. Ord a => a -> Set a -> Bool
`S.member` Set String
reserved then String
i' String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
"'" else String
i'
                | Bool
otherwise = String
i

-- | 'reserved' is a set of strings which are Haskell keywords and
-- should not be valid field names.
--
-- I do not protect these values:
-- "mdo","foreign","rec","proc" ( GHC manual section 8.3.16 )
-- because I do not anticipate using these extensions in the generated
-- Haskell code.
reserved :: Set String
reserved :: Set String
reserved = [String] -> Set String
forall a. [a] -> Set a
S.fromDistinctAscList
  [String
"_"
  ,String
"case",String
"class",String
"data",String
"default",String
"deriving",String
"do",String
"else"
  ,String
"forall" {- extension keyword -}
  ,String
"if",String
"import",String
"in",String
"infix",String
"infixl",String
"infixr",String
"instance"
  ,String
"let",String
"module",String
"newtype",String
"of",String
"then",String
"type",String
"where"
  ]