Construction of EqPred dictionaries
[ghc.git] / compiler / basicTypes / OccName.lhs
1 %
2 % (c) The University of Glasgow 2006
3 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4 %
5
6 \begin{code}
7 module OccName (
8         -- * The NameSpace type; abstact
9         NameSpace, tcName, clsName, tcClsName, dataName, varName, 
10         tvName, srcDataName,
11
12         -- ** Printing
13         pprNameSpace, pprNonVarNameSpace, pprNameSpaceBrief,
14
15         -- * The OccName type
16         OccName,        -- Abstract, instance of Outputable
17         pprOccName, 
18
19         -- ** Construction      
20         mkOccName, mkOccNameFS, 
21         mkVarOcc, mkVarOccFS,
22         mkTyVarOcc,
23         mkDFunOcc,
24         mkTupleOcc, 
25         setOccNameSpace,
26
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
36         -- ** Deconstruction
37         occNameFS, occNameString, occNameSpace, 
38
39         isVarOcc, isTvOcc, isTcOcc, isDataOcc, isDataSymOcc, isSymOcc, isValOcc,
40         parenSymOcc, reportIfUnused, isTcClsName, isVarName,
41
42         isTupleOcc_maybe,
43
44         -- The OccEnv type
45         OccEnv, emptyOccEnv, unitOccEnv, extendOccEnv, mapOccEnv,
46         lookupOccEnv, mkOccEnv, mkOccEnv_C, extendOccEnvList, elemOccEnv,
47         occEnvElts, foldOccEnv, plusOccEnv, plusOccEnv_C, extendOccEnv_C,
48
49         -- The OccSet type
50         OccSet, emptyOccSet, unitOccSet, mkOccSet, extendOccSet, 
51         extendOccSetList,
52         unionOccSets, unionManyOccSets, minusOccSet, elemOccSet, occSetElts, 
53         foldOccSet, isEmptyOccSet, intersectOccSet, intersectsOccSet,
54
55         -- Tidying up
56         TidyOccEnv, emptyTidyOccEnv, tidyOccName, initTidyOccEnv,
57
58         -- The basic form of names
59         isLexCon, isLexVar, isLexId, isLexSym,
60         isLexConId, isLexConSym, isLexVarId, isLexVarSym,
61         startsVarSym, startsVarId, startsConSym, startsConId
62     ) where
63
64 #include "HsVersions.h"
65
66 import Util
67 import Unique
68 import BasicTypes
69 import StaticFlags
70 import UniqFM
71 import UniqSet
72 import FastString
73 import Outputable
74 import Binary
75
76 import GHC.Exts
77 import Data.Char
78
79 -- Unicode TODO: put isSymbol in libcompat
80 #if __GLASGOW_HASKELL__ > 604
81 import Data.Char        ( isSymbol )
82 #else
83 isSymbol = const False
84 #endif
85
86 \end{code}
87
88 %************************************************************************
89 %*                                                                      *
90 \subsection{Name space}
91 %*                                                                      *
92 %************************************************************************
93
94 \begin{code}
95 data NameSpace = VarName        -- Variables, including "source" data constructors
96                | DataName       -- "Real" data constructors 
97                | TvName         -- Type variables
98                | TcClsName      -- Type constructors and classes; Haskell has them
99                                 -- in the same name space for now.
100                deriving( Eq, Ord )
101    {-! derive: Binary !-}
102
103 -- Note [Data Constructors]  
104 -- see also: Note [Data Constructor Naming] in DataCon.lhs
105 -- 
106 --      "Source" data constructors are the data constructors mentioned
107 --      in Haskell source code
108 --
109 --      "Real" data constructors are the data constructors of the
110 --      representation type, which may not be the same as the source
111 --      type
112
113 -- Example:
114 --      data T = T !(Int,Int)
115 --
116 -- The source datacon has type (Int,Int) -> T
117 -- The real   datacon has type Int -> Int -> T
118 -- GHC chooses a representation based on the strictness etc.
119
120
121 -- Though type constructors and classes are in the same name space now,
122 -- the NameSpace type is abstract, so we can easily separate them later
123 tcName    = TcClsName           -- Type constructors
124 clsName   = TcClsName           -- Classes
125 tcClsName = TcClsName           -- Not sure which!
126
127 dataName    = DataName
128 srcDataName = DataName  -- Haskell-source data constructors should be
129                         -- in the Data name space
130
131 tvName      = TvName
132 varName     = VarName
133
134 isTcClsName :: NameSpace -> Bool
135 isTcClsName TcClsName = True
136 isTcClsName _         = False
137
138 isVarName :: NameSpace -> Bool  -- Variables or type variables, but not constructors
139 isVarName TvName  = True
140 isVarName VarName = True
141 isVarName other   = False
142
143 pprNameSpace :: NameSpace -> SDoc
144 pprNameSpace DataName  = ptext SLIT("data constructor")
145 pprNameSpace VarName   = ptext SLIT("variable")
146 pprNameSpace TvName    = ptext SLIT("type variable")
147 pprNameSpace TcClsName = ptext SLIT("type constructor or class")
148
149 pprNonVarNameSpace :: NameSpace -> SDoc
150 pprNonVarNameSpace VarName = empty
151 pprNonVarNameSpace ns = pprNameSpace ns
152
153 pprNameSpaceBrief DataName  = char 'd'
154 pprNameSpaceBrief VarName   = char 'v'
155 pprNameSpaceBrief TvName    = ptext SLIT("tv")
156 pprNameSpaceBrief TcClsName = ptext SLIT("tc")
157 \end{code}
158
159
160 %************************************************************************
161 %*                                                                      *
162 \subsection[Name-pieces-datatypes]{The @OccName@ datatypes}
163 %*                                                                      *
164 %************************************************************************
165
166 \begin{code}
167 data OccName = OccName 
168     { occNameSpace  :: !NameSpace
169     , occNameFS     :: !FastString
170     }
171 \end{code}
172
173
174 \begin{code}
175 instance Eq OccName where
176     (OccName sp1 s1) == (OccName sp2 s2) = s1 == s2 && sp1 == sp2
177
178 instance Ord OccName where
179     compare (OccName sp1 s1) (OccName sp2 s2) = (s1  `compare` s2) `thenCmp`
180                                                 (sp1 `compare` sp2)
181 \end{code}
182
183
184 %************************************************************************
185 %*                                                                      *
186 \subsection{Printing}
187 %*                                                                      *
188 %************************************************************************
189  
190 \begin{code}
191 instance Outputable OccName where
192     ppr = pprOccName
193
194 pprOccName :: OccName -> SDoc
195 pprOccName (OccName sp occ) 
196   = getPprStyle $ \ sty ->
197     if codeStyle sty 
198         then ftext (zEncodeFS occ)
199         else ftext occ <> if debugStyle sty 
200                             then braces (pprNameSpaceBrief sp)
201                             else empty
202 \end{code}
203
204
205 %************************************************************************
206 %*                                                                      *
207 \subsection{Construction}
208 %*                                                                      *
209 %************************************************************************
210
211 \begin{code}
212 mkOccName :: NameSpace -> String -> OccName
213 mkOccName occ_sp str = OccName occ_sp (mkFastString str)
214
215 mkOccNameFS :: NameSpace -> FastString -> OccName
216 mkOccNameFS occ_sp fs = OccName occ_sp fs
217
218 mkVarOcc :: String -> OccName
219 mkVarOcc s = mkOccName varName s
220
221 mkVarOccFS :: FastString -> OccName
222 mkVarOccFS fs = mkOccNameFS varName fs
223
224 mkTyVarOcc :: FastString -> OccName
225 mkTyVarOcc fs = mkOccNameFS tvName fs
226 \end{code}
227
228
229 %************************************************************************
230 %*                                                                      *
231                 Environments
232 %*                                                                      *
233 %************************************************************************
234
235 OccEnvs are used mainly for the envts in ModIfaces.
236
237 They are efficient, because FastStrings have unique Int# keys.  We assume
238 this key is less than 2^24, so we can make a Unique using
239         mkUnique ns key  :: Unique
240 where 'ns' is a Char reprsenting the name space.  This in turn makes it
241 easy to build an OccEnv.
242
243 \begin{code}
244 instance Uniquable OccName where
245   getUnique (OccName ns fs)
246       = mkUnique char (I# (uniqueOfFS fs))
247       where     -- See notes above about this getUnique function
248         char = case ns of
249                 VarName   -> 'i'
250                 DataName  -> 'd'
251                 TvName    -> 'v'
252                 TcClsName -> 't'
253
254 type OccEnv a = UniqFM a
255
256 emptyOccEnv :: OccEnv a
257 unitOccEnv  :: OccName -> a -> OccEnv a
258 extendOccEnv :: OccEnv a -> OccName -> a -> OccEnv a
259 extendOccEnvList :: OccEnv a -> [(OccName, a)] -> OccEnv a
260 lookupOccEnv :: OccEnv a -> OccName -> Maybe a
261 mkOccEnv     :: [(OccName,a)] -> OccEnv a
262 mkOccEnv_C   :: (a -> a -> a) -> [(OccName,a)] -> OccEnv a
263 elemOccEnv   :: OccName -> OccEnv a -> Bool
264 foldOccEnv   :: (a -> b -> b) -> b -> OccEnv a -> b
265 occEnvElts   :: OccEnv a -> [a]
266 extendOccEnv_C :: (a->a->a) -> OccEnv a -> OccName -> a -> OccEnv a
267 plusOccEnv     :: OccEnv a -> OccEnv a -> OccEnv a
268 plusOccEnv_C   :: (a->a->a) -> OccEnv a -> OccEnv a -> OccEnv a
269 mapOccEnv      :: (a->b) -> OccEnv a -> OccEnv b
270
271 emptyOccEnv      = emptyUFM
272 unitOccEnv       = unitUFM
273 extendOccEnv     = addToUFM
274 extendOccEnvList = addListToUFM
275 lookupOccEnv     = lookupUFM
276 mkOccEnv         = listToUFM
277 elemOccEnv       = elemUFM
278 foldOccEnv       = foldUFM
279 occEnvElts       = eltsUFM
280 plusOccEnv       = plusUFM
281 plusOccEnv_C     = plusUFM_C
282 extendOccEnv_C   = addToUFM_C
283 mapOccEnv        = mapUFM
284
285 mkOccEnv_C comb l = addListToUFM_C comb emptyOccEnv l
286
287 type OccSet = UniqFM OccName
288
289 emptyOccSet       :: OccSet
290 unitOccSet        :: OccName -> OccSet
291 mkOccSet          :: [OccName] -> OccSet
292 extendOccSet      :: OccSet -> OccName -> OccSet
293 extendOccSetList  :: OccSet -> [OccName] -> OccSet
294 unionOccSets      :: OccSet -> OccSet -> OccSet
295 unionManyOccSets  :: [OccSet] -> OccSet
296 minusOccSet       :: OccSet -> OccSet -> OccSet
297 elemOccSet        :: OccName -> OccSet -> Bool
298 occSetElts        :: OccSet -> [OccName]
299 foldOccSet        :: (OccName -> b -> b) -> b -> OccSet -> b
300 isEmptyOccSet     :: OccSet -> Bool
301 intersectOccSet   :: OccSet -> OccSet -> OccSet
302 intersectsOccSet  :: OccSet -> OccSet -> Bool
303
304 emptyOccSet       = emptyUniqSet
305 unitOccSet        = unitUniqSet
306 mkOccSet          = mkUniqSet
307 extendOccSet      = addOneToUniqSet
308 extendOccSetList  = addListToUniqSet
309 unionOccSets      = unionUniqSets
310 unionManyOccSets  = unionManyUniqSets
311 minusOccSet       = minusUniqSet
312 elemOccSet        = elementOfUniqSet
313 occSetElts        = uniqSetToList
314 foldOccSet        = foldUniqSet
315 isEmptyOccSet     = isEmptyUniqSet
316 intersectOccSet   = intersectUniqSets
317 intersectsOccSet s1 s2 = not (isEmptyOccSet (s1 `intersectOccSet` s2))
318 \end{code}
319
320
321 %************************************************************************
322 %*                                                                      *
323 \subsection{Predicates and taking them apart}
324 %*                                                                      *
325 %************************************************************************
326
327 \begin{code}
328 occNameString :: OccName -> String
329 occNameString (OccName _ s) = unpackFS s
330
331 setOccNameSpace :: NameSpace -> OccName -> OccName
332 setOccNameSpace sp (OccName _ occ) = OccName sp occ
333
334 isVarOcc, isTvOcc, isDataSymOcc, isSymOcc, isTcOcc :: OccName -> Bool
335
336 isVarOcc (OccName VarName _) = True
337 isVarOcc other               = False
338
339 isTvOcc (OccName TvName _) = True
340 isTvOcc other              = False
341
342 isTcOcc (OccName TcClsName _) = True
343 isTcOcc other                 = False
344
345 isValOcc (OccName VarName  _) = True
346 isValOcc (OccName DataName _) = True
347 isValOcc other                = False
348
349 -- Data constructor operator (starts with ':', or '[]')
350 -- Pretty inefficient!
351 isDataSymOcc (OccName DataName s) = isLexConSym s
352 isDataSymOcc (OccName VarName s)  
353   | isLexConSym s = pprPanic "isDataSymOcc: check me" (ppr s)
354                 -- Jan06: I don't think this should happen
355 isDataSymOcc other                = False
356
357 isDataOcc (OccName DataName _) = True
358 isDataOcc (OccName VarName s)  
359   | isLexCon s = pprPanic "isDataOcc: check me" (ppr s)
360                 -- Jan06: I don't think this should happen
361 isDataOcc other                = False
362
363 -- Any operator (data constructor or variable)
364 -- Pretty inefficient!
365 isSymOcc (OccName DataName s)  = isLexConSym s
366 isSymOcc (OccName TcClsName s) = isLexConSym s
367 isSymOcc (OccName VarName s)   = isLexSym s
368 isSymOcc other                 = False
369
370 parenSymOcc :: OccName -> SDoc -> SDoc
371 -- Wrap parens around an operator
372 parenSymOcc occ doc | isSymOcc occ = parens doc
373                     | otherwise    = doc
374 \end{code}
375
376
377 \begin{code}
378 reportIfUnused :: OccName -> Bool
379   -- Haskell 98 encourages compilers to suppress warnings about
380   -- unused names in a pattern if they start with "_".
381 reportIfUnused occ = case occNameString occ of
382                         ('_' : _) -> False
383                         _other    -> True
384 \end{code}
385
386
387 %************************************************************************
388 %*                                                                      *
389 \subsection{Making system names}
390 %*                                                                      *
391 %************************************************************************
392
393 Here's our convention for splitting up the interface file name space:
394
395         d...            dictionary identifiers
396                         (local variables, so no name-clash worries)
397
398         $f...           dict-fun identifiers (from inst decls)
399         $dm...          default methods
400         $p...           superclass selectors
401         $w...           workers
402         :T...           compiler-generated tycons for dictionaries
403         :D...           ...ditto data cons
404         :Co...          ...ditto coercions
405         $sf..           specialised version of f
406
407         in encoded form these appear as Zdfxxx etc
408
409         :...            keywords (export:, letrec: etc.)
410 --- I THINK THIS IS WRONG!
411
412 This knowledge is encoded in the following functions.
413
414
415 @mk_deriv@ generates an @OccName@ from the prefix and a string.
416 NB: The string must already be encoded!
417
418 \begin{code}
419 mk_deriv :: NameSpace 
420          -> String              -- Distinguishes one sort of derived name from another
421          -> String
422          -> OccName
423
424 mk_deriv occ_sp sys_prefix str = mkOccName occ_sp (sys_prefix ++ str)
425 \end{code}
426
427 \begin{code}
428 mkDataConWrapperOcc, mkWorkerOcc, mkDefaultMethodOcc, mkDerivedTyConOcc,
429         mkClassTyConOcc, mkClassDataConOcc, mkDictOcc, mkIPOcc, 
430         mkSpecOcc, mkForeignExportOcc, mkGenOcc1, mkGenOcc2,
431         mkDataTOcc, mkDataCOcc, mkDataConWorkerOcc, mkNewTyCoOcc
432    :: OccName -> OccName
433
434 -- These derived variables have a prefix that no Haskell value could have
435 mkDataConWrapperOcc = mk_simple_deriv varName  "$W"
436 mkWorkerOcc         = mk_simple_deriv varName  "$w"
437 mkDefaultMethodOcc  = mk_simple_deriv varName  "$dm"
438 mkDerivedTyConOcc   = mk_simple_deriv tcName   ":"      -- The : prefix makes sure it classifies
439 mkClassTyConOcc     = mk_simple_deriv tcName   ":T"     -- as a tycon/datacon
440 mkClassDataConOcc   = mk_simple_deriv dataName ":D"     -- We go straight to the "real" data con
441                                                         -- for datacons from classes
442 mkDictOcc           = mk_simple_deriv varName  "$d"
443 mkIPOcc             = mk_simple_deriv varName  "$i"
444 mkSpecOcc           = mk_simple_deriv varName  "$s"
445 mkForeignExportOcc  = mk_simple_deriv varName  "$f"
446 mkNewTyCoOcc        = mk_simple_deriv tcName  ":Co"
447 mkInstTyCoOcc       = mk_simple_deriv tcName  ":Co"      -- derived from rep ty
448 mkEqPredCoOcc       = mk_simple_deriv tcName  "$co"
449
450 -- Generic derivable classes
451 mkGenOcc1           = mk_simple_deriv varName  "$gfrom"
452 mkGenOcc2           = mk_simple_deriv varName  "$gto" 
453
454 -- data T = MkT ... deriving( Data ) needs defintions for 
455 --      $tT   :: Data.Generics.Basics.DataType
456 --      $cMkT :: Data.Generics.Basics.Constr
457 mkDataTOcc = mk_simple_deriv varName  "$t"
458 mkDataCOcc = mk_simple_deriv varName  "$c"
459
460 mk_simple_deriv sp px occ = mk_deriv sp px (occNameString occ)
461
462 -- Data constructor workers are made by setting the name space
463 -- of the data constructor OccName (which should be a DataName)
464 -- to VarName
465 mkDataConWorkerOcc datacon_occ = setOccNameSpace varName datacon_occ 
466 \end{code}
467
468 \begin{code}
469 mkSuperDictSelOcc :: Int        -- Index of superclass, eg 3
470                   -> OccName    -- Class, eg "Ord"
471                   -> OccName    -- eg "$p3Ord"
472 mkSuperDictSelOcc index cls_occ
473   = mk_deriv varName "$p" (show index ++ occNameString cls_occ)
474
475 mkLocalOcc :: Unique            -- Unique
476            -> OccName           -- Local name (e.g. "sat")
477            -> OccName           -- Nice unique version ("$L23sat")
478 mkLocalOcc uniq occ
479    = mk_deriv varName ("$L" ++ show uniq) (occNameString occ)
480         -- The Unique might print with characters 
481         -- that need encoding (e.g. 'z'!)
482 \end{code}
483
484 Derive a name for the representation type constructor of a data/newtype
485 instance.
486
487 \begin{code}
488 mkInstTyTcOcc :: Int                    -- Index
489               -> OccName                -- Family name (e.g. "Map")
490               -> OccName                -- Nice unique version (":R23Map")
491 mkInstTyTcOcc index occ
492    = mk_deriv tcName (":R" ++ show index) (occNameString occ)
493 \end{code}
494
495 \begin{code}
496 mkDFunOcc :: String             -- Typically the class and type glommed together e.g. "OrdMaybe"
497                                 -- Only used in debug mode, for extra clarity
498           -> Bool               -- True <=> hs-boot instance dfun
499           -> Int                -- Unique index
500           -> OccName            -- "$f3OrdMaybe"
501
502 -- In hs-boot files we make dict funs like $fx7ClsTy, which get bound to the real
503 -- thing when we compile the mother module. Reason: we don't know exactly
504 -- what the  mother module will call it.
505
506 mkDFunOcc info_str is_boot index 
507   = mk_deriv VarName prefix string
508   where
509     prefix | is_boot   = "$fx"
510            | otherwise = "$f"
511     string | opt_PprStyle_Debug = show index ++ info_str
512            | otherwise          = show index
513 \end{code}
514
515 We used to add a '$m' to indicate a method, but that gives rise to bad
516 error messages from the type checker when we print the function name or pattern
517 of an instance-decl binding.  Why? Because the binding is zapped
518 to use the method name in place of the selector name.
519 (See TcClassDcl.tcMethodBind)
520
521 The way it is now, -ddump-xx output may look confusing, but
522 you can always say -dppr-debug to get the uniques.
523
524 However, we *do* have to zap the first character to be lower case,
525 because overloaded constructors (blarg) generate methods too.
526 And convert to VarName space
527
528 e.g. a call to constructor MkFoo where
529         data (Ord a) => Foo a = MkFoo a
530
531 If this is necessary, we do it by prefixing '$m'.  These 
532 guys never show up in error messages.  What a hack.
533
534 \begin{code}
535 mkMethodOcc :: OccName -> OccName
536 mkMethodOcc occ@(OccName VarName fs) = occ
537 mkMethodOcc occ                      = mk_simple_deriv varName "$m" occ
538 \end{code}
539
540
541 %************************************************************************
542 %*                                                                      *
543 \subsection{Tidying them up}
544 %*                                                                      *
545 %************************************************************************
546
547 Before we print chunks of code we like to rename it so that
548 we don't have to print lots of silly uniques in it.  But we mustn't
549 accidentally introduce name clashes!  So the idea is that we leave the
550 OccName alone unless it accidentally clashes with one that is already
551 in scope; if so, we tack on '1' at the end and try again, then '2', and
552 so on till we find a unique one.
553
554 There's a wrinkle for operators.  Consider '>>='.  We can't use '>>=1' 
555 because that isn't a single lexeme.  So we encode it to 'lle' and *then*
556 tack on the '1', if necessary.
557
558 \begin{code}
559 type TidyOccEnv = OccEnv Int    -- The in-scope OccNames
560         -- Range gives a plausible starting point for new guesses
561
562 emptyTidyOccEnv = emptyOccEnv
563
564 initTidyOccEnv :: [OccName] -> TidyOccEnv       -- Initialise with names to avoid!
565 initTidyOccEnv = foldl (\env occ -> extendOccEnv env occ 1) emptyTidyOccEnv
566
567 tidyOccName :: TidyOccEnv -> OccName -> (TidyOccEnv, OccName)
568
569 tidyOccName in_scope occ@(OccName occ_sp fs)
570   = case lookupOccEnv in_scope occ of
571         Nothing ->      -- Not already used: make it used
572                    (extendOccEnv in_scope occ 1, occ)
573
574         Just n  ->      -- Already used: make a new guess, 
575                         -- change the guess base, and try again
576                    tidyOccName  (extendOccEnv in_scope occ (n+1))
577                                 (mkOccName occ_sp (unpackFS fs ++ show n))
578 \end{code}
579
580 %************************************************************************
581 %*                                                                      *
582                 Stuff for dealing with tuples
583 %*                                                                      *
584 %************************************************************************
585
586 \begin{code}
587 mkTupleOcc :: NameSpace -> Boxity -> Arity -> OccName
588 mkTupleOcc ns bx ar = OccName ns (mkFastString str)
589   where
590         -- no need to cache these, the caching is done in the caller
591         -- (TysWiredIn.mk_tuple)
592     str = case bx of
593                 Boxed   -> '(' : commas ++ ")"
594                 Unboxed -> '(' : '#' : commas ++ "#)"
595
596     commas = take (ar-1) (repeat ',')
597
598 isTupleOcc_maybe :: OccName -> Maybe (NameSpace, Boxity, Arity)
599 -- Tuples are special, because there are so many of them!
600 isTupleOcc_maybe (OccName ns fs)
601   = case unpackFS fs of
602         '(':'#':',':rest -> Just (ns, Unboxed, 2 + count_commas rest)
603         '(':',':rest     -> Just (ns, Boxed,   2 + count_commas rest)
604         _other           -> Nothing
605   where
606     count_commas (',':rest) = 1 + count_commas rest
607     count_commas _          = 0
608 \end{code}
609
610 %************************************************************************
611 %*                                                                      *
612 \subsection{Lexical categories}
613 %*                                                                      *
614 %************************************************************************
615
616 These functions test strings to see if they fit the lexical categories
617 defined in the Haskell report.
618
619 \begin{code}
620 isLexCon,   isLexVar,    isLexId,    isLexSym    :: FastString -> Bool
621 isLexConId, isLexConSym, isLexVarId, isLexVarSym :: FastString -> Bool
622
623 isLexCon cs = isLexConId  cs || isLexConSym cs
624 isLexVar cs = isLexVarId  cs || isLexVarSym cs
625
626 isLexId  cs = isLexConId  cs || isLexVarId  cs
627 isLexSym cs = isLexConSym cs || isLexVarSym cs
628
629 -------------
630
631 isLexConId cs                           -- Prefix type or data constructors
632   | nullFS cs         = False           --      e.g. "Foo", "[]", "(,)" 
633   | cs == FSLIT("[]") = True
634   | otherwise         = startsConId (headFS cs)
635
636 isLexVarId cs                           -- Ordinary prefix identifiers
637   | nullFS cs         = False           --      e.g. "x", "_x"
638   | otherwise         = startsVarId (headFS cs)
639
640 isLexConSym cs                          -- Infix type or data constructors
641   | nullFS cs         = False           --      e.g. ":-:", ":", "->"
642   | cs == FSLIT("->") = True
643   | otherwise         = startsConSym (headFS cs)
644
645 isLexVarSym cs                          -- Infix identifiers
646   | nullFS cs         = False           --      e.g. "+"
647   | otherwise         = startsVarSym (headFS cs)
648
649 -------------
650 startsVarSym, startsVarId, startsConSym, startsConId :: Char -> Bool
651 startsVarSym c = isSymbolASCII c || (ord c > 0x7f && isSymbol c) -- Infix Ids
652 startsConSym c = c == ':'                               -- Infix data constructors
653 startsVarId c  = isLower c || c == '_'  -- Ordinary Ids
654 startsConId c  = isUpper c || c == '('  -- Ordinary type constructors and data constructors
655
656 isSymbolASCII c = c `elem` "!#$%&*+./<=>?@\\^|~-"
657 \end{code}
658
659 %************************************************************************
660 %*                                                                      *
661                 Binary instance
662     Here rather than BinIface because OccName is abstract
663 %*                                                                      *
664 %************************************************************************
665
666 \begin{code}
667 instance Binary NameSpace where
668     put_ bh VarName = do
669             putByte bh 0
670     put_ bh DataName = do
671             putByte bh 1
672     put_ bh TvName = do
673             putByte bh 2
674     put_ bh TcClsName = do
675             putByte bh 3
676     get bh = do
677             h <- getByte bh
678             case h of
679               0 -> do return VarName
680               1 -> do return DataName
681               2 -> do return TvName
682               _ -> do return TcClsName
683
684 instance Binary OccName where
685     put_ bh (OccName aa ab) = do
686             put_ bh aa
687             put_ bh ab
688     get bh = do
689           aa <- get bh
690           ab <- get bh
691           return (OccName aa ab)
692 \end{code}