Make Ident abstract; imports of Data.ByteString.Char8 down from 29 to 16 modules

Most of the explicit uses of ByteStrings were eliminated by using identS,

	identS = identC . BS.pack 

which was found in GF.Grammar.CF and moved to GF.Infra.Ident. The function

	prefixIdent :: String -> Ident -> Ident

allowed one additional import of ByteString to be eliminated. The functions

	isArgIdent :: Ident -> Bool
	getArgIndex :: Ident -> Maybe Int

were needed to eliminate explicit pattern matching on Ident from two modules.

4 files changed, 63 insertions, 201 deletions

diff --git a/src/compiler/GF/Grammar/CF.hs b/src/compiler/GF/Grammar/CF.hs
index 8b66bd72d..cb5c91bde 100644
--- a/src/compiler/GF/Grammar/CF.hs
+++ b/src/compiler/GF/Grammar/CF.hs
@@ -16,7 +16,7 @@ module GF.Grammar.CF (getCF,CFItem,CFCat,CFFun,cf2gf,CFRule) where
 
 import GF.Grammar.Grammar
 import GF.Grammar.Macros
-import GF.Infra.Ident
+import GF.Infra.Ident(Ident,identS)
 import GF.Infra.Option
 import GF.Infra.UseIO
 
@@ -25,7 +25,6 @@ import GF.Data.Utilities (nub')
 
 import Data.Char
 import Data.List
-import qualified Data.ByteString.Char8 as BS
 import System.FilePath
 
 getCF :: FilePath -> String -> Err SourceGrammar
@@ -126,6 +125,3 @@ cf2rule (L loc (fun, (cat, items))) = (def,ldef) where
   mkIt (_, Right a) = K a
   foldconcat [] = K ""
   foldconcat tt = foldr1 C tt
-
-identS = identC . BS.pack
-
diff --git a/src/compiler/GF/Grammar/MMacros.hs b/src/compiler/GF/Grammar/MMacros.hs
index c52ee4ce2..f1d2f172a 100644
--- a/src/compiler/GF/Grammar/MMacros.hs
+++ b/src/compiler/GF/Grammar/MMacros.hs
@@ -215,7 +215,7 @@ freeVarsExp e = case e of
   _ -> [] --- thus applies to abstract syntax only
 
 int2var :: Int -> Ident
-int2var = identC . BS.pack . ('$':) . show
+int2var = identS . ('$':) . show
 
 meta0 :: MetaId
 meta0 = 0
diff --git a/src/compiler/GF/Grammar/Parser.y b/src/compiler/GF/Grammar/Parser.y
index 21b45de73..a84db6ffd 100644
--- a/src/compiler/GF/Grammar/Parser.y
+++ b/src/compiler/GF/Grammar/Parser.y
@@ -16,7 +16,6 @@ import GF.Grammar.Predef
 import GF.Grammar.Grammar
 import GF.Grammar.Macros
 import GF.Grammar.Lexer
-import qualified Data.ByteString.Char8 as BS
 import GF.Compile.Update (buildAnyTree)
 import Codec.Binary.UTF8.String(decodeString)
 import Data.Char(toLower)
@@ -622,12 +621,9 @@ optDecode opts =
     else id
 
 mkListId,mkConsId,mkBaseId  :: Ident -> Ident
-mkListId = prefixId (BS.pack "List")
-mkConsId = prefixId (BS.pack "Cons")
-mkBaseId = prefixId (BS.pack "Base")
-
-prefixId :: BS.ByteString -> Ident -> Ident
-prefixId pref id = identC (BS.append pref (ident2bs id))
+mkListId = prefixIdent "List"
+mkConsId = prefixIdent "Cons"
+mkBaseId = prefixIdent "Base"
 
 listCatDef :: L (Ident, Context, Int) -> [(Ident,Info)]
 listCatDef (L loc (id,cont,size)) = [catd,nilfund,consfund]
diff --git a/src/compiler/GF/Grammar/Predef.hs b/src/compiler/GF/Grammar/Predef.hs
index 71b0cef3d..8bee8dcb5 100644
--- a/src/compiler/GF/Grammar/Predef.hs
+++ b/src/compiler/GF/Grammar/Predef.hs
@@ -8,195 +8,65 @@
 -- Predefined identifiers and labels which the compiler knows
 ----------------------------------------------------------------------
 
-
-module GF.Grammar.Predef
-          ( cType
-          , cPType
-          , cTok
-          , cStr
-          , cStrs
-          , cPredefAbs, cPredefCnc, cPredef
-          , cInt
-          , cFloat
-          , cString
-          , cVar
-          , cInts
-          , cNonExist
-          , cPBool
-          , cErrorType
-          , cOverload
-          , cUndefinedType
-          , isPredefCat
-
-          , cPTrue, cPFalse
-
-          , cLength, cDrop, cTake, cTk, cDp, cEqStr, cOccur
-          , cOccurs, cEqInt, cLessInt, cPlus, cShow, cRead
-          , cToStr, cMapStr, cError
-          , cToUpper, cToLower, cIsUpper
-          , cEqVal
-
-          -- hacks
-          , cMeta, cAs, cChar, cChars, cSeq, cAlt, cRep
-          , cNeg, cCNC, cConflict
-          ) where
-
-import GF.Infra.Ident
-import qualified Data.ByteString.Char8 as BS
-
-cType :: Ident
-cType = identC (BS.pack "Type")
-
-cPType :: Ident
-cPType = identC (BS.pack "PType")
-
-cTok :: Ident
-cTok = identC (BS.pack "Tok")
-
-cStr :: Ident
-cStr = identC (BS.pack "Str")
-
-cStrs :: Ident
-cStrs = identC (BS.pack "Strs")
-
-cPredefAbs :: Ident
-cPredefAbs = identC (BS.pack "PredefAbs")
-
-cPredefCnc :: Ident
-cPredefCnc = identC (BS.pack "PredefCnc")
-
-cPredef :: Ident
-cPredef = identC (BS.pack "Predef")
-
-cInt :: Ident
-cInt = identC (BS.pack "Int")
-
-cFloat :: Ident
-cFloat = identC (BS.pack "Float")
-
-cString :: Ident
-cString = identC (BS.pack "String")
-
-cVar :: Ident
-cVar = identC (BS.pack "__gfVar")
-
-cInts :: Ident
-cInts = identC (BS.pack "Ints")
-
-cPBool :: Ident
-cPBool = identC (BS.pack "PBool")
-
-cErrorType :: Ident
-cErrorType = identC (BS.pack "Error")
-
-cOverload :: Ident
-cOverload = identC (BS.pack "overload")
-
-cUndefinedType :: Ident
-cUndefinedType = identC (BS.pack "UndefinedType")
-
-cNonExist :: Ident
-cNonExist = identC (BS.pack "nonExist")
+module GF.Grammar.Predef where
+
+import GF.Infra.Ident(Ident,identS)
+
+cType = identS "Type"
+cPType = identS "PType"
+cTok = identS "Tok"
+cStr = identS "Str"
+cStrs = identS "Strs"
+cPredefAbs = identS "PredefAbs"
+cPredefCnc = identS "PredefCnc"
+cPredef = identS "Predef"
+cInt = identS "Int"
+cFloat = identS "Float"
+cString = identS "String"
+cVar = identS "__gfVar"
+cInts = identS "Ints"
+cPBool = identS "PBool"
+cErrorType = identS "Error"
+cOverload = identS "overload"
+cUndefinedType = identS "UndefinedType"
+cNonExist = identS "nonExist"
 
 isPredefCat :: Ident -> Bool
 isPredefCat c = elem c [cInt,cString,cFloat]
 
-cPTrue :: Ident
-cPTrue  = identC (BS.pack "PTrue")
-
-cPFalse :: Ident
-cPFalse = identC (BS.pack "PFalse")
-
-cLength :: Ident
-cLength = identC (BS.pack "length")
-
-cDrop :: Ident
-cDrop = identC (BS.pack "drop")
-
-cTake :: Ident
-cTake = identC (BS.pack "take")
-
-cTk :: Ident
-cTk = identC (BS.pack "tk")
-
-cDp :: Ident
-cDp = identC (BS.pack "dp")
-
-cToUpper :: Ident
-cToUpper = identC (BS.pack "toUpper")
-
-cToLower :: Ident
-cToLower = identC (BS.pack "toLower")
-
-cIsUpper :: Ident
-cIsUpper = identC (BS.pack "isUpper")
-
-cEqStr :: Ident
-cEqStr = identC (BS.pack "eqStr")
-
-cEqVal :: Ident
-cEqVal = identC (BS.pack "eqVal")
-
-cOccur :: Ident
-cOccur = identC (BS.pack "occur")
-
-cOccurs :: Ident
-cOccurs = identC (BS.pack "occurs")
-
-cEqInt :: Ident
-cEqInt = identC (BS.pack "eqInt")
-
-cLessInt :: Ident
-cLessInt = identC (BS.pack "lessInt")
-
-cPlus :: Ident
-cPlus = identC (BS.pack "plus")
-
-cShow :: Ident
-cShow = identC (BS.pack "show")
-
-cRead :: Ident
-cRead = identC (BS.pack "read")
-
-cToStr :: Ident
-cToStr = identC (BS.pack "toStr")
-
-cMapStr :: Ident
-cMapStr = identC (BS.pack "mapStr")
-
-cError :: Ident
-cError = identC (BS.pack "error")
-
-
---- hacks: dummy identifiers used in various places
---- Not very nice!
-
-cMeta :: Ident
-cMeta = identC (BS.singleton '?')
-
-cAs :: Ident
-cAs = identC (BS.singleton '@')
-
-cChar :: Ident
-cChar = identC (BS.singleton '?')
-
-cChars :: Ident
-cChars = identC (BS.pack "[]")
-
-cSeq :: Ident
-cSeq = identC (BS.pack "+")
-
-cAlt :: Ident
-cAlt = identC (BS.pack "|")
-
-cRep :: Ident
-cRep = identC (BS.pack "*")
-
-cNeg :: Ident
-cNeg = identC (BS.pack "-")
-
-cCNC :: Ident
-cCNC = identC (BS.pack "CNC")
-
-cConflict :: Ident
-cConflict = IC (BS.pack "#conflict")
+cPTrue  = identS "PTrue"
+cPFalse = identS "PFalse"
+cLength = identS "length"
+cDrop = identS "drop"
+cTake = identS "take"
+cTk = identS "tk"
+cDp = identS "dp"
+cToUpper = identS "toUpper"
+cToLower = identS "toLower"
+cIsUpper = identS "isUpper"
+cEqStr = identS "eqStr"
+cEqVal = identS "eqVal"
+cOccur = identS "occur"
+cOccurs = identS "occurs"
+cEqInt = identS "eqInt"
+cLessInt = identS "lessInt"
+cPlus = identS "plus"
+cShow = identS "show"
+cRead = identS "read"
+cToStr = identS "toStr"
+cMapStr = identS "mapStr"
+cError = identS "error"
+
+-- * Hacks: dummy identifiers used in various places.
+-- Not very nice!
+
+cMeta = identS "?"
+cAs = identS "@"
+cChar = identS "?"
+cChars = identS "[]"
+cSeq = identS "+"
+cAlt = identS "|"
+cRep = identS "*"
+cNeg = identS "-"
+cCNC = identS "CNC"
+cConflict = identS "#conflict"