2 % (c) The University of Glasgow 2006
3 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
9 -- * The NameSpace type; abstact
10 NameSpace, tcName, clsName, tcClsName, dataName, varName,
14 pprNameSpace, pprNonVarNameSpace, pprNameSpaceBrief,
17 OccName, -- Abstract, instance of Outputable
21 mkOccName, mkOccNameFS,
28 -- ** Derived OccNames
30 mkDataConWrapperOcc, mkWorkerOcc, mkDefaultMethodOcc,
31 mkDerivedTyConOcc, mkNewTyCoOcc,
32 mkCon2TagOcc, mkTag2ConOcc, mkMaxTagOcc,
33 mkClassTyConOcc, mkClassDataConOcc, mkDictOcc, mkIPOcc,
34 mkSpecOcc, mkForeignExportOcc, mkGenOcc1, mkGenOcc2,
35 mkDataTOcc, mkDataCOcc, mkDataConWorkerOcc,
36 mkSuperDictSelOcc, mkLocalOcc, mkMethodOcc, mkInstTyTcOcc,
37 mkInstTyCoOcc, mkEqPredCoOcc,
38 mkVectOcc, mkVectTyConOcc, mkVectDataConOcc, mkVectIsoOcc,
39 mkPArrayTyConOcc, mkPArrayDataConOcc,
44 occNameFS, occNameString, occNameSpace,
46 isVarOcc, isTvOcc, isTcOcc, isDataOcc, isDataSymOcc, isSymOcc, isValOcc,
47 parenSymOcc, reportIfUnused, isTcClsName, isVarName,
52 OccEnv, emptyOccEnv, unitOccEnv, extendOccEnv, mapOccEnv,
53 lookupOccEnv, mkOccEnv, mkOccEnv_C, extendOccEnvList, elemOccEnv,
54 occEnvElts, foldOccEnv, plusOccEnv, plusOccEnv_C, extendOccEnv_C,
55 filterOccEnv, delListFromOccEnv, delFromOccEnv,
58 OccSet, emptyOccSet, unitOccSet, mkOccSet, extendOccSet,
60 unionOccSets, unionManyOccSets, minusOccSet, elemOccSet, occSetElts,
61 foldOccSet, isEmptyOccSet, intersectOccSet, intersectsOccSet,
64 TidyOccEnv, emptyTidyOccEnv, tidyOccName, initTidyOccEnv,
66 -- The basic form of names
67 isLexCon, isLexVar, isLexId, isLexSym,
68 isLexConId, isLexConSym, isLexVarId, isLexVarSym,
69 startsVarSym, startsVarId, startsConSym, startsConId
86 -- Unicode TODO: put isSymbol in libcompat
87 #if !defined(__GLASGOW_HASKELL__) || __GLASGOW_HASKELL__ > 604
90 isSymbol = const False
95 %************************************************************************
97 \subsection{Name space}
99 %************************************************************************
102 data NameSpace = VarName -- Variables, including "real" data constructors
103 | DataName -- "Source" data constructors
104 | TvName -- Type variables
105 | TcClsName -- Type constructors and classes; Haskell has them
106 -- in the same name space for now.
108 {-! derive: Binary !-}
110 -- Note [Data Constructors]
111 -- see also: Note [Data Constructor Naming] in DataCon.lhs
113 -- "Source" data constructors are the data constructors mentioned
114 -- in Haskell source code
116 -- "Real" data constructors are the data constructors of the
117 -- representation type, which may not be the same as the source
121 -- data T = T !(Int,Int)
123 -- The source datacon has type (Int,Int) -> T
124 -- The real datacon has type Int -> Int -> T
125 -- GHC chooses a representation based on the strictness etc.
127 tcName, clsName, tcClsName :: NameSpace
128 dataName, srcDataName :: NameSpace
129 tvName, varName :: NameSpace
131 -- Though type constructors and classes are in the same name space now,
132 -- the NameSpace type is abstract, so we can easily separate them later
133 tcName = TcClsName -- Type constructors
134 clsName = TcClsName -- Classes
135 tcClsName = TcClsName -- Not sure which!
138 srcDataName = DataName -- Haskell-source data constructors should be
139 -- in the Data name space
144 isTcClsName :: NameSpace -> Bool
145 isTcClsName TcClsName = True
146 isTcClsName _ = False
148 isVarName :: NameSpace -> Bool -- Variables or type variables, but not constructors
149 isVarName TvName = True
150 isVarName VarName = True
153 pprNameSpace :: NameSpace -> SDoc
154 pprNameSpace DataName = ptext (sLit "data constructor")
155 pprNameSpace VarName = ptext (sLit "variable")
156 pprNameSpace TvName = ptext (sLit "type variable")
157 pprNameSpace TcClsName = ptext (sLit "type constructor or class")
159 pprNonVarNameSpace :: NameSpace -> SDoc
160 pprNonVarNameSpace VarName = empty
161 pprNonVarNameSpace ns = pprNameSpace ns
163 pprNameSpaceBrief :: NameSpace -> SDoc
164 pprNameSpaceBrief DataName = char 'd'
165 pprNameSpaceBrief VarName = char 'v'
166 pprNameSpaceBrief TvName = ptext (sLit "tv")
167 pprNameSpaceBrief TcClsName = ptext (sLit "tc")
171 %************************************************************************
173 \subsection[Name-pieces-datatypes]{The @OccName@ datatypes}
175 %************************************************************************
178 data OccName = OccName
179 { occNameSpace :: !NameSpace
180 , occNameFS :: !FastString
186 instance Eq OccName where
187 (OccName sp1 s1) == (OccName sp2 s2) = s1 == s2 && sp1 == sp2
189 instance Ord OccName where
190 -- Compares lexicographically, *not* by Unique of the string
191 compare (OccName sp1 s1) (OccName sp2 s2)
192 = (s1 `compare` s2) `thenCmp` (sp1 `compare` sp2)
196 %************************************************************************
198 \subsection{Printing}
200 %************************************************************************
203 instance Outputable OccName where
206 pprOccName :: OccName -> SDoc
207 pprOccName (OccName sp occ)
208 = getPprStyle $ \ sty ->
210 then ftext (zEncodeFS occ)
211 else ftext occ <> if debugStyle sty
212 then braces (pprNameSpaceBrief sp)
217 %************************************************************************
219 \subsection{Construction}
221 %************************************************************************
224 mkOccName :: NameSpace -> String -> OccName
225 mkOccName occ_sp str = OccName occ_sp (mkFastString str)
227 mkOccNameFS :: NameSpace -> FastString -> OccName
228 mkOccNameFS occ_sp fs = OccName occ_sp fs
230 mkVarOcc :: String -> OccName
231 mkVarOcc s = mkOccName varName s
233 mkVarOccFS :: FastString -> OccName
234 mkVarOccFS fs = mkOccNameFS varName fs
236 mkTyVarOcc :: FastString -> OccName
237 mkTyVarOcc fs = mkOccNameFS tvName fs
241 %************************************************************************
245 %************************************************************************
247 OccEnvs are used mainly for the envts in ModIfaces.
249 They are efficient, because FastStrings have unique Int# keys. We assume
250 this key is less than 2^24, so we can make a Unique using
251 mkUnique ns key :: Unique
252 where 'ns' is a Char reprsenting the name space. This in turn makes it
253 easy to build an OccEnv.
256 instance Uniquable OccName where
257 getUnique (OccName ns fs)
258 = mkUnique char (iBox (uniqueOfFS fs))
259 where -- See notes above about this getUnique function
266 newtype OccEnv a = A (UniqFM a)
268 emptyOccEnv :: OccEnv a
269 unitOccEnv :: OccName -> a -> OccEnv a
270 extendOccEnv :: OccEnv a -> OccName -> a -> OccEnv a
271 extendOccEnvList :: OccEnv a -> [(OccName, a)] -> OccEnv a
272 lookupOccEnv :: OccEnv a -> OccName -> Maybe a
273 mkOccEnv :: [(OccName,a)] -> OccEnv a
274 mkOccEnv_C :: (a -> a -> a) -> [(OccName,a)] -> OccEnv a
275 elemOccEnv :: OccName -> OccEnv a -> Bool
276 foldOccEnv :: (a -> b -> b) -> b -> OccEnv a -> b
277 occEnvElts :: OccEnv a -> [a]
278 extendOccEnv_C :: (a->a->a) -> OccEnv a -> OccName -> a -> OccEnv a
279 plusOccEnv :: OccEnv a -> OccEnv a -> OccEnv a
280 plusOccEnv_C :: (a->a->a) -> OccEnv a -> OccEnv a -> OccEnv a
281 mapOccEnv :: (a->b) -> OccEnv a -> OccEnv b
282 delFromOccEnv :: OccEnv a -> OccName -> OccEnv a
283 delListFromOccEnv :: OccEnv a -> [OccName] -> OccEnv a
284 filterOccEnv :: (elt -> Bool) -> OccEnv elt -> OccEnv elt
286 emptyOccEnv = A emptyUFM
287 unitOccEnv x y = A $ unitUFM x y
288 extendOccEnv (A x) y z = A $ addToUFM x y z
289 extendOccEnvList (A x) l = A $ addListToUFM x l
290 lookupOccEnv (A x) y = lookupUFM x y
291 mkOccEnv l = A $ listToUFM l
292 elemOccEnv x (A y) = elemUFM x y
293 foldOccEnv a b (A c) = foldUFM a b c
294 occEnvElts (A x) = eltsUFM x
295 plusOccEnv (A x) (A y) = A $ plusUFM x y
296 plusOccEnv_C f (A x) (A y) = A $ plusUFM_C f x y
297 extendOccEnv_C f (A x) y z = A $ addToUFM_C f x y z
298 mapOccEnv f (A x) = A $ mapUFM f x
299 mkOccEnv_C comb l = A $ addListToUFM_C comb emptyUFM l
300 delFromOccEnv (A x) y = A $ delFromUFM x y
301 delListFromOccEnv (A x) y = A $ delListFromUFM x y
302 filterOccEnv x (A y) = A $ filterUFM x y
304 instance Outputable a => Outputable (OccEnv a) where
307 type OccSet = UniqSet OccName
309 emptyOccSet :: OccSet
310 unitOccSet :: OccName -> OccSet
311 mkOccSet :: [OccName] -> OccSet
312 extendOccSet :: OccSet -> OccName -> OccSet
313 extendOccSetList :: OccSet -> [OccName] -> OccSet
314 unionOccSets :: OccSet -> OccSet -> OccSet
315 unionManyOccSets :: [OccSet] -> OccSet
316 minusOccSet :: OccSet -> OccSet -> OccSet
317 elemOccSet :: OccName -> OccSet -> Bool
318 occSetElts :: OccSet -> [OccName]
319 foldOccSet :: (OccName -> b -> b) -> b -> OccSet -> b
320 isEmptyOccSet :: OccSet -> Bool
321 intersectOccSet :: OccSet -> OccSet -> OccSet
322 intersectsOccSet :: OccSet -> OccSet -> Bool
324 emptyOccSet = emptyUniqSet
325 unitOccSet = unitUniqSet
327 extendOccSet = addOneToUniqSet
328 extendOccSetList = addListToUniqSet
329 unionOccSets = unionUniqSets
330 unionManyOccSets = unionManyUniqSets
331 minusOccSet = minusUniqSet
332 elemOccSet = elementOfUniqSet
333 occSetElts = uniqSetToList
334 foldOccSet = foldUniqSet
335 isEmptyOccSet = isEmptyUniqSet
336 intersectOccSet = intersectUniqSets
337 intersectsOccSet s1 s2 = not (isEmptyOccSet (s1 `intersectOccSet` s2))
341 %************************************************************************
343 \subsection{Predicates and taking them apart}
345 %************************************************************************
348 occNameString :: OccName -> String
349 occNameString (OccName _ s) = unpackFS s
351 setOccNameSpace :: NameSpace -> OccName -> OccName
352 setOccNameSpace sp (OccName _ occ) = OccName sp occ
354 isVarOcc, isTvOcc, isDataSymOcc, isSymOcc, isTcOcc, isValOcc, isDataOcc :: OccName -> Bool
356 isVarOcc (OccName VarName _) = True
359 isTvOcc (OccName TvName _) = True
362 isTcOcc (OccName TcClsName _) = True
365 isValOcc (OccName VarName _) = True
366 isValOcc (OccName DataName _) = True
369 -- Data constructor operator (starts with ':', or '[]')
370 -- Pretty inefficient!
371 isDataSymOcc (OccName DataName s) = isLexConSym s
372 isDataSymOcc (OccName VarName s)
373 | isLexConSym s = pprPanic "isDataSymOcc: check me" (ppr s)
374 -- Jan06: I don't think this should happen
375 isDataSymOcc _ = False
377 isDataOcc (OccName DataName _) = True
378 isDataOcc (OccName VarName s)
379 | isLexCon s = pprPanic "isDataOcc: check me" (ppr s)
380 -- Jan06: I don't think this should happen
383 -- Any operator (data constructor or variable)
384 -- Pretty inefficient!
385 isSymOcc (OccName DataName s) = isLexConSym s
386 isSymOcc (OccName TcClsName s) = isLexConSym s
387 isSymOcc (OccName VarName s) = isLexSym s
388 isSymOcc (OccName TvName s) = isLexSym s
390 parenSymOcc :: OccName -> SDoc -> SDoc
391 -- Wrap parens around an operator
392 parenSymOcc occ doc | isSymOcc occ = parens doc
398 reportIfUnused :: OccName -> Bool
399 -- Haskell 98 encourages compilers to suppress warnings about
400 -- unused names in a pattern if they start with "_".
401 reportIfUnused occ = case occNameString occ of
407 %************************************************************************
409 \subsection{Making system names}
411 %************************************************************************
413 Here's our convention for splitting up the interface file name space:
415 d... dictionary identifiers
416 (local variables, so no name-clash worries)
418 $f... dict-fun identifiers (from inst decls)
419 $dm... default methods
420 $p... superclass selectors
422 :T... compiler-generated tycons for dictionaries
423 :D... ...ditto data cons
424 :Co... ...ditto coercions
425 $sf.. specialised version of f
427 in encoded form these appear as Zdfxxx etc
429 :... keywords (export:, letrec: etc.)
430 --- I THINK THIS IS WRONG!
432 This knowledge is encoded in the following functions.
434 @mk_deriv@ generates an @OccName@ from the prefix and a string.
435 NB: The string must already be encoded!
438 mk_deriv :: NameSpace
439 -> String -- Distinguishes one sort of derived name from another
443 mk_deriv occ_sp sys_prefix str = mkOccName occ_sp (sys_prefix ++ str)
445 isDerivedOccName :: OccName -> Bool
446 isDerivedOccName occ =
447 case occNameString occ of
448 '$':c:_ | isAlphaNum c -> True
449 ':':c:_ | isAlphaNum c -> True
454 mkDataConWrapperOcc, mkWorkerOcc, mkDefaultMethodOcc, mkDerivedTyConOcc,
455 mkClassTyConOcc, mkClassDataConOcc, mkDictOcc, mkIPOcc,
456 mkSpecOcc, mkForeignExportOcc, mkGenOcc1, mkGenOcc2,
457 mkDataTOcc, mkDataCOcc, mkDataConWorkerOcc, mkNewTyCoOcc,
458 mkInstTyCoOcc, mkEqPredCoOcc,
459 mkCon2TagOcc, mkTag2ConOcc, mkMaxTagOcc,
460 mkVectOcc, mkVectTyConOcc, mkVectDataConOcc, mkVectIsoOcc,
461 mkPArrayTyConOcc, mkPArrayDataConOcc, mkPReprTyConOcc, mkPADFunOcc
462 :: OccName -> OccName
464 -- These derived variables have a prefix that no Haskell value could have
465 mkDataConWrapperOcc = mk_simple_deriv varName "$W"
466 mkWorkerOcc = mk_simple_deriv varName "$w"
467 mkDefaultMethodOcc = mk_simple_deriv varName "$dm"
468 mkDerivedTyConOcc = mk_simple_deriv tcName ":" -- The : prefix makes sure it classifies
469 mkClassTyConOcc = mk_simple_deriv tcName ":T" -- as a tycon/datacon
470 mkClassDataConOcc = mk_simple_deriv dataName ":D" -- We go straight to the "real" data con
471 -- for datacons from classes
472 mkDictOcc = mk_simple_deriv varName "$d"
473 mkIPOcc = mk_simple_deriv varName "$i"
474 mkSpecOcc = mk_simple_deriv varName "$s"
475 mkForeignExportOcc = mk_simple_deriv varName "$f"
476 mkNewTyCoOcc = mk_simple_deriv tcName ":Co"
477 mkInstTyCoOcc = mk_simple_deriv tcName ":CoF" -- derived from rep ty
478 mkEqPredCoOcc = mk_simple_deriv tcName "$co"
480 -- used in derived instances
481 mkCon2TagOcc = mk_simple_deriv varName "$con2tag_"
482 mkTag2ConOcc = mk_simple_deriv varName "$tag2con_"
483 mkMaxTagOcc = mk_simple_deriv varName "$maxtag_"
485 -- Generic derivable classes
486 mkGenOcc1 = mk_simple_deriv varName "$gfrom"
487 mkGenOcc2 = mk_simple_deriv varName "$gto"
489 -- data T = MkT ... deriving( Data ) needs defintions for
490 -- $tT :: Data.Generics.Basics.DataType
491 -- $cMkT :: Data.Generics.Basics.Constr
492 mkDataTOcc = mk_simple_deriv varName "$t"
493 mkDataCOcc = mk_simple_deriv varName "$c"
496 mkVectOcc = mk_simple_deriv varName "$v_"
497 mkVectTyConOcc = mk_simple_deriv tcName ":V_"
498 mkVectDataConOcc = mk_simple_deriv dataName ":VD_"
499 mkVectIsoOcc = mk_simple_deriv varName "$VI_"
500 mkPArrayTyConOcc = mk_simple_deriv tcName ":VP_"
501 mkPArrayDataConOcc = mk_simple_deriv dataName ":VPD_"
502 mkPReprTyConOcc = mk_simple_deriv tcName ":VR_"
503 mkPADFunOcc = mk_simple_deriv varName "$PA_"
505 mk_simple_deriv :: NameSpace -> String -> OccName -> OccName
506 mk_simple_deriv sp px occ = mk_deriv sp px (occNameString occ)
508 -- Data constructor workers are made by setting the name space
509 -- of the data constructor OccName (which should be a DataName)
511 mkDataConWorkerOcc datacon_occ = setOccNameSpace varName datacon_occ
515 mkSuperDictSelOcc :: Int -- Index of superclass, eg 3
516 -> OccName -- Class, eg "Ord"
517 -> OccName -- eg "$p3Ord"
518 mkSuperDictSelOcc index cls_occ
519 = mk_deriv varName "$p" (show index ++ occNameString cls_occ)
521 mkLocalOcc :: Unique -- Unique
522 -> OccName -- Local name (e.g. "sat")
523 -> OccName -- Nice unique version ("$L23sat")
525 = mk_deriv varName ("$L" ++ show uniq) (occNameString occ)
526 -- The Unique might print with characters
527 -- that need encoding (e.g. 'z'!)
530 Derive a name for the representation type constructor of a data/newtype
534 mkInstTyTcOcc :: Int -- Index
535 -> OccName -- Family name (e.g. "Map")
536 -> OccName -- Nice unique version (":R23Map")
537 mkInstTyTcOcc index occ
538 = mk_deriv tcName (":R" ++ show index) (occNameString occ)
542 mkDFunOcc :: String -- Typically the class and type glommed together e.g. "OrdMaybe"
543 -- Only used in debug mode, for extra clarity
544 -> Bool -- True <=> hs-boot instance dfun
545 -> Int -- Unique index
546 -> OccName -- "$f3OrdMaybe"
548 -- In hs-boot files we make dict funs like $fx7ClsTy, which get bound to the real
549 -- thing when we compile the mother module. Reason: we don't know exactly
550 -- what the mother module will call it.
552 mkDFunOcc info_str is_boot index
553 = mk_deriv VarName prefix string
555 prefix | is_boot = "$fx"
557 string | opt_PprStyle_Debug = show index ++ info_str
558 | otherwise = show index
561 We used to add a '$m' to indicate a method, but that gives rise to bad
562 error messages from the type checker when we print the function name or pattern
563 of an instance-decl binding. Why? Because the binding is zapped
564 to use the method name in place of the selector name.
565 (See TcClassDcl.tcMethodBind)
567 The way it is now, -ddump-xx output may look confusing, but
568 you can always say -dppr-debug to get the uniques.
570 However, we *do* have to zap the first character to be lower case,
571 because overloaded constructors (blarg) generate methods too.
572 And convert to VarName space
574 e.g. a call to constructor MkFoo where
575 data (Ord a) => Foo a = MkFoo a
577 If this is necessary, we do it by prefixing '$m'. These
578 guys never show up in error messages. What a hack.
581 mkMethodOcc :: OccName -> OccName
582 mkMethodOcc occ@(OccName VarName _) = occ
583 mkMethodOcc occ = mk_simple_deriv varName "$m" occ
587 %************************************************************************
589 \subsection{Tidying them up}
591 %************************************************************************
593 Before we print chunks of code we like to rename it so that
594 we don't have to print lots of silly uniques in it. But we mustn't
595 accidentally introduce name clashes! So the idea is that we leave the
596 OccName alone unless it accidentally clashes with one that is already
597 in scope; if so, we tack on '1' at the end and try again, then '2', and
598 so on till we find a unique one.
600 There's a wrinkle for operators. Consider '>>='. We can't use '>>=1'
601 because that isn't a single lexeme. So we encode it to 'lle' and *then*
602 tack on the '1', if necessary.
605 type TidyOccEnv = OccEnv Int -- The in-scope OccNames
606 -- Range gives a plausible starting point for new guesses
608 emptyTidyOccEnv :: TidyOccEnv
609 emptyTidyOccEnv = emptyOccEnv
611 initTidyOccEnv :: [OccName] -> TidyOccEnv -- Initialise with names to avoid!
612 initTidyOccEnv = foldl (\env occ -> extendOccEnv env occ 1) emptyTidyOccEnv
614 tidyOccName :: TidyOccEnv -> OccName -> (TidyOccEnv, OccName)
616 tidyOccName in_scope occ@(OccName occ_sp fs)
617 = case lookupOccEnv in_scope occ of
618 Nothing -> -- Not already used: make it used
619 (extendOccEnv in_scope occ 1, occ)
621 Just n -> -- Already used: make a new guess,
622 -- change the guess base, and try again
623 tidyOccName (extendOccEnv in_scope occ (n+1))
624 (mkOccName occ_sp (unpackFS fs ++ show n))
627 %************************************************************************
629 Stuff for dealing with tuples
631 %************************************************************************
634 mkTupleOcc :: NameSpace -> Boxity -> Arity -> OccName
635 mkTupleOcc ns bx ar = OccName ns (mkFastString str)
637 -- no need to cache these, the caching is done in the caller
638 -- (TysWiredIn.mk_tuple)
640 Boxed -> '(' : commas ++ ")"
641 Unboxed -> '(' : '#' : commas ++ "#)"
643 commas = take (ar-1) (repeat ',')
645 isTupleOcc_maybe :: OccName -> Maybe (NameSpace, Boxity, Arity)
646 -- Tuples are special, because there are so many of them!
647 isTupleOcc_maybe (OccName ns fs)
648 = case unpackFS fs of
649 '(':'#':',':rest -> Just (ns, Unboxed, 2 + count_commas rest)
650 '(':',':rest -> Just (ns, Boxed, 2 + count_commas rest)
653 count_commas (',':rest) = 1 + count_commas rest
657 %************************************************************************
659 \subsection{Lexical categories}
661 %************************************************************************
663 These functions test strings to see if they fit the lexical categories
664 defined in the Haskell report.
667 isLexCon, isLexVar, isLexId, isLexSym :: FastString -> Bool
668 isLexConId, isLexConSym, isLexVarId, isLexVarSym :: FastString -> Bool
670 isLexCon cs = isLexConId cs || isLexConSym cs
671 isLexVar cs = isLexVarId cs || isLexVarSym cs
673 isLexId cs = isLexConId cs || isLexVarId cs
674 isLexSym cs = isLexConSym cs || isLexVarSym cs
678 isLexConId cs -- Prefix type or data constructors
679 | nullFS cs = False -- e.g. "Foo", "[]", "(,)"
680 | cs == (fsLit "[]") = True
681 | otherwise = startsConId (headFS cs)
683 isLexVarId cs -- Ordinary prefix identifiers
684 | nullFS cs = False -- e.g. "x", "_x"
685 | otherwise = startsVarId (headFS cs)
687 isLexConSym cs -- Infix type or data constructors
688 | nullFS cs = False -- e.g. ":-:", ":", "->"
689 | cs == (fsLit "->") = True
690 | otherwise = startsConSym (headFS cs)
692 isLexVarSym cs -- Infix identifiers
693 | nullFS cs = False -- e.g. "+"
694 | otherwise = startsVarSym (headFS cs)
697 startsVarSym, startsVarId, startsConSym, startsConId :: Char -> Bool
698 startsVarSym c = isSymbolASCII c || (ord c > 0x7f && isSymbol c) -- Infix Ids
699 startsConSym c = c == ':' -- Infix data constructors
700 startsVarId c = isLower c || c == '_' -- Ordinary Ids
701 startsConId c = isUpper c || c == '(' -- Ordinary type constructors and data constructors
703 isSymbolASCII :: Char -> Bool
704 isSymbolASCII c = c `elem` "!#$%&*+./<=>?@\\^|~-"
707 %************************************************************************
710 Here rather than BinIface because OccName is abstract
712 %************************************************************************
715 instance Binary NameSpace where
718 put_ bh DataName = do
722 put_ bh TcClsName = do
727 0 -> do return VarName
728 1 -> do return DataName
729 2 -> do return TvName
730 _ -> do return TcClsName
732 instance Binary OccName where
733 put_ bh (OccName aa ab) = do
739 return (OccName aa ab)