2 % (c) The University of Glasgow 2006
3 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
8 -- * The NameSpace type; abstact
9 NameSpace, tcName, clsName, tcClsName, dataName, varName,
13 pprNameSpace, pprNonVarNameSpace, pprNameSpaceBrief,
16 OccName, -- Abstract, instance of Outputable
20 mkOccName, mkOccNameFS,
27 -- ** Derived OccNames
28 mkDataConWrapperOcc, mkWorkerOcc, mkDefaultMethodOcc,
29 mkDerivedTyConOcc, mkNewTyCoOcc,
30 mkClassTyConOcc, mkClassDataConOcc, mkDictOcc, mkIPOcc,
31 mkSpecOcc, mkForeignExportOcc, mkGenOcc1, mkGenOcc2,
32 mkDataTOcc, mkDataCOcc, mkDataConWorkerOcc,
33 mkSuperDictSelOcc, mkLocalOcc, mkMethodOcc, mkInstTyTcOcc,
34 mkInstTyCoOcc, mkEqPredCoOcc,
35 mkVectOcc, mkVectTyConOcc, mkVectDataConOcc, mkVectIsoOcc,
36 mkPArrayTyConOcc, mkPArrayDataConOcc,
41 occNameFS, occNameString, occNameSpace,
43 isVarOcc, isTvOcc, isTcOcc, isDataOcc, isDataSymOcc, isSymOcc, isValOcc,
44 parenSymOcc, reportIfUnused, isTcClsName, isVarName,
49 OccEnv, emptyOccEnv, unitOccEnv, extendOccEnv, mapOccEnv,
50 lookupOccEnv, mkOccEnv, mkOccEnv_C, extendOccEnvList, elemOccEnv,
51 occEnvElts, foldOccEnv, plusOccEnv, plusOccEnv_C, extendOccEnv_C,
52 filterOccEnv, delListFromOccEnv, delFromOccEnv,
55 OccSet, emptyOccSet, unitOccSet, mkOccSet, extendOccSet,
57 unionOccSets, unionManyOccSets, minusOccSet, elemOccSet, occSetElts,
58 foldOccSet, isEmptyOccSet, intersectOccSet, intersectsOccSet,
61 TidyOccEnv, emptyTidyOccEnv, tidyOccName, initTidyOccEnv,
63 -- The basic form of names
64 isLexCon, isLexVar, isLexId, isLexSym,
65 isLexConId, isLexConSym, isLexVarId, isLexVarSym,
66 startsVarSym, startsVarId, startsConSym, startsConId
69 #include "HsVersions.h"
85 -- Unicode TODO: put isSymbol in libcompat
86 #if !defined(__GLASGOW_HASKELL__) || __GLASGOW_HASKELL__ > 604
88 isSymbol = const False
93 %************************************************************************
95 \subsection{Name space}
97 %************************************************************************
100 data NameSpace = VarName -- Variables, including "real" data constructors
101 | DataName -- "Source" data constructors
102 | TvName -- Type variables
103 | TcClsName -- Type constructors and classes; Haskell has them
104 -- in the same name space for now.
106 {-! derive: Binary !-}
108 -- Note [Data Constructors]
109 -- see also: Note [Data Constructor Naming] in DataCon.lhs
111 -- "Source" data constructors are the data constructors mentioned
112 -- in Haskell source code
114 -- "Real" data constructors are the data constructors of the
115 -- representation type, which may not be the same as the source
119 -- data T = T !(Int,Int)
121 -- The source datacon has type (Int,Int) -> T
122 -- The real datacon has type Int -> Int -> T
123 -- GHC chooses a representation based on the strictness etc.
125 tcName, clsName, tcClsName :: NameSpace
126 dataName, srcDataName :: NameSpace
127 tvName, varName :: NameSpace
129 -- Though type constructors and classes are in the same name space now,
130 -- the NameSpace type is abstract, so we can easily separate them later
131 tcName = TcClsName -- Type constructors
132 clsName = TcClsName -- Classes
133 tcClsName = TcClsName -- Not sure which!
136 srcDataName = DataName -- Haskell-source data constructors should be
137 -- in the Data name space
142 isTcClsName :: NameSpace -> Bool
143 isTcClsName TcClsName = True
144 isTcClsName _ = False
146 isVarName :: NameSpace -> Bool -- Variables or type variables, but not constructors
147 isVarName TvName = True
148 isVarName VarName = True
151 pprNameSpace :: NameSpace -> SDoc
152 pprNameSpace DataName = ptext SLIT("data constructor")
153 pprNameSpace VarName = ptext SLIT("variable")
154 pprNameSpace TvName = ptext SLIT("type variable")
155 pprNameSpace TcClsName = ptext SLIT("type constructor or class")
157 pprNonVarNameSpace :: NameSpace -> SDoc
158 pprNonVarNameSpace VarName = empty
159 pprNonVarNameSpace ns = pprNameSpace ns
161 pprNameSpaceBrief :: NameSpace -> SDoc
162 pprNameSpaceBrief DataName = char 'd'
163 pprNameSpaceBrief VarName = char 'v'
164 pprNameSpaceBrief TvName = ptext SLIT("tv")
165 pprNameSpaceBrief TcClsName = ptext SLIT("tc")
169 %************************************************************************
171 \subsection[Name-pieces-datatypes]{The @OccName@ datatypes}
173 %************************************************************************
176 data OccName = OccName
177 { occNameSpace :: !NameSpace
178 , occNameFS :: !FastString
184 instance Eq OccName where
185 (OccName sp1 s1) == (OccName sp2 s2) = s1 == s2 && sp1 == sp2
187 instance Ord OccName where
188 -- Compares lexicographically, *not* by Unique of the string
189 compare (OccName sp1 s1) (OccName sp2 s2)
190 = (s1 `compare` s2) `thenCmp` (sp1 `compare` sp2)
194 %************************************************************************
196 \subsection{Printing}
198 %************************************************************************
201 instance Outputable OccName where
204 pprOccName :: OccName -> SDoc
205 pprOccName (OccName sp occ)
206 = getPprStyle $ \ sty ->
208 then ftext (zEncodeFS occ)
209 else ftext occ <> if debugStyle sty
210 then braces (pprNameSpaceBrief sp)
215 %************************************************************************
217 \subsection{Construction}
219 %************************************************************************
222 mkOccName :: NameSpace -> String -> OccName
223 mkOccName occ_sp str = OccName occ_sp (mkFastString str)
225 mkOccNameFS :: NameSpace -> FastString -> OccName
226 mkOccNameFS occ_sp fs = OccName occ_sp fs
228 mkVarOcc :: String -> OccName
229 mkVarOcc s = mkOccName varName s
231 mkVarOccFS :: FastString -> OccName
232 mkVarOccFS fs = mkOccNameFS varName fs
234 mkTyVarOcc :: FastString -> OccName
235 mkTyVarOcc fs = mkOccNameFS tvName fs
239 %************************************************************************
243 %************************************************************************
245 OccEnvs are used mainly for the envts in ModIfaces.
247 They are efficient, because FastStrings have unique Int# keys. We assume
248 this key is less than 2^24, so we can make a Unique using
249 mkUnique ns key :: Unique
250 where 'ns' is a Char reprsenting the name space. This in turn makes it
251 easy to build an OccEnv.
254 instance Uniquable OccName where
255 getUnique (OccName ns fs)
256 = mkUnique char (iBox (uniqueOfFS fs))
257 where -- See notes above about this getUnique function
264 newtype OccEnv a = A (UniqFM a)
266 emptyOccEnv :: OccEnv a
267 unitOccEnv :: OccName -> a -> OccEnv a
268 extendOccEnv :: OccEnv a -> OccName -> a -> OccEnv a
269 extendOccEnvList :: OccEnv a -> [(OccName, a)] -> OccEnv a
270 lookupOccEnv :: OccEnv a -> OccName -> Maybe a
271 mkOccEnv :: [(OccName,a)] -> OccEnv a
272 mkOccEnv_C :: (a -> a -> a) -> [(OccName,a)] -> OccEnv a
273 elemOccEnv :: OccName -> OccEnv a -> Bool
274 foldOccEnv :: (a -> b -> b) -> b -> OccEnv a -> b
275 occEnvElts :: OccEnv a -> [a]
276 extendOccEnv_C :: (a->a->a) -> OccEnv a -> OccName -> a -> OccEnv a
277 plusOccEnv :: OccEnv a -> OccEnv a -> OccEnv a
278 plusOccEnv_C :: (a->a->a) -> OccEnv a -> OccEnv a -> OccEnv a
279 mapOccEnv :: (a->b) -> OccEnv a -> OccEnv b
280 delFromOccEnv :: OccEnv a -> OccName -> OccEnv a
281 delListFromOccEnv :: OccEnv a -> [OccName] -> OccEnv a
282 filterOccEnv :: (elt -> Bool) -> OccEnv elt -> OccEnv elt
284 emptyOccEnv = A emptyUFM
285 unitOccEnv x y = A $ unitUFM x y
286 extendOccEnv (A x) y z = A $ addToUFM x y z
287 extendOccEnvList (A x) l = A $ addListToUFM x l
288 lookupOccEnv (A x) y = lookupUFM x y
289 mkOccEnv l = A $ listToUFM l
290 elemOccEnv x (A y) = elemUFM x y
291 foldOccEnv a b (A c) = foldUFM a b c
292 occEnvElts (A x) = eltsUFM x
293 plusOccEnv (A x) (A y) = A $ plusUFM x y
294 plusOccEnv_C f (A x) (A y) = A $ plusUFM_C f x y
295 extendOccEnv_C f (A x) y z = A $ addToUFM_C f x y z
296 mapOccEnv f (A x) = A $ mapUFM f x
297 mkOccEnv_C comb l = A $ addListToUFM_C comb emptyUFM l
298 delFromOccEnv (A x) y = A $ delFromUFM x y
299 delListFromOccEnv (A x) y = A $ delListFromUFM x y
300 filterOccEnv x (A y) = A $ filterUFM x y
302 instance Outputable a => Outputable (OccEnv a) where
305 type OccSet = UniqSet OccName
307 emptyOccSet :: OccSet
308 unitOccSet :: OccName -> OccSet
309 mkOccSet :: [OccName] -> OccSet
310 extendOccSet :: OccSet -> OccName -> OccSet
311 extendOccSetList :: OccSet -> [OccName] -> OccSet
312 unionOccSets :: OccSet -> OccSet -> OccSet
313 unionManyOccSets :: [OccSet] -> OccSet
314 minusOccSet :: OccSet -> OccSet -> OccSet
315 elemOccSet :: OccName -> OccSet -> Bool
316 occSetElts :: OccSet -> [OccName]
317 foldOccSet :: (OccName -> b -> b) -> b -> OccSet -> b
318 isEmptyOccSet :: OccSet -> Bool
319 intersectOccSet :: OccSet -> OccSet -> OccSet
320 intersectsOccSet :: OccSet -> OccSet -> Bool
322 emptyOccSet = emptyUniqSet
323 unitOccSet = unitUniqSet
325 extendOccSet = addOneToUniqSet
326 extendOccSetList = addListToUniqSet
327 unionOccSets = unionUniqSets
328 unionManyOccSets = unionManyUniqSets
329 minusOccSet = minusUniqSet
330 elemOccSet = elementOfUniqSet
331 occSetElts = uniqSetToList
332 foldOccSet = foldUniqSet
333 isEmptyOccSet = isEmptyUniqSet
334 intersectOccSet = intersectUniqSets
335 intersectsOccSet s1 s2 = not (isEmptyOccSet (s1 `intersectOccSet` s2))
339 %************************************************************************
341 \subsection{Predicates and taking them apart}
343 %************************************************************************
346 occNameString :: OccName -> String
347 occNameString (OccName _ s) = unpackFS s
349 setOccNameSpace :: NameSpace -> OccName -> OccName
350 setOccNameSpace sp (OccName _ occ) = OccName sp occ
352 isVarOcc, isTvOcc, isDataSymOcc, isSymOcc, isTcOcc, isValOcc, isDataOcc :: OccName -> Bool
354 isVarOcc (OccName VarName _) = True
357 isTvOcc (OccName TvName _) = True
360 isTcOcc (OccName TcClsName _) = True
363 isValOcc (OccName VarName _) = True
364 isValOcc (OccName DataName _) = True
367 -- Data constructor operator (starts with ':', or '[]')
368 -- Pretty inefficient!
369 isDataSymOcc (OccName DataName s) = isLexConSym s
370 isDataSymOcc (OccName VarName s)
371 | isLexConSym s = pprPanic "isDataSymOcc: check me" (ppr s)
372 -- Jan06: I don't think this should happen
373 isDataSymOcc _ = False
375 isDataOcc (OccName DataName _) = True
376 isDataOcc (OccName VarName s)
377 | isLexCon s = pprPanic "isDataOcc: check me" (ppr s)
378 -- Jan06: I don't think this should happen
381 -- Any operator (data constructor or variable)
382 -- Pretty inefficient!
383 isSymOcc (OccName DataName s) = isLexConSym s
384 isSymOcc (OccName TcClsName s) = isLexConSym s
385 isSymOcc (OccName VarName s) = isLexSym s
386 isSymOcc (OccName TvName s) = isLexSym s
388 parenSymOcc :: OccName -> SDoc -> SDoc
389 -- Wrap parens around an operator
390 parenSymOcc occ doc | isSymOcc occ = parens doc
396 reportIfUnused :: OccName -> Bool
397 -- Haskell 98 encourages compilers to suppress warnings about
398 -- unused names in a pattern if they start with "_".
399 reportIfUnused occ = case occNameString occ of
405 %************************************************************************
407 \subsection{Making system names}
409 %************************************************************************
411 Here's our convention for splitting up the interface file name space:
413 d... dictionary identifiers
414 (local variables, so no name-clash worries)
416 $f... dict-fun identifiers (from inst decls)
417 $dm... default methods
418 $p... superclass selectors
420 :T... compiler-generated tycons for dictionaries
421 :D... ...ditto data cons
422 :Co... ...ditto coercions
423 $sf.. specialised version of f
425 in encoded form these appear as Zdfxxx etc
427 :... keywords (export:, letrec: etc.)
428 --- I THINK THIS IS WRONG!
430 This knowledge is encoded in the following functions.
433 @mk_deriv@ generates an @OccName@ from the prefix and a string.
434 NB: The string must already be encoded!
437 mk_deriv :: NameSpace
438 -> String -- Distinguishes one sort of derived name from another
442 mk_deriv occ_sp sys_prefix str = mkOccName occ_sp (sys_prefix ++ str)
446 mkDataConWrapperOcc, mkWorkerOcc, mkDefaultMethodOcc, mkDerivedTyConOcc,
447 mkClassTyConOcc, mkClassDataConOcc, mkDictOcc, mkIPOcc,
448 mkSpecOcc, mkForeignExportOcc, mkGenOcc1, mkGenOcc2,
449 mkDataTOcc, mkDataCOcc, mkDataConWorkerOcc, mkNewTyCoOcc,
450 mkInstTyCoOcc, mkEqPredCoOcc,
451 mkVectOcc, mkVectTyConOcc, mkVectDataConOcc, mkVectIsoOcc,
452 mkPArrayTyConOcc, mkPArrayDataConOcc, mkPReprTyConOcc, mkPADFunOcc
453 :: OccName -> OccName
455 -- These derived variables have a prefix that no Haskell value could have
456 mkDataConWrapperOcc = mk_simple_deriv varName "$W"
457 mkWorkerOcc = mk_simple_deriv varName "$w"
458 mkDefaultMethodOcc = mk_simple_deriv varName "$dm"
459 mkDerivedTyConOcc = mk_simple_deriv tcName ":" -- The : prefix makes sure it classifies
460 mkClassTyConOcc = mk_simple_deriv tcName ":T" -- as a tycon/datacon
461 mkClassDataConOcc = mk_simple_deriv dataName ":D" -- We go straight to the "real" data con
462 -- for datacons from classes
463 mkDictOcc = mk_simple_deriv varName "$d"
464 mkIPOcc = mk_simple_deriv varName "$i"
465 mkSpecOcc = mk_simple_deriv varName "$s"
466 mkForeignExportOcc = mk_simple_deriv varName "$f"
467 mkNewTyCoOcc = mk_simple_deriv tcName ":Co"
468 mkInstTyCoOcc = mk_simple_deriv tcName ":CoF" -- derived from rep ty
469 mkEqPredCoOcc = mk_simple_deriv tcName "$co"
471 -- Generic derivable classes
472 mkGenOcc1 = mk_simple_deriv varName "$gfrom"
473 mkGenOcc2 = mk_simple_deriv varName "$gto"
475 -- data T = MkT ... deriving( Data ) needs defintions for
476 -- $tT :: Data.Generics.Basics.DataType
477 -- $cMkT :: Data.Generics.Basics.Constr
478 mkDataTOcc = mk_simple_deriv varName "$t"
479 mkDataCOcc = mk_simple_deriv varName "$c"
482 mkVectOcc = mk_simple_deriv varName "$v_"
483 mkVectTyConOcc = mk_simple_deriv tcName ":V_"
484 mkVectDataConOcc = mk_simple_deriv dataName ":VD_"
485 mkVectIsoOcc = mk_simple_deriv varName "$VI_"
486 mkPArrayTyConOcc = mk_simple_deriv tcName ":VP_"
487 mkPArrayDataConOcc = mk_simple_deriv dataName ":VPD_"
488 mkPReprTyConOcc = mk_simple_deriv tcName ":VR_"
489 mkPADFunOcc = mk_simple_deriv varName "$PA_"
491 mk_simple_deriv :: NameSpace -> String -> OccName -> OccName
492 mk_simple_deriv sp px occ = mk_deriv sp px (occNameString occ)
494 -- Data constructor workers are made by setting the name space
495 -- of the data constructor OccName (which should be a DataName)
497 mkDataConWorkerOcc datacon_occ = setOccNameSpace varName datacon_occ
501 mkSuperDictSelOcc :: Int -- Index of superclass, eg 3
502 -> OccName -- Class, eg "Ord"
503 -> OccName -- eg "$p3Ord"
504 mkSuperDictSelOcc index cls_occ
505 = mk_deriv varName "$p" (show index ++ occNameString cls_occ)
507 mkLocalOcc :: Unique -- Unique
508 -> OccName -- Local name (e.g. "sat")
509 -> OccName -- Nice unique version ("$L23sat")
511 = mk_deriv varName ("$L" ++ show uniq) (occNameString occ)
512 -- The Unique might print with characters
513 -- that need encoding (e.g. 'z'!)
516 Derive a name for the representation type constructor of a data/newtype
520 mkInstTyTcOcc :: Int -- Index
521 -> OccName -- Family name (e.g. "Map")
522 -> OccName -- Nice unique version (":R23Map")
523 mkInstTyTcOcc index occ
524 = mk_deriv tcName (":R" ++ show index) (occNameString occ)
528 mkDFunOcc :: String -- Typically the class and type glommed together e.g. "OrdMaybe"
529 -- Only used in debug mode, for extra clarity
530 -> Bool -- True <=> hs-boot instance dfun
531 -> Int -- Unique index
532 -> OccName -- "$f3OrdMaybe"
534 -- In hs-boot files we make dict funs like $fx7ClsTy, which get bound to the real
535 -- thing when we compile the mother module. Reason: we don't know exactly
536 -- what the mother module will call it.
538 mkDFunOcc info_str is_boot index
539 = mk_deriv VarName prefix string
541 prefix | is_boot = "$fx"
543 string | opt_PprStyle_Debug = show index ++ info_str
544 | otherwise = show index
547 We used to add a '$m' to indicate a method, but that gives rise to bad
548 error messages from the type checker when we print the function name or pattern
549 of an instance-decl binding. Why? Because the binding is zapped
550 to use the method name in place of the selector name.
551 (See TcClassDcl.tcMethodBind)
553 The way it is now, -ddump-xx output may look confusing, but
554 you can always say -dppr-debug to get the uniques.
556 However, we *do* have to zap the first character to be lower case,
557 because overloaded constructors (blarg) generate methods too.
558 And convert to VarName space
560 e.g. a call to constructor MkFoo where
561 data (Ord a) => Foo a = MkFoo a
563 If this is necessary, we do it by prefixing '$m'. These
564 guys never show up in error messages. What a hack.
567 mkMethodOcc :: OccName -> OccName
568 mkMethodOcc occ@(OccName VarName _) = occ
569 mkMethodOcc occ = mk_simple_deriv varName "$m" occ
573 %************************************************************************
575 \subsection{Tidying them up}
577 %************************************************************************
579 Before we print chunks of code we like to rename it so that
580 we don't have to print lots of silly uniques in it. But we mustn't
581 accidentally introduce name clashes! So the idea is that we leave the
582 OccName alone unless it accidentally clashes with one that is already
583 in scope; if so, we tack on '1' at the end and try again, then '2', and
584 so on till we find a unique one.
586 There's a wrinkle for operators. Consider '>>='. We can't use '>>=1'
587 because that isn't a single lexeme. So we encode it to 'lle' and *then*
588 tack on the '1', if necessary.
591 type TidyOccEnv = OccEnv Int -- The in-scope OccNames
592 -- Range gives a plausible starting point for new guesses
594 emptyTidyOccEnv :: TidyOccEnv
595 emptyTidyOccEnv = emptyOccEnv
597 initTidyOccEnv :: [OccName] -> TidyOccEnv -- Initialise with names to avoid!
598 initTidyOccEnv = foldl (\env occ -> extendOccEnv env occ 1) emptyTidyOccEnv
600 tidyOccName :: TidyOccEnv -> OccName -> (TidyOccEnv, OccName)
602 tidyOccName in_scope occ@(OccName occ_sp fs)
603 = case lookupOccEnv in_scope occ of
604 Nothing -> -- Not already used: make it used
605 (extendOccEnv in_scope occ 1, occ)
607 Just n -> -- Already used: make a new guess,
608 -- change the guess base, and try again
609 tidyOccName (extendOccEnv in_scope occ (n+1))
610 (mkOccName occ_sp (unpackFS fs ++ show n))
613 %************************************************************************
615 Stuff for dealing with tuples
617 %************************************************************************
620 mkTupleOcc :: NameSpace -> Boxity -> Arity -> OccName
621 mkTupleOcc ns bx ar = OccName ns (mkFastString str)
623 -- no need to cache these, the caching is done in the caller
624 -- (TysWiredIn.mk_tuple)
626 Boxed -> '(' : commas ++ ")"
627 Unboxed -> '(' : '#' : commas ++ "#)"
629 commas = take (ar-1) (repeat ',')
631 isTupleOcc_maybe :: OccName -> Maybe (NameSpace, Boxity, Arity)
632 -- Tuples are special, because there are so many of them!
633 isTupleOcc_maybe (OccName ns fs)
634 = case unpackFS fs of
635 '(':'#':',':rest -> Just (ns, Unboxed, 2 + count_commas rest)
636 '(':',':rest -> Just (ns, Boxed, 2 + count_commas rest)
639 count_commas (',':rest) = 1 + count_commas rest
643 %************************************************************************
645 \subsection{Lexical categories}
647 %************************************************************************
649 These functions test strings to see if they fit the lexical categories
650 defined in the Haskell report.
653 isLexCon, isLexVar, isLexId, isLexSym :: FastString -> Bool
654 isLexConId, isLexConSym, isLexVarId, isLexVarSym :: FastString -> Bool
656 isLexCon cs = isLexConId cs || isLexConSym cs
657 isLexVar cs = isLexVarId cs || isLexVarSym cs
659 isLexId cs = isLexConId cs || isLexVarId cs
660 isLexSym cs = isLexConSym cs || isLexVarSym cs
664 isLexConId cs -- Prefix type or data constructors
665 | nullFS cs = False -- e.g. "Foo", "[]", "(,)"
666 | cs == FSLIT("[]") = True
667 | otherwise = startsConId (headFS cs)
669 isLexVarId cs -- Ordinary prefix identifiers
670 | nullFS cs = False -- e.g. "x", "_x"
671 | otherwise = startsVarId (headFS cs)
673 isLexConSym cs -- Infix type or data constructors
674 | nullFS cs = False -- e.g. ":-:", ":", "->"
675 | cs == FSLIT("->") = True
676 | otherwise = startsConSym (headFS cs)
678 isLexVarSym cs -- Infix identifiers
679 | nullFS cs = False -- e.g. "+"
680 | otherwise = startsVarSym (headFS cs)
683 startsVarSym, startsVarId, startsConSym, startsConId :: Char -> Bool
684 startsVarSym c = isSymbolASCII c || (ord c > 0x7f && isSymbol c) -- Infix Ids
685 startsConSym c = c == ':' -- Infix data constructors
686 startsVarId c = isLower c || c == '_' -- Ordinary Ids
687 startsConId c = isUpper c || c == '(' -- Ordinary type constructors and data constructors
689 isSymbolASCII :: Char -> Bool
690 isSymbolASCII c = c `elem` "!#$%&*+./<=>?@\\^|~-"
693 %************************************************************************
696 Here rather than BinIface because OccName is abstract
698 %************************************************************************
701 instance Binary NameSpace where
704 put_ bh DataName = do
708 put_ bh TcClsName = do
713 0 -> do return VarName
714 1 -> do return DataName
715 2 -> do return TvName
716 _ -> do return TcClsName
718 instance Binary OccName where
719 put_ bh (OccName aa ab) = do
725 return (OccName aa ab)