{-# LANGUAGE MultiParamTypeClasses,FlexibleInstances,TypeSynonymInstances,FlexibleContexts,CPP #-}

-- | This modules collects utility routines related to the different
-- incarnations of identifiers in the code.  The basic identifier is
-- always ASCII, but because of the self gereneted 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.
--
-- 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.ProtoCompile.Identifiers 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.Set(Set)
import qualified Data.Set as S
import Text.ProtocolBuffers.Basic

-- | Contains one identifier name
newtype IName a = IName {IName a -> a
iName::a} deriving (Int -> IName a -> ShowS
[IName a] -> ShowS
IName a -> String
(Int -> IName a -> ShowS)
-> (IName a -> String) -> ([IName a] -> ShowS) -> Show (IName a)
forall a. Show a => Int -> IName a -> ShowS
forall a. Show a => [IName a] -> ShowS
forall a. Show a => IName a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [IName a] -> ShowS
$cshowList :: forall a. Show a => [IName a] -> ShowS
show :: IName a -> String
$cshow :: forall a. Show a => IName a -> String
showsPrec :: Int -> IName a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> IName a -> ShowS
Show,ReadPrec [IName a]
ReadPrec (IName a)
Int -> ReadS (IName a)
ReadS [IName a]
(Int -> ReadS (IName a))
-> ReadS [IName a]
-> ReadPrec (IName a)
-> ReadPrec [IName a]
-> Read (IName a)
forall a. Read a => ReadPrec [IName a]
forall a. Read a => ReadPrec (IName a)
forall a. Read a => Int -> ReadS (IName a)
forall a. Read a => ReadS [IName a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [IName a]
$creadListPrec :: forall a. Read a => ReadPrec [IName a]
readPrec :: ReadPrec (IName a)
$creadPrec :: forall a. Read a => ReadPrec (IName a)
readList :: ReadS [IName a]
$creadList :: forall a. Read a => ReadS [IName a]
readsPrec :: Int -> ReadS (IName a)
$creadsPrec :: forall a. Read a => Int -> ReadS (IName a)
Read,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
newtype MName a = MName {MName a -> a
mName::a} deriving (Int -> MName a -> ShowS
[MName a] -> ShowS
MName a -> String
(Int -> MName a -> ShowS)
-> (MName a -> String) -> ([MName a] -> ShowS) -> Show (MName a)
forall a. Show a => Int -> MName a -> ShowS
forall a. Show a => [MName a] -> ShowS
forall a. Show a => MName a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MName a] -> ShowS
$cshowList :: forall a. Show a => [MName a] -> ShowS
show :: MName a -> String
$cshow :: forall a. Show a => MName a -> String
showsPrec :: Int -> MName a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> MName a -> ShowS
Show,ReadPrec [MName a]
ReadPrec (MName a)
Int -> ReadS (MName a)
ReadS [MName a]
(Int -> ReadS (MName a))
-> ReadS [MName a]
-> ReadPrec (MName a)
-> ReadPrec [MName a]
-> Read (MName a)
forall a. Read a => ReadPrec [MName a]
forall a. Read a => ReadPrec (MName a)
forall a. Read a => Int -> ReadS (MName a)
forall a. Read a => ReadS [MName a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MName a]
$creadListPrec :: forall a. Read a => ReadPrec [MName a]
readPrec :: ReadPrec (MName a)
$creadPrec :: forall a. Read a => ReadPrec (MName a)
readList :: ReadS [MName a]
$creadList :: forall a. Read a => ReadS [MName a]
readsPrec :: Int -> ReadS (MName a)
$creadsPrec :: forall a. Read a => Int -> ReadS (MName a)
Read,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
newtype FName a = FName {FName a -> a
fName::a} deriving (Int -> FName a -> ShowS
[FName a] -> ShowS
FName a -> String
(Int -> FName a -> ShowS)
-> (FName a -> String) -> ([FName a] -> ShowS) -> Show (FName a)
forall a. Show a => Int -> FName a -> ShowS
forall a. Show a => [FName a] -> ShowS
forall a. Show a => FName a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FName a] -> ShowS
$cshowList :: forall a. Show a => [FName a] -> ShowS
show :: FName a -> String
$cshow :: forall a. Show a => FName a -> String
showsPrec :: Int -> FName a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> FName a -> ShowS
Show,ReadPrec [FName a]
ReadPrec (FName a)
Int -> ReadS (FName a)
ReadS [FName a]
(Int -> ReadS (FName a))
-> ReadS [FName a]
-> ReadPrec (FName a)
-> ReadPrec [FName a]
-> Read (FName a)
forall a. Read a => ReadPrec [FName a]
forall a. Read a => ReadPrec (FName a)
forall a. Read a => Int -> ReadS (FName a)
forall a. Read a => ReadS [FName a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [FName a]
$creadListPrec :: forall a. Read a => ReadPrec [FName a]
readPrec :: ReadPrec (FName a)
$creadPrec :: forall a. Read a => ReadPrec (FName a)
readList :: ReadS [FName a]
$creadList :: forall a. Read a => ReadS [FName a]
readsPrec :: Int -> ReadS (FName a)
$creadsPrec :: forall a. Read a => Int -> ReadS (FName a)
Read,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
newtype DIName a = DIName {DIName a -> a
diName :: a}
-- | Fully qualified identifier: repeated '.' then identifier.
newtype FIName a = FIName {FIName a -> a
fiName::a} deriving (Int -> FIName a -> ShowS
[FIName a] -> ShowS
FIName a -> String
(Int -> FIName a -> ShowS)
-> (FIName a -> String) -> ([FIName a] -> ShowS) -> Show (FIName a)
forall a. Show a => Int -> FIName a -> ShowS
forall a. Show a => [FIName a] -> ShowS
forall a. Show a => FIName a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FIName a] -> ShowS
$cshowList :: forall a. Show a => [FIName a] -> ShowS
show :: FIName a -> String
$cshow :: forall a. Show a => FIName a -> String
showsPrec :: Int -> FIName a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> FIName a -> ShowS
Show,ReadPrec [FIName a]
ReadPrec (FIName a)
Int -> ReadS (FIName a)
ReadS [FIName a]
(Int -> ReadS (FIName a))
-> ReadS [FIName a]
-> ReadPrec (FIName a)
-> ReadPrec [FIName a]
-> Read (FIName a)
forall a. Read a => ReadPrec [FIName a]
forall a. Read a => ReadPrec (FIName a)
forall a. Read a => Int -> ReadS (FIName a)
forall a. Read a => ReadS [FIName a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [FIName a]
$creadListPrec :: forall a. Read a => ReadPrec [FIName a]
readPrec :: ReadPrec (FIName a)
$creadPrec :: forall a. Read a => ReadPrec (FIName a)
readList :: ReadS [FIName a]
$creadList :: forall a. Read a => ReadS [FIName a]
readsPrec :: Int -> ReadS (FIName a)
$creadsPrec :: forall a. Read a => Int -> ReadS (FIName a)
Read,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 (Int -> FMName a -> ShowS
[FMName a] -> ShowS
FMName a -> String
(Int -> FMName a -> ShowS)
-> (FMName a -> String) -> ([FMName a] -> ShowS) -> Show (FMName a)
forall a. Show a => Int -> FMName a -> ShowS
forall a. Show a => [FMName a] -> ShowS
forall a. Show a => FMName a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FMName a] -> ShowS
$cshowList :: forall a. Show a => [FMName a] -> ShowS
show :: FMName a -> String
$cshow :: forall a. Show a => FMName a -> String
showsPrec :: Int -> FMName a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> FMName a -> ShowS
Show,ReadPrec [FMName a]
ReadPrec (FMName a)
Int -> ReadS (FMName a)
ReadS [FMName a]
(Int -> ReadS (FMName a))
-> ReadS [FMName a]
-> ReadPrec (FMName a)
-> ReadPrec [FMName a]
-> Read (FMName a)
forall a. Read a => ReadPrec [FMName a]
forall a. Read a => ReadPrec (FMName a)
forall a. Read a => Int -> ReadS (FMName a)
forall a. Read a => ReadS [FMName a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [FMName a]
$creadListPrec :: forall a. Read a => ReadPrec [FMName a]
readPrec :: ReadPrec (FMName a)
$creadPrec :: forall a. Read a => ReadPrec (FMName a)
readList :: ReadS [FMName a]
$creadList :: forall a. Read a => ReadS [FMName a]
readsPrec :: Int -> ReadS (FMName a)
$creadsPrec :: forall a. Read a => Int -> ReadS (FMName a)
Read,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 (Int -> FFName a -> ShowS
[FFName a] -> ShowS
FFName a -> String
(Int -> FFName a -> ShowS)
-> (FFName a -> String) -> ([FFName a] -> ShowS) -> Show (FFName a)
forall a. Show a => Int -> FFName a -> ShowS
forall a. Show a => [FFName a] -> ShowS
forall a. Show a => FFName a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FFName a] -> ShowS
$cshowList :: forall a. Show a => [FFName a] -> ShowS
show :: FFName a -> String
$cshow :: forall a. Show a => FFName a -> String
showsPrec :: Int -> FFName a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> FFName a -> ShowS
Show,ReadPrec [FFName a]
ReadPrec (FFName a)
Int -> ReadS (FFName a)
ReadS [FFName a]
(Int -> ReadS (FFName a))
-> ReadS [FFName a]
-> ReadPrec (FFName a)
-> ReadPrec [FFName a]
-> Read (FFName a)
forall a. Read a => ReadPrec [FFName a]
forall a. Read a => ReadPrec (FFName a)
forall a. Read a => Int -> ReadS (FFName a)
forall a. Read a => ReadS [FFName a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [FFName a]
$creadListPrec :: forall a. Read a => ReadPrec [FFName a]
readPrec :: ReadPrec (FFName a)
$creadPrec :: forall a. Read a => ReadPrec (FFName a)
readList :: ReadS [FFName a]
$creadList :: forall a. Read a => ReadS [FFName a]
readsPrec :: Int -> ReadS (FFName a)
$creadsPrec :: forall a. Read a => Int -> ReadS (FFName a)
Read,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
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,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
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,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)

dotPM :: Dotted a => PMName a -> FMName a
dotPM :: PMName a -> FMName a
dotPM (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)

dotPF :: Dotted a => PFName a -> FFName a
dotPF :: PFName a -> FFName a
dotPF (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)

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)

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

preUtf8 :: Utf8 -> Utf8
preUtf8 :: Utf8 -> Utf8
preUtf8 (Utf8 ByteString
x) = ByteString -> Utf8
Utf8 (Char -> ByteString -> ByteString
LC.cons Char
'x' ByteString
x)

preString :: String -> String
preString :: ShowS
preString = (Char
'.'Char -> ShowS
forall a. a -> [a] -> [a]
:)

splitUtf8 :: DIName Utf8 -> [IName Utf8]
splitUtf8 :: DIName Utf8 -> [IName Utf8]
splitUtf8 = (ByteString -> Maybe (IName Utf8, ByteString))
-> ByteString -> [IName Utf8]
forall b a. (b -> Maybe (a, b)) -> b -> [a]
unfoldr ByteString -> Maybe (IName Utf8, ByteString)
s (ByteString -> [IName Utf8])
-> (DIName Utf8 -> ByteString) -> DIName Utf8 -> [IName Utf8]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Utf8 -> ByteString
utf8 (Utf8 -> ByteString)
-> (DIName Utf8 -> Utf8) -> DIName Utf8 -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DIName Utf8 -> Utf8
forall a. DIName a -> a
diName where
  s :: ByteString -> Maybe (IName Utf8,ByteString)
  s :: ByteString -> Maybe (IName Utf8, ByteString)
s ByteString
y | ByteString -> Bool
LC.null ByteString
y = Maybe (IName Utf8, ByteString)
forall a. Maybe a
Nothing
      | Bool
otherwise = case (Char -> Bool) -> ByteString -> (ByteString, ByteString)
U.span (Char
'.'Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/=) ByteString
y of
                      (ByteString
a,ByteString
b) | ByteString -> Bool
LC.null ByteString
a -> ByteString -> Maybe (IName Utf8, ByteString)
s ByteString
b
                            | Bool
otherwise -> (IName Utf8, ByteString) -> Maybe (IName Utf8, ByteString)
forall a. a -> Maybe a
Just (Utf8 -> IName Utf8
forall a. a -> IName a
IName (ByteString -> Utf8
Utf8 ByteString
a),ByteString
b)

splitString :: DIName String -> [IName String]
splitString :: DIName String -> [IName String]
splitString = (String -> Maybe (IName String, String))
-> String -> [IName String]
forall b a. (b -> Maybe (a, b)) -> b -> [a]
unfoldr String -> Maybe (IName String, String)
s (String -> [IName String])
-> (DIName String -> String) -> DIName String -> [IName String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DIName String -> String
forall a. DIName a -> a
diName where
  s :: String -> Maybe (IName String, String)
s [] = Maybe (IName String, String)
forall a. Maybe a
Nothing
  s (Char
'.':String
xs) = String -> Maybe (IName String, String)
s String
xs -- delete all '.' in the input
  s String
xs = (IName String, String) -> Maybe (IName String, String)
forall a. a -> Maybe a
Just (let (String
a,String
b) = (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 in (String -> IName String
forall a. a -> IName a
IName String
a,String
b))

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

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
                    Maybe (Char, a)
Nothing -> a -> FIName a
forall a. a -> FIName a
FIName a
forall a. Monoid a => a
mempty
                    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 (a -> a
forall a. Dotted a => a -> a
preDot a
a)

{- in Text.ProtocolBuffers.Basic now
instance Monoid Utf8 where
  mempty = Utf8 mempty
  mappend (Utf8 x) (Utf8 y) = Utf8 (mappend x y)
-}

class Monoid a => Dotted a where
  uncons :: a -> Maybe (Char,a)
  preDot :: a -> a
  dot :: a -> a -> a
  splitDI :: DIName a -> [IName a]

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)
  preDot :: Utf8 -> Utf8
preDot = Utf8 -> Utf8
preUtf8
  dot :: Utf8 -> Utf8 -> Utf8
dot = Utf8 -> Utf8 -> Utf8
dotUtf8
  splitDI :: DIName Utf8 -> [IName Utf8]
splitDI = DIName Utf8 -> [IName Utf8]
splitUtf8

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)
  preDot :: ShowS
preDot = ShowS
preString
  dot :: String -> ShowS
dot = String -> ShowS
dotString
  splitDI :: DIName String -> [IName String]
splitDI = DIName String -> [IName String]
splitString

splitFI :: Dotted a => FIName a -> [IName a]
splitFI :: FIName a -> [IName a]
splitFI = DIName a -> [IName a]
forall a. Dotted a => DIName a -> [IName a]
splitDI (DIName a -> [IName a])
-> (FIName a -> DIName a) -> FIName a -> [IName a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> DIName a
forall a. a -> DIName a
DIName (a -> DIName a) -> (FIName a -> a) -> FIName a -> DIName a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FIName a -> a
forall a. FIName a -> a
fiName

fqDots :: Dotted a => [IName a] -> FIName a
fqDots :: [IName a] -> FIName a
fqDots [] = a -> FIName a
forall a. a -> FIName a
FIName a
forall a. Monoid a => a
mempty
fqDots [IName a]
xs = a -> FIName a
forall a. a -> FIName a
FIName (a -> a
forall a. Dotted a => a -> a
preDot ((a -> a -> a) -> [a] -> a
forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
foldr1 a -> a -> a
forall a. Dotted a => a -> a -> a
dot ([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))

joinDots :: Dotted a => [a] -> a
joinDots :: [a] -> a
joinDots [] = a
forall a. Monoid a => a
mempty
joinDots [a]
xs = (a -> a -> a) -> [a] -> a
forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
foldr1 a -> a -> a
forall a. Dotted a => a -> a -> a
dot [a]
xs

-- | Right (True,_) means the input is a FIName.
-- Right (False,_) means the input is a DIName (without leading '.')
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
_,String
"")  = [IName String] -> Either String [IName String]
forall a b. b -> Either a b
Right ([IName String] -> [IName String]
f [])
       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 '.')
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 [])
                         (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))

manglePM :: Mangle a (MName x) => [a] -> PMName x
manglePM :: [a] -> PMName x
manglePM = ([MName x] -> [MName x]) -> [a] -> PMName x
forall a a a.
(Mangle a a, Mangle a (MName a)) =>
([a] -> [MName a]) -> [a] -> PMName a
go [MName x] -> [MName x]
forall a. a -> a
id where
  go :: ([a] -> [MName a]) -> [a] -> PMName a
go [a] -> [MName a]
ms [a
x] = [MName a] -> MName a -> PMName a
forall a. [MName a] -> MName a -> PMName a
PMName ([a] -> [MName a]
ms []) (a -> MName a
forall a b. Mangle a b => a -> b
mangle a
x)
  go [a] -> [MName a]
ms (a
x:[a]
xs) = ([a] -> [MName a]) -> [a] -> PMName a
go ([a] -> [MName a]
ms ([a] -> [MName a]) -> ([a] -> [a]) -> [a] -> [MName a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> a
forall a b. Mangle a b => a -> b
mangle a
xa -> [a] -> [a]
forall a. a -> [a] -> [a]
:)) [a]
xs
  go [a] -> [MName a]
_ [] = String -> PMName a
forall a. HasCallStack => String -> a
error String
"impossible manglePM []"

manglePF :: (Mangle a (MName x),Mangle a (FName x)) => [a] -> PFName x
manglePF :: [a] -> PFName x
manglePF = ([MName x] -> [MName x]) -> [a] -> PFName x
forall a a a.
(Mangle a a, Mangle a (FName a)) =>
([a] -> [MName a]) -> [a] -> PFName a
go [MName x] -> [MName x]
forall a. a -> a
id where
  go :: ([a] -> [MName a]) -> [a] -> PFName a
go [a] -> [MName a]
ms [a
x] = [MName a] -> FName a -> PFName a
forall a. [MName a] -> FName a -> PFName a
PFName ([a] -> [MName a]
ms []) (a -> FName a
forall a b. Mangle a b => a -> b
mangle a
x)
  go [a] -> [MName a]
ms (a
x:[a]
xs) = ([a] -> [MName a]) -> [a] -> PFName a
go ([a] -> [MName a]
ms ([a] -> [MName a]) -> ([a] -> [a]) -> [a] -> [MName a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> a
forall a b. Mangle a b => a -> b
mangle a
xa -> [a] -> [a]
forall a. a -> [a] -> [a]
:)) [a]
xs
  go [a] -> [MName a]
_ [] = String -> PFName a
forall a. HasCallStack => String -> a
error String
"impossible manglePF []"

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

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)

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 Utf8) where
  mangle :: IName Utf8 -> MName Utf8
mangle (IName Utf8
s) = Utf8 -> MName Utf8
forall a. a -> MName a
MName (String -> Utf8
fromString (String -> Utf8) -> (Utf8 -> String) -> Utf8 -> Utf8
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShowS
fixUp ShowS -> (Utf8 -> String) -> Utf8 -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Utf8 -> String
toString (Utf8 -> Utf8) -> Utf8 -> Utf8
forall a b. (a -> b) -> a -> b
$ Utf8
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 (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 Utf8) where
  mangle :: IName Utf8 -> FName Utf8
mangle (IName Utf8
s) = Utf8 -> FName Utf8
forall a. a -> FName a
FName (String -> Utf8
fromString (String -> Utf8) -> (Utf8 -> String) -> Utf8 -> Utf8
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShowS
fixLow ShowS -> (Utf8 -> String) -> Utf8 -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Utf8 -> String
toString (Utf8 -> Utf8) -> Utf8 -> Utf8
forall a b. (a -> b) -> a -> b
$ Utf8
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)

-- make leading upper case letter or "U'_"
fixUp :: String -> String
fixUp :: ShowS
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 single quote.
fixLow :: String -> String
fixLow :: ShowS
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
fixLow [] = []

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
"foreign"
  ,String
"if",String
"import",String
"in",String
"infix",String
"infixl",String
"infixr",String
"instance"
  ,String
"let",String
"mdo",String
"module",String
"newtype",String
"of",String
"then",String
"type",String
"where"
  ]