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
83 -- Unicode TODO: put isSymbol in libcompat
84 #if !defined(__GLASGOW_HASKELL__) || __GLASGOW_HASKELL__ > 604
87 isSymbol = const False
92 %************************************************************************
94 \subsection{Name space}
96 %************************************************************************
99 data NameSpace = VarName -- Variables, including "real" data constructors
100 | DataName -- "Source" data constructors
101 | TvName -- Type variables
102 | TcClsName -- Type constructors and classes; Haskell has them
103 -- in the same name space for now.
105 {-! derive: Binary !-}
107 -- Note [Data Constructors]
108 -- see also: Note [Data Constructor Naming] in DataCon.lhs
110 -- "Source" data constructors are the data constructors mentioned
111 -- in Haskell source code
113 -- "Real" data constructors are the data constructors of the
114 -- representation type, which may not be the same as the source
118 -- data T = T !(Int,Int)
120 -- The source datacon has type (Int,Int) -> T
121 -- The real datacon has type Int -> Int -> T
122 -- GHC chooses a representation based on the strictness etc.
124 tcName, clsName, tcClsName :: NameSpace
125 dataName, srcDataName :: NameSpace
126 tvName, varName :: NameSpace
128 -- Though type constructors and classes are in the same name space now,
129 -- the NameSpace type is abstract, so we can easily separate them later
130 tcName = TcClsName -- Type constructors
131 clsName = TcClsName -- Classes
132 tcClsName = TcClsName -- Not sure which!
135 srcDataName = DataName -- Haskell-source data constructors should be
136 -- in the Data name space
141 isTcClsName :: NameSpace -> Bool
142 isTcClsName TcClsName = True
143 isTcClsName _ = False
145 isVarName :: NameSpace -> Bool -- Variables or type variables, but not constructors
146 isVarName TvName = True
147 isVarName VarName = True
150 pprNameSpace :: NameSpace -> SDoc
151 pprNameSpace DataName = ptext (sLit "data constructor")
152 pprNameSpace VarName = ptext (sLit "variable")
153 pprNameSpace TvName = ptext (sLit "type variable")
154 pprNameSpace TcClsName = ptext (sLit "type constructor or class")
156 pprNonVarNameSpace :: NameSpace -> SDoc
157 pprNonVarNameSpace VarName = empty
158 pprNonVarNameSpace ns = pprNameSpace ns
160 pprNameSpaceBrief :: NameSpace -> SDoc
161 pprNameSpaceBrief DataName = char 'd'
162 pprNameSpaceBrief VarName = char 'v'
163 pprNameSpaceBrief TvName = ptext (sLit "tv")
164 pprNameSpaceBrief TcClsName = ptext (sLit "tc")
168 %************************************************************************
170 \subsection[Name-pieces-datatypes]{The @OccName@ datatypes}
172 %************************************************************************
175 data OccName = OccName
176 { occNameSpace :: !NameSpace
177 , occNameFS :: !FastString
183 instance Eq OccName where
184 (OccName sp1 s1) == (OccName sp2 s2) = s1 == s2 && sp1 == sp2
186 instance Ord OccName where
187 -- Compares lexicographically, *not* by Unique of the string
188 compare (OccName sp1 s1) (OccName sp2 s2)
189 = (s1 `compare` s2) `thenCmp` (sp1 `compare` sp2)
193 %************************************************************************
195 \subsection{Printing}
197 %************************************************************************
200 instance Outputable OccName where
203 pprOccName :: OccName -> SDoc
204 pprOccName (OccName sp occ)
205 = getPprStyle $ \ sty ->
207 then ftext (zEncodeFS occ)
208 else ftext occ <> if debugStyle sty
209 then braces (pprNameSpaceBrief sp)
214 %************************************************************************
216 \subsection{Construction}
218 %************************************************************************
221 mkOccName :: NameSpace -> String -> OccName
222 mkOccName occ_sp str = OccName occ_sp (mkFastString str)
224 mkOccNameFS :: NameSpace -> FastString -> OccName
225 mkOccNameFS occ_sp fs = OccName occ_sp fs
227 mkVarOcc :: String -> OccName
228 mkVarOcc s = mkOccName varName s
230 mkVarOccFS :: FastString -> OccName
231 mkVarOccFS fs = mkOccNameFS varName fs
233 mkTyVarOcc :: FastString -> OccName
234 mkTyVarOcc fs = mkOccNameFS tvName fs
238 %************************************************************************
242 %************************************************************************
244 OccEnvs are used mainly for the envts in ModIfaces.
246 They are efficient, because FastStrings have unique Int# keys. We assume
247 this key is less than 2^24, so we can make a Unique using
248 mkUnique ns key :: Unique
249 where 'ns' is a Char reprsenting the name space. This in turn makes it
250 easy to build an OccEnv.
253 instance Uniquable OccName where
254 getUnique (OccName ns fs)
255 = mkUnique char (iBox (uniqueOfFS fs))
256 where -- See notes above about this getUnique function
263 newtype OccEnv a = A (UniqFM a)
265 emptyOccEnv :: OccEnv a
266 unitOccEnv :: OccName -> a -> OccEnv a
267 extendOccEnv :: OccEnv a -> OccName -> a -> OccEnv a
268 extendOccEnvList :: OccEnv a -> [(OccName, a)] -> OccEnv a
269 lookupOccEnv :: OccEnv a -> OccName -> Maybe a
270 mkOccEnv :: [(OccName,a)] -> OccEnv a
271 mkOccEnv_C :: (a -> a -> a) -> [(OccName,a)] -> OccEnv a
272 elemOccEnv :: OccName -> OccEnv a -> Bool
273 foldOccEnv :: (a -> b -> b) -> b -> OccEnv a -> b
274 occEnvElts :: OccEnv a -> [a]
275 extendOccEnv_C :: (a->a->a) -> OccEnv a -> OccName -> a -> OccEnv a
276 plusOccEnv :: OccEnv a -> OccEnv a -> OccEnv a
277 plusOccEnv_C :: (a->a->a) -> OccEnv a -> OccEnv a -> OccEnv a
278 mapOccEnv :: (a->b) -> OccEnv a -> OccEnv b
279 delFromOccEnv :: OccEnv a -> OccName -> OccEnv a
280 delListFromOccEnv :: OccEnv a -> [OccName] -> OccEnv a
281 filterOccEnv :: (elt -> Bool) -> OccEnv elt -> OccEnv elt
283 emptyOccEnv = A emptyUFM
284 unitOccEnv x y = A $ unitUFM x y
285 extendOccEnv (A x) y z = A $ addToUFM x y z
286 extendOccEnvList (A x) l = A $ addListToUFM x l
287 lookupOccEnv (A x) y = lookupUFM x y
288 mkOccEnv l = A $ listToUFM l
289 elemOccEnv x (A y) = elemUFM x y
290 foldOccEnv a b (A c) = foldUFM a b c
291 occEnvElts (A x) = eltsUFM x
292 plusOccEnv (A x) (A y) = A $ plusUFM x y
293 plusOccEnv_C f (A x) (A y) = A $ plusUFM_C f x y
294 extendOccEnv_C f (A x) y z = A $ addToUFM_C f x y z
295 mapOccEnv f (A x) = A $ mapUFM f x
296 mkOccEnv_C comb l = A $ addListToUFM_C comb emptyUFM l
297 delFromOccEnv (A x) y = A $ delFromUFM x y
298 delListFromOccEnv (A x) y = A $ delListFromUFM x y
299 filterOccEnv x (A y) = A $ filterUFM x y
301 instance Outputable a => Outputable (OccEnv a) where
304 type OccSet = UniqSet OccName
306 emptyOccSet :: OccSet
307 unitOccSet :: OccName -> OccSet
308 mkOccSet :: [OccName] -> OccSet
309 extendOccSet :: OccSet -> OccName -> OccSet
310 extendOccSetList :: OccSet -> [OccName] -> OccSet
311 unionOccSets :: OccSet -> OccSet -> OccSet
312 unionManyOccSets :: [OccSet] -> OccSet
313 minusOccSet :: OccSet -> OccSet -> OccSet
314 elemOccSet :: OccName -> OccSet -> Bool
315 occSetElts :: OccSet -> [OccName]
316 foldOccSet :: (OccName -> b -> b) -> b -> OccSet -> b
317 isEmptyOccSet :: OccSet -> Bool
318 intersectOccSet :: OccSet -> OccSet -> OccSet
319 intersectsOccSet :: OccSet -> OccSet -> Bool
321 emptyOccSet = emptyUniqSet
322 unitOccSet = unitUniqSet
324 extendOccSet = addOneToUniqSet
325 extendOccSetList = addListToUniqSet
326 unionOccSets = unionUniqSets
327 unionManyOccSets = unionManyUniqSets
328 minusOccSet = minusUniqSet
329 elemOccSet = elementOfUniqSet
330 occSetElts = uniqSetToList
331 foldOccSet = foldUniqSet
332 isEmptyOccSet = isEmptyUniqSet
333 intersectOccSet = intersectUniqSets
334 intersectsOccSet s1 s2 = not (isEmptyOccSet (s1 `intersectOccSet` s2))
338 %************************************************************************
340 \subsection{Predicates and taking them apart}
342 %************************************************************************
345 occNameString :: OccName -> String
346 occNameString (OccName _ s) = unpackFS s
348 setOccNameSpace :: NameSpace -> OccName -> OccName
349 setOccNameSpace sp (OccName _ occ) = OccName sp occ
351 isVarOcc, isTvOcc, isDataSymOcc, isSymOcc, isTcOcc, isValOcc, isDataOcc :: OccName -> Bool
353 isVarOcc (OccName VarName _) = True
356 isTvOcc (OccName TvName _) = True
359 isTcOcc (OccName TcClsName _) = True
362 isValOcc (OccName VarName _) = True
363 isValOcc (OccName DataName _) = True
366 -- Data constructor operator (starts with ':', or '[]')
367 -- Pretty inefficient!
368 isDataSymOcc (OccName DataName s) = isLexConSym s
369 isDataSymOcc (OccName VarName s)
370 | isLexConSym s = pprPanic "isDataSymOcc: check me" (ppr s)
371 -- Jan06: I don't think this should happen
372 isDataSymOcc _ = False
374 isDataOcc (OccName DataName _) = True
375 isDataOcc (OccName VarName s)
376 | isLexCon s = pprPanic "isDataOcc: check me" (ppr s)
377 -- Jan06: I don't think this should happen
380 -- Any operator (data constructor or variable)
381 -- Pretty inefficient!
382 isSymOcc (OccName DataName s) = isLexConSym s
383 isSymOcc (OccName TcClsName s) = isLexConSym s
384 isSymOcc (OccName VarName s) = isLexSym s
385 isSymOcc (OccName TvName s) = isLexSym s
387 parenSymOcc :: OccName -> SDoc -> SDoc
388 -- Wrap parens around an operator
389 parenSymOcc occ doc | isSymOcc occ = parens doc
395 reportIfUnused :: OccName -> Bool
396 -- Haskell 98 encourages compilers to suppress warnings about
397 -- unused names in a pattern if they start with "_".
398 reportIfUnused occ = case occNameString occ of
404 %************************************************************************
406 \subsection{Making system names}
408 %************************************************************************
410 Here's our convention for splitting up the interface file name space:
412 d... dictionary identifiers
413 (local variables, so no name-clash worries)
415 $f... dict-fun identifiers (from inst decls)
416 $dm... default methods
417 $p... superclass selectors
419 :T... compiler-generated tycons for dictionaries
420 :D... ...ditto data cons
421 :Co... ...ditto coercions
422 $sf.. specialised version of f
424 in encoded form these appear as Zdfxxx etc
426 :... keywords (export:, letrec: etc.)
427 --- I THINK THIS IS WRONG!
429 This knowledge is encoded in the following functions.
432 @mk_deriv@ generates an @OccName@ from the prefix and a string.
433 NB: The string must already be encoded!
436 mk_deriv :: NameSpace
437 -> String -- Distinguishes one sort of derived name from another
441 mk_deriv occ_sp sys_prefix str = mkOccName occ_sp (sys_prefix ++ str)
445 mkDataConWrapperOcc, mkWorkerOcc, mkDefaultMethodOcc, mkDerivedTyConOcc,
446 mkClassTyConOcc, mkClassDataConOcc, mkDictOcc, mkIPOcc,
447 mkSpecOcc, mkForeignExportOcc, mkGenOcc1, mkGenOcc2,
448 mkDataTOcc, mkDataCOcc, mkDataConWorkerOcc, mkNewTyCoOcc,
449 mkInstTyCoOcc, mkEqPredCoOcc,
450 mkVectOcc, mkVectTyConOcc, mkVectDataConOcc, mkVectIsoOcc,
451 mkPArrayTyConOcc, mkPArrayDataConOcc, mkPReprTyConOcc, mkPADFunOcc
452 :: OccName -> OccName
454 -- These derived variables have a prefix that no Haskell value could have
455 mkDataConWrapperOcc = mk_simple_deriv varName "$W"
456 mkWorkerOcc = mk_simple_deriv varName "$w"
457 mkDefaultMethodOcc = mk_simple_deriv varName "$dm"
458 mkDerivedTyConOcc = mk_simple_deriv tcName ":" -- The : prefix makes sure it classifies
459 mkClassTyConOcc = mk_simple_deriv tcName ":T" -- as a tycon/datacon
460 mkClassDataConOcc = mk_simple_deriv dataName ":D" -- We go straight to the "real" data con
461 -- for datacons from classes
462 mkDictOcc = mk_simple_deriv varName "$d"
463 mkIPOcc = mk_simple_deriv varName "$i"
464 mkSpecOcc = mk_simple_deriv varName "$s"
465 mkForeignExportOcc = mk_simple_deriv varName "$f"
466 mkNewTyCoOcc = mk_simple_deriv tcName ":Co"
467 mkInstTyCoOcc = mk_simple_deriv tcName ":CoF" -- derived from rep ty
468 mkEqPredCoOcc = mk_simple_deriv tcName "$co"
470 -- Generic derivable classes
471 mkGenOcc1 = mk_simple_deriv varName "$gfrom"
472 mkGenOcc2 = mk_simple_deriv varName "$gto"
474 -- data T = MkT ... deriving( Data ) needs defintions for
475 -- $tT :: Data.Generics.Basics.DataType
476 -- $cMkT :: Data.Generics.Basics.Constr
477 mkDataTOcc = mk_simple_deriv varName "$t"
478 mkDataCOcc = mk_simple_deriv varName "$c"
481 mkVectOcc = mk_simple_deriv varName "$v_"
482 mkVectTyConOcc = mk_simple_deriv tcName ":V_"
483 mkVectDataConOcc = mk_simple_deriv dataName ":VD_"
484 mkVectIsoOcc = mk_simple_deriv varName "$VI_"
485 mkPArrayTyConOcc = mk_simple_deriv tcName ":VP_"
486 mkPArrayDataConOcc = mk_simple_deriv dataName ":VPD_"
487 mkPReprTyConOcc = mk_simple_deriv tcName ":VR_"
488 mkPADFunOcc = mk_simple_deriv varName "$PA_"
490 mk_simple_deriv :: NameSpace -> String -> OccName -> OccName
491 mk_simple_deriv sp px occ = mk_deriv sp px (occNameString occ)
493 -- Data constructor workers are made by setting the name space
494 -- of the data constructor OccName (which should be a DataName)
496 mkDataConWorkerOcc datacon_occ = setOccNameSpace varName datacon_occ
500 mkSuperDictSelOcc :: Int -- Index of superclass, eg 3
501 -> OccName -- Class, eg "Ord"
502 -> OccName -- eg "$p3Ord"
503 mkSuperDictSelOcc index cls_occ
504 = mk_deriv varName "$p" (show index ++ occNameString cls_occ)
506 mkLocalOcc :: Unique -- Unique
507 -> OccName -- Local name (e.g. "sat")
508 -> OccName -- Nice unique version ("$L23sat")
510 = mk_deriv varName ("$L" ++ show uniq) (occNameString occ)
511 -- The Unique might print with characters
512 -- that need encoding (e.g. 'z'!)
515 Derive a name for the representation type constructor of a data/newtype
519 mkInstTyTcOcc :: Int -- Index
520 -> OccName -- Family name (e.g. "Map")
521 -> OccName -- Nice unique version (":R23Map")
522 mkInstTyTcOcc index occ
523 = mk_deriv tcName (":R" ++ show index) (occNameString occ)
527 mkDFunOcc :: String -- Typically the class and type glommed together e.g. "OrdMaybe"
528 -- Only used in debug mode, for extra clarity
529 -> Bool -- True <=> hs-boot instance dfun
530 -> Int -- Unique index
531 -> OccName -- "$f3OrdMaybe"
533 -- In hs-boot files we make dict funs like $fx7ClsTy, which get bound to the real
534 -- thing when we compile the mother module. Reason: we don't know exactly
535 -- what the mother module will call it.
537 mkDFunOcc info_str is_boot index
538 = mk_deriv VarName prefix string
540 prefix | is_boot = "$fx"
542 string | opt_PprStyle_Debug = show index ++ info_str
543 | otherwise = show index
546 We used to add a '$m' to indicate a method, but that gives rise to bad
547 error messages from the type checker when we print the function name or pattern
548 of an instance-decl binding. Why? Because the binding is zapped
549 to use the method name in place of the selector name.
550 (See TcClassDcl.tcMethodBind)
552 The way it is now, -ddump-xx output may look confusing, but
553 you can always say -dppr-debug to get the uniques.
555 However, we *do* have to zap the first character to be lower case,
556 because overloaded constructors (blarg) generate methods too.
557 And convert to VarName space
559 e.g. a call to constructor MkFoo where
560 data (Ord a) => Foo a = MkFoo a
562 If this is necessary, we do it by prefixing '$m'. These
563 guys never show up in error messages. What a hack.
566 mkMethodOcc :: OccName -> OccName
567 mkMethodOcc occ@(OccName VarName _) = occ
568 mkMethodOcc occ = mk_simple_deriv varName "$m" occ
572 %************************************************************************
574 \subsection{Tidying them up}
576 %************************************************************************
578 Before we print chunks of code we like to rename it so that
579 we don't have to print lots of silly uniques in it. But we mustn't
580 accidentally introduce name clashes! So the idea is that we leave the
581 OccName alone unless it accidentally clashes with one that is already
582 in scope; if so, we tack on '1' at the end and try again, then '2', and
583 so on till we find a unique one.
585 There's a wrinkle for operators. Consider '>>='. We can't use '>>=1'
586 because that isn't a single lexeme. So we encode it to 'lle' and *then*
587 tack on the '1', if necessary.
590 type TidyOccEnv = OccEnv Int -- The in-scope OccNames
591 -- Range gives a plausible starting point for new guesses
593 emptyTidyOccEnv :: TidyOccEnv
594 emptyTidyOccEnv = emptyOccEnv
596 initTidyOccEnv :: [OccName] -> TidyOccEnv -- Initialise with names to avoid!
597 initTidyOccEnv = foldl (\env occ -> extendOccEnv env occ 1) emptyTidyOccEnv
599 tidyOccName :: TidyOccEnv -> OccName -> (TidyOccEnv, OccName)
601 tidyOccName in_scope occ@(OccName occ_sp fs)
602 = case lookupOccEnv in_scope occ of
603 Nothing -> -- Not already used: make it used
604 (extendOccEnv in_scope occ 1, occ)
606 Just n -> -- Already used: make a new guess,
607 -- change the guess base, and try again
608 tidyOccName (extendOccEnv in_scope occ (n+1))
609 (mkOccName occ_sp (unpackFS fs ++ show n))
612 %************************************************************************
614 Stuff for dealing with tuples
616 %************************************************************************
619 mkTupleOcc :: NameSpace -> Boxity -> Arity -> OccName
620 mkTupleOcc ns bx ar = OccName ns (mkFastString str)
622 -- no need to cache these, the caching is done in the caller
623 -- (TysWiredIn.mk_tuple)
625 Boxed -> '(' : commas ++ ")"
626 Unboxed -> '(' : '#' : commas ++ "#)"
628 commas = take (ar-1) (repeat ',')
630 isTupleOcc_maybe :: OccName -> Maybe (NameSpace, Boxity, Arity)
631 -- Tuples are special, because there are so many of them!
632 isTupleOcc_maybe (OccName ns fs)
633 = case unpackFS fs of
634 '(':'#':',':rest -> Just (ns, Unboxed, 2 + count_commas rest)
635 '(':',':rest -> Just (ns, Boxed, 2 + count_commas rest)
638 count_commas (',':rest) = 1 + count_commas rest
642 %************************************************************************
644 \subsection{Lexical categories}
646 %************************************************************************
648 These functions test strings to see if they fit the lexical categories
649 defined in the Haskell report.
652 isLexCon, isLexVar, isLexId, isLexSym :: FastString -> Bool
653 isLexConId, isLexConSym, isLexVarId, isLexVarSym :: FastString -> Bool
655 isLexCon cs = isLexConId cs || isLexConSym cs
656 isLexVar cs = isLexVarId cs || isLexVarSym cs
658 isLexId cs = isLexConId cs || isLexVarId cs
659 isLexSym cs = isLexConSym cs || isLexVarSym cs
663 isLexConId cs -- Prefix type or data constructors
664 | nullFS cs = False -- e.g. "Foo", "[]", "(,)"
665 | cs == (fsLit "[]") = True
666 | otherwise = startsConId (headFS cs)
668 isLexVarId cs -- Ordinary prefix identifiers
669 | nullFS cs = False -- e.g. "x", "_x"
670 | otherwise = startsVarId (headFS cs)
672 isLexConSym cs -- Infix type or data constructors
673 | nullFS cs = False -- e.g. ":-:", ":", "->"
674 | cs == (fsLit "->") = True
675 | otherwise = startsConSym (headFS cs)
677 isLexVarSym cs -- Infix identifiers
678 | nullFS cs = False -- e.g. "+"
679 | otherwise = startsVarSym (headFS cs)
682 startsVarSym, startsVarId, startsConSym, startsConId :: Char -> Bool
683 startsVarSym c = isSymbolASCII c || (ord c > 0x7f && isSymbol c) -- Infix Ids
684 startsConSym c = c == ':' -- Infix data constructors
685 startsVarId c = isLower c || c == '_' -- Ordinary Ids
686 startsConId c = isUpper c || c == '(' -- Ordinary type constructors and data constructors
688 isSymbolASCII :: Char -> Bool
689 isSymbolASCII c = c `elem` "!#$%&*+./<=>?@\\^|~-"
692 %************************************************************************
695 Here rather than BinIface because OccName is abstract
697 %************************************************************************
700 instance Binary NameSpace where
703 put_ bh DataName = do
707 put_ bh TcClsName = do
712 0 -> do return VarName
713 1 -> do return DataName
714 2 -> do return TvName
715 _ -> do return TcClsName
717 instance Binary OccName where
718 put_ bh (OccName aa ab) = do
724 return (OccName aa ab)