8452092ceb881e224bab7f8a5d05aa4ca176d042
[ghc.git] / compiler / prelude / PrelNames.lhs
1 %
2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
3 %
4 \section[PrelNames]{Definitions of prelude modules and names}
5
6
7 Nota Bene: all Names defined in here should come from the base package
8
9  - ModuleNames for prelude modules,
10         e.g.    pREL_BASE_Name :: ModuleName
11
12  - Modules for prelude modules
13         e.g.    pREL_Base :: Module
14
15  - Uniques for Ids, DataCons, TyCons and Classes that the compiler
16    "knows about" in some way
17         e.g.    intTyConKey :: Unique
18                 minusClassOpKey :: Unique
19
20  - Names for Ids, DataCons, TyCons and Classes that the compiler
21    "knows about" in some way
22         e.g.    intTyConName :: Name
23                 minusName    :: Name
24    One of these Names contains
25         (a) the module and occurrence name of the thing
26         (b) its Unique
27    The may way the compiler "knows about" one of these things is
28    where the type checker or desugarer needs to look it up. For
29    example, when desugaring list comprehensions the desugarer
30    needs to conjure up 'foldr'.  It does this by looking up
31    foldrName in the environment.
32
33  - RdrNames for Ids, DataCons etc that the compiler may emit into
34    generated code (e.g. for deriving).  It's not necessary to know
35    the uniques for these guys, only their names
36
37
38 Note [Known-key names]
39 ~~~~~~~~~~~~~~~~~~~~~~
40
41 It is *very* important that the compiler gives wired-in things and things with "known-key" names
42 the correct Uniques wherever they occur. We have to be careful about this in exactly two places:
43
44   1. When we parse some source code, renaming the AST better yield an AST whose Names have the
45      correct uniques
46
47   2. When we read an interface file, the read-in gubbins better have the right uniques
48
49 This is accomplished through a combination of mechanisms:
50
51   1. When parsing source code, the RdrName-decorated AST has some RdrNames which are Exact. These are
52      wired-in RdrNames where the we could directly tell from the parsed syntax what Name to use. For
53      example, when we parse a [] in a type we can just insert an Exact RdrName Name with the listTyConKey.
54
55      Currently, I believe this is just an optimisation: it would be equally valid to just output Orig
56      RdrNames that correctly record the module etc we expect the final Name to come from. However,
57      were we to eliminate isTupleOcc_maybe it would become essential (see point 3).
58
59   2. The knownKeyNames (which consist of the basicKnownKeyNames from the module, and those names reachable
60      via the wired-in stuff from TysWiredIn) are used to initialise the "original name cache" in IfaceEnv.
61      This initialization ensures that when the type checker or renamer (both of which use IfaceEnv) look up
62      an original name (i.e. a pair of a Module and an OccName) for a known-key name they get the correct Unique.
63
64      This is the most important mechanism for ensuring that known-key stuff gets the right Unique, and is why
65      it is so important to place your known-key names in the appropriate lists.
66
67   3. For "infinite families" of known-key names (i.e. tuples, Any tycons and implicit parameter TyCons), we
68      have to be extra careful. Because there are an infinite number of these things, we cannot add them to
69      the list of known-key names used to initialise the original name cache. Instead, we have to rely on
70      never having to look them up in that cache.
71
72      This is accomplished through a variety of mechanisms:
73
74        a) The known infinite families of names are specially serialised by BinIface.putName, with that special treatment
75           detected when we read back to ensure that we get back to the correct uniques.
76
77        b) Most of the infinite families cannot occur in source code, so mechanism a) sufficies to ensure that they
78           always have the right Unique. In particular, implicit param TyCon names, constraint tuples and Any TyCons
79           cannot be mentioned by the user.
80
81        c) Tuple TyCon/DataCon names have a special hack (isTupleOcc_maybe) that is used by the original name cache
82           lookup routine to detect tuple names and give them the right Unique. You might think that this is unnecessary
83           because tuple TyCon/DataCons are parsed as Exact RdrNames and *don't* appear as original names in interface files
84           (because serialization gives them special treatment), so we will never look them up in the original name cache.
85
86           However, there is a subtle reason why this is not the case: if you use setRdrNameSpace on an Exact RdrName
87           it may be turned into an Orig RdrName. So if the original name was an Exact tuple Name we might end up with
88           an Orig instead, which *will* lead to an original name cache query.
89 \begin{code}
90 module PrelNames (
91         Unique, Uniquable(..), hasKey,  -- Re-exported for convenience
92
93         -----------------------------------------------------------
94         module PrelNames,       -- A huge bunch of (a) Names,  e.g. intTyConName
95                                 --                 (b) Uniques e.g. intTyConKey
96                                 --                 (c) Groups of classes and types
97                                 --                 (d) miscellaneous things
98                                 -- So many that we export them all
99     ) where
100
101 #include "HsVersions.h"
102
103 import Module
104 import OccName
105 import RdrName
106 import Unique
107 import BasicTypes
108 import Name
109 import SrcLoc
110 import FastString
111 \end{code}
112
113
114 %************************************************************************
115 %*                                                                      *
116 \subsection{Local Names}
117 %*                                                                      *
118 %************************************************************************
119
120 This *local* name is used by the interactive stuff
121
122 \begin{code}
123 itName :: Unique -> SrcSpan -> Name
124 itName uniq loc = mkInternalName uniq (mkOccNameFS varName (fsLit "it")) loc
125 \end{code}
126
127 \begin{code}
128 -- mkUnboundName makes a place-holder Name; it shouldn't be looked at except possibly
129 -- during compiler debugging.
130 mkUnboundName :: RdrName -> Name
131 mkUnboundName rdr_name = mkInternalName unboundKey (rdrNameOcc rdr_name) noSrcSpan
132
133 isUnboundName :: Name -> Bool
134 isUnboundName name = name `hasKey` unboundKey
135 \end{code}
136
137
138 %************************************************************************
139 %*                                                                      *
140 \subsection{Known key Names}
141 %*                                                                      *
142 %************************************************************************
143
144 This section tells what the compiler knows about the association of
145 names with uniques.  These ones are the *non* wired-in ones.  The
146 wired in ones are defined in TysWiredIn etc.
147
148 The names for DPH can come from one of multiple backend packages. At the point where
149 'basicKnownKeyNames' is used, we don't know which backend it will be.  Hence, we list
150 the names for multiple backends.  That works out fine, although they use the same uniques,
151 as we are guaranteed to only load one backend; hence, only one of the different names
152 sharing a unique will be used.
153
154 \begin{code}
155 basicKnownKeyNames :: [Name]
156 basicKnownKeyNames
157  = genericTyConNames
158  ++ oldTypeableClassNames
159  ++ [   -- Type constructors (synonyms especially)
160         ioTyConName, ioDataConName,
161         runMainIOName,
162         rationalTyConName,
163         stringTyConName,
164         ratioDataConName,
165         ratioTyConName,
166         integerTyConName,
167
168         --  Classes.  *Must* include:
169         --      classes that are grabbed by key (e.g., eqClassKey)
170         --      classes in "Class.standardClassKeys" (quite a few)
171         eqClassName,                    -- mentioned, derivable
172         ordClassName,                   -- derivable
173         boundedClassName,               -- derivable
174         numClassName,                   -- mentioned, numeric
175         enumClassName,                  -- derivable
176         monadClassName,
177         functorClassName,
178         realClassName,                  -- numeric
179         integralClassName,              -- numeric
180         fractionalClassName,            -- numeric
181         floatingClassName,              -- numeric
182         realFracClassName,              -- numeric
183         realFloatClassName,             -- numeric
184         dataClassName,
185         isStringClassName,
186         applicativeClassName,
187         foldableClassName,
188         traversableClassName,
189         typeableClassName,              -- derivable
190
191         -- Numeric stuff
192         negateName, minusName, geName, eqName,
193
194         -- Conversion functions
195         fromRationalName, fromIntegerName,
196         toIntegerName, toRationalName,
197         fromIntegralName, realToFracName,
198
199         -- String stuff
200         fromStringName,
201
202         -- Enum stuff
203         enumFromName, enumFromThenName,
204         enumFromThenToName, enumFromToName,
205
206         -- Monad stuff
207         thenIOName, bindIOName, returnIOName, failIOName,
208         failMName, bindMName, thenMName, returnMName,
209         fmapName,
210
211         -- MonadRec stuff
212         mfixName,
213
214         -- Arrow stuff
215         arrAName, composeAName, firstAName,
216         appAName, choiceAName, loopAName,
217
218         -- Ix stuff
219         ixClassName,
220
221         -- Show stuff
222         showClassName,
223
224         -- Read stuff
225         readClassName,
226
227         -- Stable pointers
228         newStablePtrName,
229
230         -- GHC Extensions
231         groupWithName,
232
233         -- Strings and lists
234         unpackCStringName,
235         unpackCStringFoldrName, unpackCStringUtf8Name,
236         
237         -- Overloaded lists
238         isListClassName,
239         fromListName,
240         fromListNName,
241         toListName,
242         
243         -- List operations
244         concatName, filterName, mapName,
245         zipName, foldrName, buildName, augmentName, appendName,
246
247         dollarName,         -- The ($) apply function
248
249         -- FFI primitive types that are not wired-in.
250         stablePtrTyConName, ptrTyConName, funPtrTyConName,
251         int8TyConName, int16TyConName, int32TyConName, int64TyConName,
252         wordTyConName, word8TyConName, word16TyConName, word32TyConName, word64TyConName,
253
254         -- Others
255         otherwiseIdName, inlineIdName,
256         eqStringName, assertName, breakpointName, breakpointCondName,
257         breakpointAutoName,  opaqueTyConName,
258         assertErrorName, runSTRepName,
259         printName, fstName, sndName,
260
261         -- Integer
262         integerTyConName, mkIntegerName,
263         integerToWord64Name, integerToInt64Name,
264         word64ToIntegerName, int64ToIntegerName,
265         plusIntegerName, timesIntegerName, smallIntegerName,
266         wordToIntegerName,
267         integerToWordName, integerToIntName, minusIntegerName,
268         negateIntegerName, eqIntegerName, neqIntegerName,
269         absIntegerName, signumIntegerName,
270         leIntegerName, gtIntegerName, ltIntegerName, geIntegerName,
271         compareIntegerName, quotRemIntegerName, divModIntegerName,
272         quotIntegerName, remIntegerName,
273         floatFromIntegerName, doubleFromIntegerName,
274         encodeFloatIntegerName, encodeDoubleIntegerName,
275         decodeDoubleIntegerName,
276         gcdIntegerName, lcmIntegerName,
277         andIntegerName, orIntegerName, xorIntegerName, complementIntegerName,
278         shiftLIntegerName, shiftRIntegerName,
279
280         -- Float/Double
281         rationalToFloatName,
282         rationalToDoubleName,
283
284         -- MonadFix
285         monadFixClassName, mfixName,
286
287         -- Other classes
288         randomClassName, randomGenClassName, monadPlusClassName,
289
290         -- Type-level naturals
291         singIClassName,
292         typeNatLeqClassName,
293         typeNatAddTyFamName,
294         typeNatMulTyFamName,
295         typeNatExpTyFamName,
296
297         -- Implicit parameters
298         ipClassName,
299
300         -- Annotation type checking
301         toAnnotationWrapperName
302
303         -- The Ordering type
304         , orderingTyConName, ltDataConName, eqDataConName, gtDataConName
305
306         -- The Either type
307         , eitherTyConName, leftDataConName, rightDataConName
308
309         -- Plugins
310         , pluginTyConName
311
312         -- dotnet interop
313         , objectTyConName, marshalObjectName, unmarshalObjectName
314         , marshalStringName, unmarshalStringName, checkDotnetResName
315
316         -- Generics
317         , genClassName, gen1ClassName
318         , datatypeClassName, constructorClassName, selectorClassName
319
320         -- Monad comprehensions
321         , guardMName
322         , liftMName
323         , mzipName
324
325         -- GHCi Sandbox
326         , ghciIoClassName, ghciStepIoMName
327     ]
328
329 genericTyConNames :: [Name]
330 genericTyConNames = [
331     v1TyConName, u1TyConName, par1TyConName, rec1TyConName,
332     k1TyConName, m1TyConName, sumTyConName, prodTyConName,
333     compTyConName, rTyConName, pTyConName, dTyConName,
334     cTyConName, sTyConName, rec0TyConName, par0TyConName,
335     d1TyConName, c1TyConName, s1TyConName, noSelTyConName,
336     repTyConName, rep1TyConName
337   ]
338 \end{code}
339
340
341 %************************************************************************
342 %*                                                                      *
343 \subsection{Module names}
344 %*                                                                      *
345 %************************************************************************
346
347
348 --MetaHaskell Extension Add a new module here
349 \begin{code}
350 pRELUDE :: Module
351 pRELUDE         = mkBaseModule_ pRELUDE_NAME
352
353 gHC_PRIM, gHC_TYPES, gHC_GENERICS,
354     gHC_MAGIC,
355     gHC_CLASSES, gHC_BASE, gHC_ENUM, gHC_GHCI, gHC_CSTRING,
356     gHC_SHOW, gHC_READ, gHC_NUM, gHC_INTEGER_TYPE, gHC_LIST,
357     gHC_TUPLE, dATA_TUPLE, dATA_EITHER, dATA_STRING, dATA_FOLDABLE, dATA_TRAVERSABLE, dATA_MONOID,
358     gHC_CONC, gHC_IO, gHC_IO_Exception,
359     gHC_ST, gHC_ARR, gHC_STABLE, gHC_PTR, gHC_ERR, gHC_REAL,
360     gHC_FLOAT, gHC_TOP_HANDLER, sYSTEM_IO, dYNAMIC,
361     tYPEABLE, tYPEABLE_INTERNAL, oLDTYPEABLE, oLDTYPEABLE_INTERNAL, gENERICS,
362     dOTNET, rEAD_PREC, lEX, gHC_INT, gHC_WORD, mONAD, mONAD_FIX, mONAD_ZIP,
363     aRROW, cONTROL_APPLICATIVE, gHC_DESUGAR, rANDOM, gHC_EXTS,
364     cONTROL_EXCEPTION_BASE, gHC_TYPELITS, gHC_IP :: Module
365
366 gHC_PRIM        = mkPrimModule (fsLit "GHC.Prim")   -- Primitive types and values
367 gHC_TYPES       = mkPrimModule (fsLit "GHC.Types")
368 gHC_MAGIC       = mkPrimModule (fsLit "GHC.Magic")
369 gHC_CSTRING     = mkPrimModule (fsLit "GHC.CString")
370 gHC_CLASSES     = mkPrimModule (fsLit "GHC.Classes")
371
372 gHC_BASE        = mkBaseModule (fsLit "GHC.Base")
373 gHC_ENUM        = mkBaseModule (fsLit "GHC.Enum")
374 gHC_GHCI        = mkBaseModule (fsLit "GHC.GHCi")
375 gHC_SHOW        = mkBaseModule (fsLit "GHC.Show")
376 gHC_READ        = mkBaseModule (fsLit "GHC.Read")
377 gHC_NUM         = mkBaseModule (fsLit "GHC.Num")
378 gHC_INTEGER_TYPE= mkIntegerModule (fsLit "GHC.Integer.Type")
379 gHC_LIST        = mkBaseModule (fsLit "GHC.List")
380 gHC_TUPLE       = mkPrimModule (fsLit "GHC.Tuple")
381 dATA_TUPLE      = mkBaseModule (fsLit "Data.Tuple")
382 dATA_EITHER     = mkBaseModule (fsLit "Data.Either")
383 dATA_STRING     = mkBaseModule (fsLit "Data.String")
384 dATA_FOLDABLE   = mkBaseModule (fsLit "Data.Foldable")
385 dATA_TRAVERSABLE= mkBaseModule (fsLit "Data.Traversable")
386 dATA_MONOID     = mkBaseModule (fsLit "Data.Monoid")
387 gHC_CONC        = mkBaseModule (fsLit "GHC.Conc")
388 gHC_IO          = mkBaseModule (fsLit "GHC.IO")
389 gHC_IO_Exception = mkBaseModule (fsLit "GHC.IO.Exception")
390 gHC_ST          = mkBaseModule (fsLit "GHC.ST")
391 gHC_ARR         = mkBaseModule (fsLit "GHC.Arr")
392 gHC_STABLE      = mkBaseModule (fsLit "GHC.Stable")
393 gHC_PTR         = mkBaseModule (fsLit "GHC.Ptr")
394 gHC_ERR         = mkBaseModule (fsLit "GHC.Err")
395 gHC_REAL        = mkBaseModule (fsLit "GHC.Real")
396 gHC_FLOAT       = mkBaseModule (fsLit "GHC.Float")
397 gHC_TOP_HANDLER = mkBaseModule (fsLit "GHC.TopHandler")
398 sYSTEM_IO       = mkBaseModule (fsLit "System.IO")
399 dYNAMIC         = mkBaseModule (fsLit "Data.Dynamic")
400 tYPEABLE        = mkBaseModule (fsLit "Data.Typeable")
401 tYPEABLE_INTERNAL = mkBaseModule (fsLit "Data.Typeable.Internal")
402 oLDTYPEABLE     = mkBaseModule (fsLit "Data.OldTypeable")
403 oLDTYPEABLE_INTERNAL = mkBaseModule (fsLit "Data.OldTypeable.Internal")
404 gENERICS        = mkBaseModule (fsLit "Data.Data")
405 dOTNET          = mkBaseModule (fsLit "GHC.Dotnet")
406 rEAD_PREC       = mkBaseModule (fsLit "Text.ParserCombinators.ReadPrec")
407 lEX             = mkBaseModule (fsLit "Text.Read.Lex")
408 gHC_INT         = mkBaseModule (fsLit "GHC.Int")
409 gHC_WORD        = mkBaseModule (fsLit "GHC.Word")
410 mONAD           = mkBaseModule (fsLit "Control.Monad")
411 mONAD_FIX       = mkBaseModule (fsLit "Control.Monad.Fix")
412 mONAD_ZIP       = mkBaseModule (fsLit "Control.Monad.Zip")
413 aRROW           = mkBaseModule (fsLit "Control.Arrow")
414 cONTROL_APPLICATIVE = mkBaseModule (fsLit "Control.Applicative")
415 gHC_DESUGAR = mkBaseModule (fsLit "GHC.Desugar")
416 rANDOM          = mkBaseModule (fsLit "System.Random")
417 gHC_EXTS        = mkBaseModule (fsLit "GHC.Exts")
418 cONTROL_EXCEPTION_BASE = mkBaseModule (fsLit "Control.Exception.Base")
419 gHC_GENERICS    = mkBaseModule (fsLit "GHC.Generics")
420 gHC_TYPELITS    = mkBaseModule (fsLit "GHC.TypeLits")
421 gHC_IP          = mkBaseModule (fsLit "GHC.IP")
422
423 gHC_PARR' :: Module
424 gHC_PARR' = mkBaseModule (fsLit "GHC.PArr")
425
426 mAIN, rOOT_MAIN :: Module
427 mAIN            = mkMainModule_ mAIN_NAME
428 rOOT_MAIN       = mkMainModule (fsLit ":Main") -- Root module for initialisation
429
430         -- The ':xxx' makes a module name that the user can never
431         -- use himself.  The z-encoding for ':' is "ZC", so the z-encoded
432         -- module name still starts with a capital letter, which keeps
433         -- the z-encoded version consistent.
434 iNTERACTIVE :: Module
435 iNTERACTIVE    = mkMainModule (fsLit ":Interactive")
436
437 pRELUDE_NAME, mAIN_NAME :: ModuleName
438 pRELUDE_NAME   = mkModuleNameFS (fsLit "Prelude")
439 mAIN_NAME      = mkModuleNameFS (fsLit "Main")
440
441 dATA_ARRAY_PARALLEL_NAME, dATA_ARRAY_PARALLEL_PRIM_NAME :: ModuleName
442 dATA_ARRAY_PARALLEL_NAME      = mkModuleNameFS (fsLit "Data.Array.Parallel")
443 dATA_ARRAY_PARALLEL_PRIM_NAME = mkModuleNameFS (fsLit "Data.Array.Parallel.Prim")
444
445 mkPrimModule :: FastString -> Module
446 mkPrimModule m = mkModule primPackageId (mkModuleNameFS m)
447
448 mkIntegerModule :: FastString -> Module
449 mkIntegerModule m = mkModule integerPackageId (mkModuleNameFS m)
450
451 mkBaseModule :: FastString -> Module
452 mkBaseModule m = mkModule basePackageId (mkModuleNameFS m)
453
454 mkBaseModule_ :: ModuleName -> Module
455 mkBaseModule_ m = mkModule basePackageId m
456
457 mkThisGhcModule :: FastString -> Module
458 mkThisGhcModule m = mkModule thisGhcPackageId (mkModuleNameFS m)
459
460 mkThisGhcModule_ :: ModuleName -> Module
461 mkThisGhcModule_ m = mkModule thisGhcPackageId m
462
463 mkMainModule :: FastString -> Module
464 mkMainModule m = mkModule mainPackageId (mkModuleNameFS m)
465
466 mkMainModule_ :: ModuleName -> Module
467 mkMainModule_ m = mkModule mainPackageId m
468 \end{code}
469
470 %************************************************************************
471 %*                                                                      *
472 \subsection{Constructing the names of tuples
473 %*                                                                      *
474 %************************************************************************
475
476 \begin{code}
477 mkTupleModule :: TupleSort -> Arity -> Module
478 mkTupleModule BoxedTuple   _ = gHC_TUPLE
479 mkTupleModule ConstraintTuple    _ = gHC_TUPLE
480 mkTupleModule UnboxedTuple _ = gHC_PRIM
481 \end{code}
482
483
484 %************************************************************************
485 %*                                                                      *
486                         RdrNames
487 %*                                                                      *
488 %************************************************************************
489
490 \begin{code}
491 main_RDR_Unqual    :: RdrName
492 main_RDR_Unqual = mkUnqual varName (fsLit "main")
493         -- We definitely don't want an Orig RdrName, because
494         -- main might, in principle, be imported into module Main
495
496 forall_tv_RDR, dot_tv_RDR :: RdrName
497 forall_tv_RDR = mkUnqual tvName (fsLit "forall")
498 dot_tv_RDR    = mkUnqual tvName (fsLit ".")
499
500 eq_RDR, ge_RDR, ne_RDR, le_RDR, lt_RDR, gt_RDR, compare_RDR,
501     ltTag_RDR, eqTag_RDR, gtTag_RDR :: RdrName
502 eq_RDR                  = nameRdrName eqName
503 ge_RDR                  = nameRdrName geName
504 ne_RDR                  = varQual_RDR  gHC_CLASSES (fsLit "/=")
505 le_RDR                  = varQual_RDR  gHC_CLASSES (fsLit "<=")
506 lt_RDR                  = varQual_RDR  gHC_CLASSES (fsLit "<")
507 gt_RDR                  = varQual_RDR  gHC_CLASSES (fsLit ">")
508 compare_RDR             = varQual_RDR  gHC_CLASSES (fsLit "compare")
509 ltTag_RDR               = dataQual_RDR gHC_TYPES (fsLit "LT")
510 eqTag_RDR               = dataQual_RDR gHC_TYPES (fsLit "EQ")
511 gtTag_RDR               = dataQual_RDR gHC_TYPES (fsLit "GT")
512
513 eqClass_RDR, numClass_RDR, ordClass_RDR, enumClass_RDR, monadClass_RDR
514     :: RdrName
515 eqClass_RDR             = nameRdrName eqClassName
516 numClass_RDR            = nameRdrName numClassName
517 ordClass_RDR            = nameRdrName ordClassName
518 enumClass_RDR           = nameRdrName enumClassName
519 monadClass_RDR          = nameRdrName monadClassName
520
521 map_RDR, append_RDR :: RdrName
522 map_RDR                 = varQual_RDR gHC_BASE (fsLit "map")
523 append_RDR              = varQual_RDR gHC_BASE (fsLit "++")
524
525 foldr_RDR, build_RDR, returnM_RDR, bindM_RDR, failM_RDR :: RdrName
526 foldr_RDR               = nameRdrName foldrName
527 build_RDR               = nameRdrName buildName
528 returnM_RDR             = nameRdrName returnMName
529 bindM_RDR               = nameRdrName bindMName
530 failM_RDR               = nameRdrName failMName
531
532 left_RDR, right_RDR :: RdrName
533 left_RDR                = nameRdrName leftDataConName
534 right_RDR               = nameRdrName rightDataConName
535
536 fromEnum_RDR, toEnum_RDR :: RdrName
537 fromEnum_RDR            = varQual_RDR gHC_ENUM (fsLit "fromEnum")
538 toEnum_RDR              = varQual_RDR gHC_ENUM (fsLit "toEnum")
539
540 enumFrom_RDR, enumFromTo_RDR, enumFromThen_RDR, enumFromThenTo_RDR :: RdrName
541 enumFrom_RDR            = nameRdrName enumFromName
542 enumFromTo_RDR          = nameRdrName enumFromToName
543 enumFromThen_RDR        = nameRdrName enumFromThenName
544 enumFromThenTo_RDR      = nameRdrName enumFromThenToName
545
546 ratioDataCon_RDR, plusInteger_RDR, timesInteger_RDR :: RdrName
547 ratioDataCon_RDR        = nameRdrName ratioDataConName
548 plusInteger_RDR         = nameRdrName plusIntegerName
549 timesInteger_RDR        = nameRdrName timesIntegerName
550
551 ioDataCon_RDR :: RdrName
552 ioDataCon_RDR           = nameRdrName ioDataConName
553
554 eqString_RDR, unpackCString_RDR, unpackCStringFoldr_RDR,
555     unpackCStringUtf8_RDR :: RdrName
556 eqString_RDR            = nameRdrName eqStringName
557 unpackCString_RDR       = nameRdrName unpackCStringName
558 unpackCStringFoldr_RDR  = nameRdrName unpackCStringFoldrName
559 unpackCStringUtf8_RDR   = nameRdrName unpackCStringUtf8Name
560
561 newStablePtr_RDR, wordDataCon_RDR :: RdrName
562 newStablePtr_RDR        = nameRdrName newStablePtrName
563 wordDataCon_RDR         = dataQual_RDR gHC_TYPES (fsLit "W#")
564
565 bindIO_RDR, returnIO_RDR :: RdrName
566 bindIO_RDR              = nameRdrName bindIOName
567 returnIO_RDR            = nameRdrName returnIOName
568
569 fromInteger_RDR, fromRational_RDR, minus_RDR, times_RDR, plus_RDR :: RdrName
570 fromInteger_RDR         = nameRdrName fromIntegerName
571 fromRational_RDR        = nameRdrName fromRationalName
572 minus_RDR               = nameRdrName minusName
573 times_RDR               = varQual_RDR  gHC_NUM (fsLit "*")
574 plus_RDR                = varQual_RDR gHC_NUM (fsLit "+")
575
576 fromString_RDR :: RdrName
577 fromString_RDR          = nameRdrName fromStringName
578
579 fromList_RDR, fromListN_RDR, toList_RDR :: RdrName
580 fromList_RDR = nameRdrName fromListName
581 fromListN_RDR = nameRdrName fromListNName
582 toList_RDR = nameRdrName toListName
583
584 compose_RDR :: RdrName
585 compose_RDR             = varQual_RDR gHC_BASE (fsLit ".")
586
587 not_RDR, getTag_RDR, succ_RDR, pred_RDR, minBound_RDR, maxBound_RDR,
588     and_RDR, range_RDR, inRange_RDR, index_RDR,
589     unsafeIndex_RDR, unsafeRangeSize_RDR :: RdrName
590 and_RDR                 = varQual_RDR gHC_CLASSES (fsLit "&&")
591 not_RDR                 = varQual_RDR gHC_CLASSES (fsLit "not")
592 getTag_RDR              = varQual_RDR gHC_BASE (fsLit "getTag")
593 succ_RDR                = varQual_RDR gHC_ENUM (fsLit "succ")
594 pred_RDR                = varQual_RDR gHC_ENUM (fsLit "pred")
595 minBound_RDR            = varQual_RDR gHC_ENUM (fsLit "minBound")
596 maxBound_RDR            = varQual_RDR gHC_ENUM (fsLit "maxBound")
597 range_RDR               = varQual_RDR gHC_ARR (fsLit "range")
598 inRange_RDR             = varQual_RDR gHC_ARR (fsLit "inRange")
599 index_RDR               = varQual_RDR gHC_ARR (fsLit "index")
600 unsafeIndex_RDR         = varQual_RDR gHC_ARR (fsLit "unsafeIndex")
601 unsafeRangeSize_RDR     = varQual_RDR gHC_ARR (fsLit "unsafeRangeSize")
602
603 readList_RDR, readListDefault_RDR, readListPrec_RDR, readListPrecDefault_RDR,
604     readPrec_RDR, parens_RDR, choose_RDR, lexP_RDR, expectP_RDR :: RdrName
605 readList_RDR            = varQual_RDR gHC_READ (fsLit "readList")
606 readListDefault_RDR     = varQual_RDR gHC_READ (fsLit "readListDefault")
607 readListPrec_RDR        = varQual_RDR gHC_READ (fsLit "readListPrec")
608 readListPrecDefault_RDR = varQual_RDR gHC_READ (fsLit "readListPrecDefault")
609 readPrec_RDR            = varQual_RDR gHC_READ (fsLit "readPrec")
610 parens_RDR              = varQual_RDR gHC_READ (fsLit "parens")
611 choose_RDR              = varQual_RDR gHC_READ (fsLit "choose")
612 lexP_RDR                = varQual_RDR gHC_READ (fsLit "lexP")
613 expectP_RDR             = varQual_RDR gHC_READ (fsLit "expectP")
614
615 punc_RDR, ident_RDR, symbol_RDR :: RdrName
616 punc_RDR                = dataQual_RDR lEX (fsLit "Punc")
617 ident_RDR               = dataQual_RDR lEX (fsLit "Ident")
618 symbol_RDR              = dataQual_RDR lEX (fsLit "Symbol")
619
620 step_RDR, alt_RDR, reset_RDR, prec_RDR, pfail_RDR :: RdrName
621 step_RDR                = varQual_RDR  rEAD_PREC (fsLit "step")
622 alt_RDR                 = varQual_RDR  rEAD_PREC (fsLit "+++")
623 reset_RDR               = varQual_RDR  rEAD_PREC (fsLit "reset")
624 prec_RDR                = varQual_RDR  rEAD_PREC (fsLit "prec")
625 pfail_RDR               = varQual_RDR  rEAD_PREC (fsLit "pfail")
626
627 showList_RDR, showList___RDR, showsPrec_RDR, showString_RDR,
628     showSpace_RDR, showParen_RDR :: RdrName
629 showList_RDR            = varQual_RDR gHC_SHOW (fsLit "showList")
630 showList___RDR          = varQual_RDR gHC_SHOW (fsLit "showList__")
631 showsPrec_RDR           = varQual_RDR gHC_SHOW (fsLit "showsPrec")
632 showString_RDR          = varQual_RDR gHC_SHOW (fsLit "showString")
633 showSpace_RDR           = varQual_RDR gHC_SHOW (fsLit "showSpace")
634 showParen_RDR           = varQual_RDR gHC_SHOW (fsLit "showParen")
635
636 typeRep_RDR, mkTyCon_RDR, mkTyConApp_RDR,
637     oldTypeOf_RDR, oldMkTyCon_RDR, oldMkTyConApp_RDR :: RdrName
638 typeRep_RDR       = varQual_RDR tYPEABLE_INTERNAL    (fsLit "typeRep")
639 mkTyCon_RDR       = varQual_RDR tYPEABLE_INTERNAL    (fsLit "mkTyCon")
640 mkTyConApp_RDR    = varQual_RDR tYPEABLE_INTERNAL    (fsLit "mkTyConApp")
641 oldTypeOf_RDR     = varQual_RDR oLDTYPEABLE_INTERNAL (fsLit "typeOf")
642 oldMkTyCon_RDR    = varQual_RDR oLDTYPEABLE_INTERNAL (fsLit "mkTyCon")
643 oldMkTyConApp_RDR = varQual_RDR oLDTYPEABLE_INTERNAL (fsLit "mkTyConApp")
644
645 undefined_RDR :: RdrName
646 undefined_RDR = varQual_RDR gHC_ERR (fsLit "undefined")
647
648 error_RDR :: RdrName
649 error_RDR = varQual_RDR gHC_ERR (fsLit "error")
650
651 -- Generics (constructors and functions)
652 u1DataCon_RDR, par1DataCon_RDR, rec1DataCon_RDR,
653   k1DataCon_RDR, m1DataCon_RDR, l1DataCon_RDR, r1DataCon_RDR,
654   prodDataCon_RDR, comp1DataCon_RDR,
655   unPar1_RDR, unRec1_RDR, unK1_RDR, unComp1_RDR,
656   from_RDR, from1_RDR, to_RDR, to1_RDR,
657   datatypeName_RDR, moduleName_RDR, isNewtypeName_RDR,
658   conName_RDR, conFixity_RDR, conIsRecord_RDR,
659   noArityDataCon_RDR, arityDataCon_RDR, selName_RDR,
660   prefixDataCon_RDR, infixDataCon_RDR, leftAssocDataCon_RDR,
661   rightAssocDataCon_RDR, notAssocDataCon_RDR :: RdrName
662
663 u1DataCon_RDR    = dataQual_RDR gHC_GENERICS (fsLit "U1")
664 par1DataCon_RDR  = dataQual_RDR gHC_GENERICS (fsLit "Par1")
665 rec1DataCon_RDR  = dataQual_RDR gHC_GENERICS (fsLit "Rec1")
666 k1DataCon_RDR    = dataQual_RDR gHC_GENERICS (fsLit "K1")
667 m1DataCon_RDR    = dataQual_RDR gHC_GENERICS (fsLit "M1")
668
669 l1DataCon_RDR     = dataQual_RDR gHC_GENERICS (fsLit "L1")
670 r1DataCon_RDR     = dataQual_RDR gHC_GENERICS (fsLit "R1")
671
672 prodDataCon_RDR   = dataQual_RDR gHC_GENERICS (fsLit ":*:")
673 comp1DataCon_RDR  = dataQual_RDR gHC_GENERICS (fsLit "Comp1")
674
675 unPar1_RDR  = varQual_RDR gHC_GENERICS (fsLit "unPar1")
676 unRec1_RDR  = varQual_RDR gHC_GENERICS (fsLit "unRec1")
677 unK1_RDR    = varQual_RDR gHC_GENERICS (fsLit "unK1")
678 unComp1_RDR = varQual_RDR gHC_GENERICS (fsLit "unComp1")
679
680 from_RDR  = varQual_RDR gHC_GENERICS (fsLit "from")
681 from1_RDR = varQual_RDR gHC_GENERICS (fsLit "from1")
682 to_RDR    = varQual_RDR gHC_GENERICS (fsLit "to")
683 to1_RDR   = varQual_RDR gHC_GENERICS (fsLit "to1")
684
685 datatypeName_RDR  = varQual_RDR gHC_GENERICS (fsLit "datatypeName")
686 moduleName_RDR    = varQual_RDR gHC_GENERICS (fsLit "moduleName")
687 isNewtypeName_RDR = varQual_RDR gHC_GENERICS (fsLit "isNewtype")
688 selName_RDR       = varQual_RDR gHC_GENERICS (fsLit "selName")
689 conName_RDR       = varQual_RDR gHC_GENERICS (fsLit "conName")
690 conFixity_RDR     = varQual_RDR gHC_GENERICS (fsLit "conFixity")
691 conIsRecord_RDR   = varQual_RDR gHC_GENERICS (fsLit "conIsRecord")
692
693 noArityDataCon_RDR    = dataQual_RDR gHC_GENERICS (fsLit "NoArity")
694 arityDataCon_RDR      = dataQual_RDR gHC_GENERICS (fsLit "Arity")
695 prefixDataCon_RDR     = dataQual_RDR gHC_GENERICS (fsLit "Prefix")
696 infixDataCon_RDR      = dataQual_RDR gHC_GENERICS (fsLit "Infix")
697 leftAssocDataCon_RDR  = dataQual_RDR gHC_GENERICS (fsLit "LeftAssociative")
698 rightAssocDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "RightAssociative")
699 notAssocDataCon_RDR   = dataQual_RDR gHC_GENERICS (fsLit "NotAssociative")
700
701
702 fmap_RDR, pure_RDR, ap_RDR, foldable_foldr_RDR, foldMap_RDR,
703     traverse_RDR, mempty_RDR, mappend_RDR :: RdrName
704 fmap_RDR                = varQual_RDR gHC_BASE (fsLit "fmap")
705 pure_RDR                = varQual_RDR cONTROL_APPLICATIVE (fsLit "pure")
706 ap_RDR                  = varQual_RDR cONTROL_APPLICATIVE (fsLit "<*>")
707 foldable_foldr_RDR      = varQual_RDR dATA_FOLDABLE       (fsLit "foldr")
708 foldMap_RDR             = varQual_RDR dATA_FOLDABLE       (fsLit "foldMap")
709 traverse_RDR            = varQual_RDR dATA_TRAVERSABLE    (fsLit "traverse")
710 mempty_RDR              = varQual_RDR dATA_MONOID         (fsLit "mempty")
711 mappend_RDR             = varQual_RDR dATA_MONOID         (fsLit "mappend")
712
713 ----------------------
714 varQual_RDR, tcQual_RDR, clsQual_RDR, dataQual_RDR
715     :: Module -> FastString -> RdrName
716 varQual_RDR  mod str = mkOrig mod (mkOccNameFS varName str)
717 tcQual_RDR   mod str = mkOrig mod (mkOccNameFS tcName str)
718 clsQual_RDR  mod str = mkOrig mod (mkOccNameFS clsName str)
719 dataQual_RDR mod str = mkOrig mod (mkOccNameFS dataName str)
720 \end{code}
721
722 %************************************************************************
723 %*                                                                      *
724 \subsection{Known-key names}
725 %*                                                                      *
726 %************************************************************************
727
728 Many of these Names are not really "built in", but some parts of the
729 compiler (notably the deriving mechanism) need to mention their names,
730 and it's convenient to write them all down in one place.
731
732 --MetaHaskell Extension  add the constrs and the lower case case
733 -- guys as well (perhaps) e.g. see  trueDataConName     below
734
735
736 \begin{code}
737 wildCardName :: Name
738 wildCardName = mkSystemVarName wildCardKey (fsLit "wild")
739
740 runMainIOName :: Name
741 runMainIOName = varQual gHC_TOP_HANDLER (fsLit "runMainIO") runMainKey
742
743 orderingTyConName, ltDataConName, eqDataConName, gtDataConName :: Name
744 orderingTyConName = tcQual   gHC_TYPES (fsLit "Ordering") orderingTyConKey
745 ltDataConName = conName gHC_TYPES (fsLit "LT") ltDataConKey
746 eqDataConName = conName gHC_TYPES (fsLit "EQ") eqDataConKey
747 gtDataConName = conName gHC_TYPES (fsLit "GT") gtDataConKey
748
749 eitherTyConName, leftDataConName, rightDataConName :: Name
750 eitherTyConName   = tcQual  dATA_EITHER (fsLit "Either") eitherTyConKey
751 leftDataConName   = conName dATA_EITHER (fsLit "Left")   leftDataConKey
752 rightDataConName  = conName dATA_EITHER (fsLit "Right")  rightDataConKey
753
754 -- Generics (types)
755 v1TyConName, u1TyConName, par1TyConName, rec1TyConName,
756   k1TyConName, m1TyConName, sumTyConName, prodTyConName,
757   compTyConName, rTyConName, pTyConName, dTyConName,
758   cTyConName, sTyConName, rec0TyConName, par0TyConName,
759   d1TyConName, c1TyConName, s1TyConName, noSelTyConName,
760   repTyConName, rep1TyConName :: Name
761
762 v1TyConName  = tcQual gHC_GENERICS (fsLit "V1") v1TyConKey
763 u1TyConName  = tcQual gHC_GENERICS (fsLit "U1") u1TyConKey
764 par1TyConName  = tcQual gHC_GENERICS (fsLit "Par1") par1TyConKey
765 rec1TyConName  = tcQual gHC_GENERICS (fsLit "Rec1") rec1TyConKey
766 k1TyConName  = tcQual gHC_GENERICS (fsLit "K1") k1TyConKey
767 m1TyConName  = tcQual gHC_GENERICS (fsLit "M1") m1TyConKey
768
769 sumTyConName    = tcQual gHC_GENERICS (fsLit ":+:") sumTyConKey
770 prodTyConName   = tcQual gHC_GENERICS (fsLit ":*:") prodTyConKey
771 compTyConName   = tcQual gHC_GENERICS (fsLit ":.:") compTyConKey
772
773 rTyConName  = tcQual gHC_GENERICS (fsLit "R") rTyConKey
774 pTyConName  = tcQual gHC_GENERICS (fsLit "P") pTyConKey
775 dTyConName  = tcQual gHC_GENERICS (fsLit "D") dTyConKey
776 cTyConName  = tcQual gHC_GENERICS (fsLit "C") cTyConKey
777 sTyConName  = tcQual gHC_GENERICS (fsLit "S") sTyConKey
778
779 rec0TyConName  = tcQual gHC_GENERICS (fsLit "Rec0") rec0TyConKey
780 par0TyConName  = tcQual gHC_GENERICS (fsLit "Par0") par0TyConKey
781 d1TyConName  = tcQual gHC_GENERICS (fsLit "D1") d1TyConKey
782 c1TyConName  = tcQual gHC_GENERICS (fsLit "C1") c1TyConKey
783 s1TyConName  = tcQual gHC_GENERICS (fsLit "S1") s1TyConKey
784 noSelTyConName = tcQual gHC_GENERICS (fsLit "NoSelector") noSelTyConKey
785
786 repTyConName  = tcQual gHC_GENERICS (fsLit "Rep")  repTyConKey
787 rep1TyConName = tcQual gHC_GENERICS (fsLit "Rep1") rep1TyConKey
788
789 -- Base strings Strings
790 unpackCStringName, unpackCStringFoldrName,
791     unpackCStringUtf8Name, eqStringName, stringTyConName :: Name
792 unpackCStringName       = varQual gHC_CSTRING (fsLit "unpackCString#") unpackCStringIdKey
793 unpackCStringFoldrName  = varQual gHC_CSTRING (fsLit "unpackFoldrCString#") unpackCStringFoldrIdKey
794 unpackCStringUtf8Name   = varQual gHC_CSTRING (fsLit "unpackCStringUtf8#") unpackCStringUtf8IdKey
795 eqStringName            = varQual gHC_BASE (fsLit "eqString")  eqStringIdKey
796 stringTyConName         = tcQual  gHC_BASE (fsLit "String") stringTyConKey
797
798 -- The 'inline' function
799 inlineIdName :: Name
800 inlineIdName            = varQual gHC_MAGIC (fsLit "inline") inlineIdKey
801
802 -- Base classes (Eq, Ord, Functor)
803 fmapName, eqClassName, eqName, ordClassName, geName, functorClassName :: Name
804 eqClassName       = clsQual  gHC_CLASSES (fsLit "Eq")      eqClassKey
805 eqName            = methName gHC_CLASSES (fsLit "==")      eqClassOpKey
806 ordClassName      = clsQual  gHC_CLASSES (fsLit "Ord")     ordClassKey
807 geName            = methName gHC_CLASSES (fsLit ">=")      geClassOpKey
808 functorClassName  = clsQual  gHC_BASE (fsLit "Functor") functorClassKey
809 fmapName          = methName gHC_BASE (fsLit "fmap")    fmapClassOpKey
810
811 -- Class Monad
812 monadClassName, thenMName, bindMName, returnMName, failMName :: Name
813 monadClassName     = clsQual  gHC_BASE (fsLit "Monad")  monadClassKey
814 thenMName          = methName gHC_BASE (fsLit ">>")     thenMClassOpKey
815 bindMName          = methName gHC_BASE (fsLit ">>=")    bindMClassOpKey
816 returnMName        = methName gHC_BASE (fsLit "return") returnMClassOpKey
817 failMName          = methName gHC_BASE (fsLit "fail")   failMClassOpKey
818
819 -- Classes (Applicative, Foldable, Traversable)
820 applicativeClassName, foldableClassName, traversableClassName :: Name
821 applicativeClassName  = clsQual  cONTROL_APPLICATIVE (fsLit "Applicative") applicativeClassKey
822 foldableClassName     = clsQual  dATA_FOLDABLE       (fsLit "Foldable")    foldableClassKey
823 traversableClassName  = clsQual  dATA_TRAVERSABLE    (fsLit "Traversable") traversableClassKey
824
825 -- Functions for GHC extensions
826 groupWithName :: Name
827 groupWithName = varQual gHC_EXTS (fsLit "groupWith") groupWithIdKey
828
829 -- Random PrelBase functions
830 fromStringName, otherwiseIdName, foldrName, buildName, augmentName,
831     mapName, appendName, assertName,
832     breakpointName, breakpointCondName, breakpointAutoName,
833     dollarName, opaqueTyConName :: Name
834 fromStringName = methName dATA_STRING (fsLit "fromString") fromStringClassOpKey
835 otherwiseIdName   = varQual gHC_BASE (fsLit "otherwise")  otherwiseIdKey
836 foldrName         = varQual gHC_BASE (fsLit "foldr")      foldrIdKey
837 buildName         = varQual gHC_BASE (fsLit "build")      buildIdKey
838 augmentName       = varQual gHC_BASE (fsLit "augment")    augmentIdKey
839 mapName           = varQual gHC_BASE (fsLit "map")        mapIdKey
840 appendName        = varQual gHC_BASE (fsLit "++")         appendIdKey
841 dollarName        = varQual gHC_BASE (fsLit "$")          dollarIdKey
842 assertName        = varQual gHC_BASE (fsLit "assert")     assertIdKey
843 breakpointName    = varQual gHC_BASE (fsLit "breakpoint") breakpointIdKey
844 breakpointCondName= varQual gHC_BASE (fsLit "breakpointCond") breakpointCondIdKey
845 breakpointAutoName= varQual gHC_BASE (fsLit "breakpointAuto") breakpointAutoIdKey
846 opaqueTyConName   = tcQual  gHC_BASE (fsLit "Opaque")   opaqueTyConKey
847
848 breakpointJumpName :: Name
849 breakpointJumpName
850     = mkInternalName
851         breakpointJumpIdKey
852         (mkOccNameFS varName (fsLit "breakpointJump"))
853         noSrcSpan
854 breakpointCondJumpName :: Name
855 breakpointCondJumpName
856     = mkInternalName
857         breakpointCondJumpIdKey
858         (mkOccNameFS varName (fsLit "breakpointCondJump"))
859         noSrcSpan
860 breakpointAutoJumpName :: Name
861 breakpointAutoJumpName
862     = mkInternalName
863         breakpointAutoJumpIdKey
864         (mkOccNameFS varName (fsLit "breakpointAutoJump"))
865         noSrcSpan
866
867 -- PrelTup
868 fstName, sndName :: Name
869 fstName           = varQual dATA_TUPLE (fsLit "fst") fstIdKey
870 sndName           = varQual dATA_TUPLE (fsLit "snd") sndIdKey
871
872 -- Module GHC.Num
873 numClassName, fromIntegerName, minusName, negateName :: Name
874 numClassName      = clsQual  gHC_NUM (fsLit "Num") numClassKey
875 fromIntegerName   = methName gHC_NUM (fsLit "fromInteger") fromIntegerClassOpKey
876 minusName         = methName gHC_NUM (fsLit "-") minusClassOpKey
877 negateName        = methName gHC_NUM (fsLit "negate") negateClassOpKey
878
879 integerTyConName, mkIntegerName,
880     integerToWord64Name, integerToInt64Name,
881     word64ToIntegerName, int64ToIntegerName,
882     plusIntegerName, timesIntegerName, smallIntegerName,
883     wordToIntegerName,
884     integerToWordName, integerToIntName, minusIntegerName,
885     negateIntegerName, eqIntegerName, neqIntegerName,
886     absIntegerName, signumIntegerName,
887     leIntegerName, gtIntegerName, ltIntegerName, geIntegerName,
888     compareIntegerName, quotRemIntegerName, divModIntegerName,
889     quotIntegerName, remIntegerName,
890     floatFromIntegerName, doubleFromIntegerName,
891     encodeFloatIntegerName, encodeDoubleIntegerName,
892     decodeDoubleIntegerName,
893     gcdIntegerName, lcmIntegerName,
894     andIntegerName, orIntegerName, xorIntegerName, complementIntegerName,
895     shiftLIntegerName, shiftRIntegerName :: Name
896 integerTyConName      = tcQual  gHC_INTEGER_TYPE (fsLit "Integer")           integerTyConKey
897 mkIntegerName         = varQual gHC_INTEGER_TYPE (fsLit "mkInteger")         mkIntegerIdKey
898 integerToWord64Name   = varQual gHC_INTEGER_TYPE (fsLit "integerToWord64")   integerToWord64IdKey
899 integerToInt64Name    = varQual gHC_INTEGER_TYPE (fsLit "integerToInt64")    integerToInt64IdKey
900 word64ToIntegerName   = varQual gHC_INTEGER_TYPE (fsLit "word64ToInteger")   word64ToIntegerIdKey
901 int64ToIntegerName    = varQual gHC_INTEGER_TYPE (fsLit "int64ToInteger")    int64ToIntegerIdKey
902 plusIntegerName       = varQual gHC_INTEGER_TYPE (fsLit "plusInteger")       plusIntegerIdKey
903 timesIntegerName      = varQual gHC_INTEGER_TYPE (fsLit "timesInteger")      timesIntegerIdKey
904 smallIntegerName      = varQual gHC_INTEGER_TYPE (fsLit "smallInteger")      smallIntegerIdKey
905 wordToIntegerName     = varQual gHC_INTEGER_TYPE (fsLit "wordToInteger")     wordToIntegerIdKey
906 integerToWordName     = varQual gHC_INTEGER_TYPE (fsLit "integerToWord")     integerToWordIdKey
907 integerToIntName      = varQual gHC_INTEGER_TYPE (fsLit "integerToInt")      integerToIntIdKey
908 minusIntegerName      = varQual gHC_INTEGER_TYPE (fsLit "minusInteger")      minusIntegerIdKey
909 negateIntegerName     = varQual gHC_INTEGER_TYPE (fsLit "negateInteger")     negateIntegerIdKey
910 eqIntegerName         = varQual gHC_INTEGER_TYPE (fsLit "eqInteger")         eqIntegerIdKey
911 neqIntegerName        = varQual gHC_INTEGER_TYPE (fsLit "neqInteger")        neqIntegerIdKey
912 absIntegerName        = varQual gHC_INTEGER_TYPE (fsLit "absInteger")        absIntegerIdKey
913 signumIntegerName     = varQual gHC_INTEGER_TYPE (fsLit "signumInteger")     signumIntegerIdKey
914 leIntegerName         = varQual gHC_INTEGER_TYPE (fsLit "leInteger")         leIntegerIdKey
915 gtIntegerName         = varQual gHC_INTEGER_TYPE (fsLit "gtInteger")         gtIntegerIdKey
916 ltIntegerName         = varQual gHC_INTEGER_TYPE (fsLit "ltInteger")         ltIntegerIdKey
917 geIntegerName         = varQual gHC_INTEGER_TYPE (fsLit "geInteger")         geIntegerIdKey
918 compareIntegerName    = varQual gHC_INTEGER_TYPE (fsLit "compareInteger")    compareIntegerIdKey
919 quotRemIntegerName    = varQual gHC_INTEGER_TYPE (fsLit "quotRemInteger")    quotRemIntegerIdKey
920 divModIntegerName     = varQual gHC_INTEGER_TYPE (fsLit "divModInteger")     divModIntegerIdKey
921 quotIntegerName       = varQual gHC_INTEGER_TYPE (fsLit "quotInteger")       quotIntegerIdKey
922 remIntegerName        = varQual gHC_INTEGER_TYPE (fsLit "remInteger")        remIntegerIdKey
923 floatFromIntegerName  = varQual gHC_INTEGER_TYPE (fsLit "floatFromInteger")      floatFromIntegerIdKey
924 doubleFromIntegerName = varQual gHC_INTEGER_TYPE (fsLit "doubleFromInteger")     doubleFromIntegerIdKey
925 encodeFloatIntegerName  = varQual gHC_INTEGER_TYPE (fsLit "encodeFloatInteger")  encodeFloatIntegerIdKey
926 encodeDoubleIntegerName = varQual gHC_INTEGER_TYPE (fsLit "encodeDoubleInteger") encodeDoubleIntegerIdKey
927 decodeDoubleIntegerName = varQual gHC_INTEGER_TYPE (fsLit "decodeDoubleInteger") decodeDoubleIntegerIdKey
928 gcdIntegerName        = varQual gHC_INTEGER_TYPE (fsLit "gcdInteger")        gcdIntegerIdKey
929 lcmIntegerName        = varQual gHC_INTEGER_TYPE (fsLit "lcmInteger")        lcmIntegerIdKey
930 andIntegerName        = varQual gHC_INTEGER_TYPE (fsLit "andInteger")        andIntegerIdKey
931 orIntegerName         = varQual gHC_INTEGER_TYPE (fsLit "orInteger")         orIntegerIdKey
932 xorIntegerName        = varQual gHC_INTEGER_TYPE (fsLit "xorInteger")        xorIntegerIdKey
933 complementIntegerName = varQual gHC_INTEGER_TYPE (fsLit "complementInteger") complementIntegerIdKey
934 shiftLIntegerName     = varQual gHC_INTEGER_TYPE (fsLit "shiftLInteger")     shiftLIntegerIdKey
935 shiftRIntegerName     = varQual gHC_INTEGER_TYPE (fsLit "shiftRInteger")     shiftRIntegerIdKey
936
937 -- GHC.Real types and classes
938 rationalTyConName, ratioTyConName, ratioDataConName, realClassName,
939     integralClassName, realFracClassName, fractionalClassName,
940     fromRationalName, toIntegerName, toRationalName, fromIntegralName,
941     realToFracName :: Name
942 rationalTyConName   = tcQual  gHC_REAL (fsLit "Rational") rationalTyConKey
943 ratioTyConName      = tcQual  gHC_REAL (fsLit "Ratio") ratioTyConKey
944 ratioDataConName    = conName gHC_REAL (fsLit ":%") ratioDataConKey
945 realClassName       = clsQual gHC_REAL (fsLit "Real") realClassKey
946 integralClassName   = clsQual gHC_REAL (fsLit "Integral") integralClassKey
947 realFracClassName   = clsQual gHC_REAL (fsLit "RealFrac") realFracClassKey
948 fractionalClassName = clsQual gHC_REAL (fsLit "Fractional") fractionalClassKey
949 fromRationalName    = methName gHC_REAL (fsLit "fromRational") fromRationalClassOpKey
950 toIntegerName       = methName gHC_REAL (fsLit "toInteger") toIntegerClassOpKey
951 toRationalName      = methName gHC_REAL (fsLit "toRational") toRationalClassOpKey
952 fromIntegralName    = varQual  gHC_REAL (fsLit "fromIntegral") fromIntegralIdKey
953 realToFracName      = varQual  gHC_REAL (fsLit "realToFrac") realToFracIdKey
954
955 -- PrelFloat classes
956 floatingClassName, realFloatClassName :: Name
957 floatingClassName  = clsQual  gHC_FLOAT (fsLit "Floating") floatingClassKey
958 realFloatClassName = clsQual  gHC_FLOAT (fsLit "RealFloat") realFloatClassKey
959
960 -- other GHC.Float functions
961 rationalToFloatName, rationalToDoubleName :: Name
962 rationalToFloatName  = varQual gHC_FLOAT (fsLit "rationalToFloat") rationalToFloatIdKey
963 rationalToDoubleName = varQual gHC_FLOAT (fsLit "rationalToDouble") rationalToDoubleIdKey
964
965 -- Class Ix
966 ixClassName :: Name
967 ixClassName = clsQual gHC_ARR (fsLit "Ix") ixClassKey
968
969 -- Class Typeable
970 typeableClassName,
971     oldTypeableClassName, oldTypeable1ClassName, oldTypeable2ClassName,
972     oldTypeable3ClassName, oldTypeable4ClassName, oldTypeable5ClassName,
973     oldTypeable6ClassName, oldTypeable7ClassName :: Name
974 typeableClassName  = clsQual tYPEABLE_INTERNAL (fsLit "Typeable")  typeableClassKey
975 oldTypeableClassName  = clsQual oLDTYPEABLE_INTERNAL (fsLit "Typeable")  oldTypeableClassKey
976 oldTypeable1ClassName = clsQual oLDTYPEABLE_INTERNAL (fsLit "Typeable1") oldTypeable1ClassKey
977 oldTypeable2ClassName = clsQual oLDTYPEABLE_INTERNAL (fsLit "Typeable2") oldTypeable2ClassKey
978 oldTypeable3ClassName = clsQual oLDTYPEABLE_INTERNAL (fsLit "Typeable3") oldTypeable3ClassKey
979 oldTypeable4ClassName = clsQual oLDTYPEABLE_INTERNAL (fsLit "Typeable4") oldTypeable4ClassKey
980 oldTypeable5ClassName = clsQual oLDTYPEABLE_INTERNAL (fsLit "Typeable5") oldTypeable5ClassKey
981 oldTypeable6ClassName = clsQual oLDTYPEABLE_INTERNAL (fsLit "Typeable6") oldTypeable6ClassKey
982 oldTypeable7ClassName = clsQual oLDTYPEABLE_INTERNAL (fsLit "Typeable7") oldTypeable7ClassKey
983
984 oldTypeableClassNames :: [Name]
985 oldTypeableClassNames = [ oldTypeableClassName, oldTypeable1ClassName, oldTypeable2ClassName
986                         , oldTypeable3ClassName, oldTypeable4ClassName, oldTypeable5ClassName
987                         , oldTypeable6ClassName, oldTypeable7ClassName ]
988
989 -- Class Data
990 dataClassName :: Name
991 dataClassName = clsQual gENERICS (fsLit "Data") dataClassKey
992
993 -- Error module
994 assertErrorName    :: Name
995 assertErrorName   = varQual gHC_IO_Exception (fsLit "assertError") assertErrorIdKey
996
997 -- Enum module (Enum, Bounded)
998 enumClassName, enumFromName, enumFromToName, enumFromThenName,
999     enumFromThenToName, boundedClassName :: Name
1000 enumClassName      = clsQual gHC_ENUM (fsLit "Enum") enumClassKey
1001 enumFromName       = methName gHC_ENUM (fsLit "enumFrom") enumFromClassOpKey
1002 enumFromToName     = methName gHC_ENUM (fsLit "enumFromTo") enumFromToClassOpKey
1003 enumFromThenName   = methName gHC_ENUM (fsLit "enumFromThen") enumFromThenClassOpKey
1004 enumFromThenToName = methName gHC_ENUM (fsLit "enumFromThenTo") enumFromThenToClassOpKey
1005 boundedClassName   = clsQual gHC_ENUM (fsLit "Bounded") boundedClassKey
1006
1007 -- List functions
1008 concatName, filterName, zipName :: Name
1009 concatName        = varQual gHC_LIST (fsLit "concat") concatIdKey
1010 filterName        = varQual gHC_LIST (fsLit "filter") filterIdKey
1011 zipName           = varQual gHC_LIST (fsLit "zip") zipIdKey
1012
1013 -- Overloaded lists
1014 isListClassName, fromListName, fromListNName, toListName :: Name
1015 isListClassName = clsQual gHC_EXTS (fsLit "IsList") isListClassKey
1016 fromListName = methName gHC_EXTS (fsLit "fromList") fromListClassOpKey
1017 fromListNName = methName gHC_EXTS (fsLit "fromListN") fromListNClassOpKey
1018 toListName = methName gHC_EXTS (fsLit "toList") toListClassOpKey
1019
1020 -- Class Show
1021 showClassName :: Name
1022 showClassName     = clsQual gHC_SHOW (fsLit "Show")       showClassKey
1023
1024 -- Class Read
1025 readClassName :: Name
1026 readClassName      = clsQual gHC_READ (fsLit "Read") readClassKey
1027
1028 -- Classes Generic and Generic1, Datatype, Constructor and Selector
1029 genClassName, gen1ClassName, datatypeClassName, constructorClassName,
1030   selectorClassName :: Name
1031 genClassName  = clsQual gHC_GENERICS (fsLit "Generic")  genClassKey
1032 gen1ClassName = clsQual gHC_GENERICS (fsLit "Generic1") gen1ClassKey
1033
1034 datatypeClassName = clsQual gHC_GENERICS (fsLit "Datatype") datatypeClassKey
1035 constructorClassName = clsQual gHC_GENERICS (fsLit "Constructor") constructorClassKey
1036 selectorClassName = clsQual gHC_GENERICS (fsLit "Selector") selectorClassKey
1037
1038 -- GHCi things
1039 ghciIoClassName, ghciStepIoMName :: Name
1040 ghciIoClassName = clsQual gHC_GHCI (fsLit "GHCiSandboxIO") ghciIoClassKey
1041 ghciStepIoMName = methName gHC_GHCI (fsLit "ghciStepIO") ghciStepIoMClassOpKey
1042
1043 -- IO things
1044 ioTyConName, ioDataConName, thenIOName, bindIOName, returnIOName,
1045     failIOName :: Name
1046 ioTyConName       = tcQual  gHC_TYPES (fsLit "IO") ioTyConKey
1047 ioDataConName     = conName gHC_TYPES (fsLit "IO") ioDataConKey
1048 thenIOName        = varQual gHC_BASE (fsLit "thenIO") thenIOIdKey
1049 bindIOName        = varQual gHC_BASE (fsLit "bindIO") bindIOIdKey
1050 returnIOName      = varQual gHC_BASE (fsLit "returnIO") returnIOIdKey
1051 failIOName        = varQual gHC_IO (fsLit "failIO") failIOIdKey
1052
1053 -- IO things
1054 printName :: Name
1055 printName         = varQual sYSTEM_IO (fsLit "print") printIdKey
1056
1057 -- Int, Word, and Addr things
1058 int8TyConName, int16TyConName, int32TyConName, int64TyConName :: Name
1059 int8TyConName     = tcQual gHC_INT  (fsLit "Int8") int8TyConKey
1060 int16TyConName    = tcQual gHC_INT  (fsLit "Int16") int16TyConKey
1061 int32TyConName    = tcQual gHC_INT  (fsLit "Int32") int32TyConKey
1062 int64TyConName    = tcQual gHC_INT  (fsLit "Int64") int64TyConKey
1063
1064 -- Word module
1065 word8TyConName, word16TyConName, word32TyConName, word64TyConName,
1066     wordTyConName, wordDataConName :: Name
1067 word8TyConName    = tcQual  gHC_WORD (fsLit "Word8")  word8TyConKey
1068 word16TyConName   = tcQual  gHC_WORD (fsLit "Word16") word16TyConKey
1069 word32TyConName   = tcQual  gHC_WORD (fsLit "Word32") word32TyConKey
1070 word64TyConName   = tcQual  gHC_WORD (fsLit "Word64") word64TyConKey
1071 wordTyConName     = tcQual  gHC_TYPES (fsLit "Word")   wordTyConKey
1072 wordDataConName   = conName gHC_TYPES (fsLit "W#") wordDataConKey
1073
1074 -- PrelPtr module
1075 ptrTyConName, funPtrTyConName :: Name
1076 ptrTyConName      = tcQual   gHC_PTR (fsLit "Ptr") ptrTyConKey
1077 funPtrTyConName   = tcQual   gHC_PTR (fsLit "FunPtr") funPtrTyConKey
1078
1079 -- Foreign objects and weak pointers
1080 stablePtrTyConName, newStablePtrName :: Name
1081 stablePtrTyConName    = tcQual   gHC_STABLE (fsLit "StablePtr") stablePtrTyConKey
1082 newStablePtrName      = varQual  gHC_STABLE (fsLit "newStablePtr") newStablePtrIdKey
1083
1084 -- PrelST module
1085 runSTRepName :: Name
1086 runSTRepName       = varQual gHC_ST  (fsLit "runSTRep") runSTRepIdKey
1087
1088 -- Recursive-do notation
1089 monadFixClassName, mfixName :: Name
1090 monadFixClassName  = clsQual mONAD_FIX (fsLit "MonadFix") monadFixClassKey
1091 mfixName           = methName mONAD_FIX (fsLit "mfix") mfixIdKey
1092
1093 -- Arrow notation
1094 arrAName, composeAName, firstAName, appAName, choiceAName, loopAName :: Name
1095 arrAName           = varQual aRROW (fsLit "arr")          arrAIdKey
1096 composeAName       = varQual gHC_DESUGAR (fsLit ">>>") composeAIdKey
1097 firstAName         = varQual aRROW (fsLit "first") firstAIdKey
1098 appAName           = varQual aRROW (fsLit "app")          appAIdKey
1099 choiceAName        = varQual aRROW (fsLit "|||")          choiceAIdKey
1100 loopAName          = varQual aRROW (fsLit "loop")  loopAIdKey
1101
1102 -- Monad comprehensions
1103 guardMName, liftMName, mzipName :: Name
1104 guardMName         = varQual mONAD (fsLit "guard") guardMIdKey
1105 liftMName          = varQual mONAD (fsLit "liftM") liftMIdKey
1106 mzipName           = varQual mONAD_ZIP (fsLit "mzip") mzipIdKey
1107
1108
1109 -- Annotation type checking
1110 toAnnotationWrapperName :: Name
1111 toAnnotationWrapperName = varQual gHC_DESUGAR (fsLit "toAnnotationWrapper") toAnnotationWrapperIdKey
1112
1113 -- Other classes, needed for type defaulting
1114 monadPlusClassName, randomClassName, randomGenClassName,
1115     isStringClassName :: Name
1116 monadPlusClassName  = clsQual mONAD (fsLit "MonadPlus")  monadPlusClassKey
1117 randomClassName     = clsQual rANDOM (fsLit "Random")    randomClassKey
1118 randomGenClassName  = clsQual rANDOM (fsLit "RandomGen") randomGenClassKey
1119 isStringClassName   = clsQual dATA_STRING (fsLit "IsString") isStringClassKey
1120
1121 -- Type-level naturals
1122 singIClassName, typeNatLeqClassName,
1123   typeNatAddTyFamName, typeNatMulTyFamName, typeNatExpTyFamName :: Name
1124 singIClassName      = clsQual gHC_TYPELITS (fsLit "SingI") singIClassNameKey
1125 typeNatLeqClassName = clsQual gHC_TYPELITS (fsLit "<=")  typeNatLeqClassNameKey
1126 typeNatAddTyFamName = tcQual  gHC_TYPELITS (fsLit "+")   typeNatAddTyFamNameKey
1127 typeNatMulTyFamName = tcQual  gHC_TYPELITS (fsLit "*")   typeNatMulTyFamNameKey
1128 typeNatExpTyFamName = tcQual  gHC_TYPELITS (fsLit "^")   typeNatExpTyFamNameKey
1129
1130 -- Implicit parameters
1131 ipClassName :: Name
1132 ipClassName         = clsQual gHC_IP (fsLit "IP")      ipClassNameKey
1133
1134
1135
1136 -- dotnet interop
1137 objectTyConName :: Name
1138 objectTyConName     = tcQual   dOTNET (fsLit "Object") objectTyConKey
1139         -- objectTyConName was "wTcQual", but that's gone now, and
1140         -- I can't see why it was wired in anyway...
1141 unmarshalObjectName, marshalObjectName, marshalStringName,
1142     unmarshalStringName, checkDotnetResName :: Name
1143 unmarshalObjectName = varQual  dOTNET (fsLit "unmarshalObject") unmarshalObjectIdKey
1144 marshalObjectName   = varQual  dOTNET (fsLit "marshalObject") marshalObjectIdKey
1145 marshalStringName   = varQual  dOTNET (fsLit "marshalString") marshalStringIdKey
1146 unmarshalStringName = varQual  dOTNET (fsLit "unmarshalString") unmarshalStringIdKey
1147 checkDotnetResName  = varQual  dOTNET (fsLit "checkResult")     checkDotnetResNameIdKey
1148
1149 -- plugins
1150 cORE_MONAD :: Module
1151 cORE_MONAD = mkThisGhcModule (fsLit "CoreMonad")
1152 pluginTyConName :: Name
1153 pluginTyConName = tcQual cORE_MONAD (fsLit "Plugin") pluginTyConKey
1154 \end{code}
1155
1156 %************************************************************************
1157 %*                                                                      *
1158 \subsection{Local helpers}
1159 %*                                                                      *
1160 %************************************************************************
1161
1162 All these are original names; hence mkOrig
1163
1164 \begin{code}
1165 varQual, tcQual, clsQual :: Module -> FastString -> Unique -> Name
1166 varQual  = mk_known_key_name varName
1167 tcQual   = mk_known_key_name tcName
1168 clsQual  = mk_known_key_name clsName
1169
1170 mk_known_key_name :: NameSpace -> Module -> FastString -> Unique -> Name
1171 mk_known_key_name space modu str unique
1172   = mkExternalName unique modu (mkOccNameFS space str) noSrcSpan
1173
1174 conName :: Module -> FastString -> Unique -> Name
1175 conName modu occ unique
1176   = mkExternalName unique modu (mkOccNameFS dataName occ) noSrcSpan
1177
1178 methName :: Module -> FastString -> Unique -> Name
1179 methName modu occ unique
1180   = mkExternalName unique modu (mkVarOccFS occ) noSrcSpan
1181 \end{code}
1182
1183 %************************************************************************
1184 %*                                                                      *
1185 \subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@}
1186 %*                                                                      *
1187 %************************************************************************
1188 --MetaHaskell extension hand allocate keys here
1189
1190 \begin{code}
1191 boundedClassKey, enumClassKey, eqClassKey, floatingClassKey,
1192     fractionalClassKey, integralClassKey, monadClassKey, dataClassKey,
1193     functorClassKey, numClassKey, ordClassKey, readClassKey, realClassKey,
1194     realFloatClassKey, realFracClassKey, showClassKey, ixClassKey :: Unique
1195 boundedClassKey         = mkPreludeClassUnique 1
1196 enumClassKey            = mkPreludeClassUnique 2
1197 eqClassKey              = mkPreludeClassUnique 3
1198 floatingClassKey        = mkPreludeClassUnique 5
1199 fractionalClassKey      = mkPreludeClassUnique 6
1200 integralClassKey        = mkPreludeClassUnique 7
1201 monadClassKey           = mkPreludeClassUnique 8
1202 dataClassKey            = mkPreludeClassUnique 9
1203 functorClassKey         = mkPreludeClassUnique 10
1204 numClassKey             = mkPreludeClassUnique 11
1205 ordClassKey             = mkPreludeClassUnique 12
1206 readClassKey            = mkPreludeClassUnique 13
1207 realClassKey            = mkPreludeClassUnique 14
1208 realFloatClassKey       = mkPreludeClassUnique 15
1209 realFracClassKey        = mkPreludeClassUnique 16
1210 showClassKey            = mkPreludeClassUnique 17
1211 ixClassKey              = mkPreludeClassUnique 18
1212
1213 typeableClassKey, typeable1ClassKey, typeable2ClassKey, typeable3ClassKey,
1214     typeable4ClassKey, typeable5ClassKey, typeable6ClassKey, typeable7ClassKey
1215     :: Unique
1216 typeableClassKey        = mkPreludeClassUnique 20
1217 typeable1ClassKey       = mkPreludeClassUnique 21
1218 typeable2ClassKey       = mkPreludeClassUnique 22
1219 typeable3ClassKey       = mkPreludeClassUnique 23
1220 typeable4ClassKey       = mkPreludeClassUnique 24
1221 typeable5ClassKey       = mkPreludeClassUnique 25
1222 typeable6ClassKey       = mkPreludeClassUnique 26
1223 typeable7ClassKey       = mkPreludeClassUnique 27
1224
1225 monadFixClassKey :: Unique
1226 monadFixClassKey        = mkPreludeClassUnique 28
1227
1228 monadPlusClassKey, randomClassKey, randomGenClassKey :: Unique
1229 monadPlusClassKey       = mkPreludeClassUnique 30
1230 randomClassKey          = mkPreludeClassUnique 31
1231 randomGenClassKey       = mkPreludeClassUnique 32
1232
1233 isStringClassKey :: Unique
1234 isStringClassKey        = mkPreludeClassUnique 33
1235
1236 applicativeClassKey, foldableClassKey, traversableClassKey :: Unique
1237 applicativeClassKey     = mkPreludeClassUnique 34
1238 foldableClassKey        = mkPreludeClassUnique 35
1239 traversableClassKey     = mkPreludeClassUnique 36
1240
1241 genClassKey, gen1ClassKey, datatypeClassKey, constructorClassKey,
1242   selectorClassKey :: Unique
1243 genClassKey   = mkPreludeClassUnique 37
1244 gen1ClassKey  = mkPreludeClassUnique 38
1245
1246 datatypeClassKey    = mkPreludeClassUnique 39
1247 constructorClassKey = mkPreludeClassUnique 40
1248 selectorClassKey    = mkPreludeClassUnique 41
1249
1250 -- SingI: see Note [SingI and EvLit] in TcEvidence
1251 singIClassNameKey, typeNatLeqClassNameKey :: Unique
1252 singIClassNameKey       = mkPreludeClassUnique 42
1253 typeNatLeqClassNameKey  = mkPreludeClassUnique 43
1254
1255 ghciIoClassKey :: Unique
1256 ghciIoClassKey = mkPreludeClassUnique 44
1257
1258 ipClassNameKey :: Unique
1259 ipClassNameKey = mkPreludeClassUnique 45
1260
1261 oldTypeableClassKey, oldTypeable1ClassKey, oldTypeable2ClassKey,
1262     oldTypeable3ClassKey, oldTypeable4ClassKey, oldTypeable5ClassKey,
1263     oldTypeable6ClassKey, oldTypeable7ClassKey :: Unique
1264 oldTypeableClassKey        = mkPreludeClassUnique 46
1265 oldTypeable1ClassKey       = mkPreludeClassUnique 47
1266 oldTypeable2ClassKey       = mkPreludeClassUnique 48
1267 oldTypeable3ClassKey       = mkPreludeClassUnique 49
1268 oldTypeable4ClassKey       = mkPreludeClassUnique 50
1269 oldTypeable5ClassKey       = mkPreludeClassUnique 51
1270 oldTypeable6ClassKey       = mkPreludeClassUnique 52
1271 oldTypeable7ClassKey       = mkPreludeClassUnique 53
1272 \end{code}
1273
1274 %************************************************************************
1275 %*                                                                      *
1276 \subsubsection[Uniques-prelude-TyCons]{@Uniques@ for wired-in @TyCons@}
1277 %*                                                                      *
1278 %************************************************************************
1279
1280 \begin{code}
1281 addrPrimTyConKey, arrayPrimTyConKey, arrayArrayPrimTyConKey, boolTyConKey, byteArrayPrimTyConKey,
1282     charPrimTyConKey, charTyConKey, doublePrimTyConKey, doubleTyConKey,
1283     floatPrimTyConKey, floatTyConKey, funTyConKey, intPrimTyConKey,
1284     intTyConKey, int8TyConKey, int16TyConKey, int32PrimTyConKey,
1285     int32TyConKey, int64PrimTyConKey, int64TyConKey,
1286     integerTyConKey, digitsTyConKey,
1287     listTyConKey, foreignObjPrimTyConKey, weakPrimTyConKey,
1288     mutableArrayPrimTyConKey, mutableArrayArrayPrimTyConKey, mutableByteArrayPrimTyConKey,
1289     orderingTyConKey, mVarPrimTyConKey, ratioTyConKey, rationalTyConKey,
1290     realWorldTyConKey, stablePtrPrimTyConKey, stablePtrTyConKey,
1291     anyTyConKey, eqTyConKey :: Unique
1292 addrPrimTyConKey                        = mkPreludeTyConUnique  1
1293 arrayPrimTyConKey                       = mkPreludeTyConUnique  3
1294 boolTyConKey                            = mkPreludeTyConUnique  4
1295 byteArrayPrimTyConKey                   = mkPreludeTyConUnique  5
1296 charPrimTyConKey                        = mkPreludeTyConUnique  7
1297 charTyConKey                            = mkPreludeTyConUnique  8
1298 doublePrimTyConKey                      = mkPreludeTyConUnique  9
1299 doubleTyConKey                          = mkPreludeTyConUnique 10
1300 floatPrimTyConKey                       = mkPreludeTyConUnique 11
1301 floatTyConKey                           = mkPreludeTyConUnique 12
1302 funTyConKey                             = mkPreludeTyConUnique 13
1303 intPrimTyConKey                         = mkPreludeTyConUnique 14
1304 intTyConKey                             = mkPreludeTyConUnique 15
1305 int8TyConKey                            = mkPreludeTyConUnique 16
1306 int16TyConKey                           = mkPreludeTyConUnique 17
1307 int32PrimTyConKey                       = mkPreludeTyConUnique 18
1308 int32TyConKey                           = mkPreludeTyConUnique 19
1309 int64PrimTyConKey                       = mkPreludeTyConUnique 20
1310 int64TyConKey                           = mkPreludeTyConUnique 21
1311 integerTyConKey                         = mkPreludeTyConUnique 22
1312 digitsTyConKey                          = mkPreludeTyConUnique 23
1313 listTyConKey                            = mkPreludeTyConUnique 24
1314 foreignObjPrimTyConKey                  = mkPreludeTyConUnique 25
1315 weakPrimTyConKey                        = mkPreludeTyConUnique 27
1316 mutableArrayPrimTyConKey                = mkPreludeTyConUnique 28
1317 mutableByteArrayPrimTyConKey            = mkPreludeTyConUnique 29
1318 orderingTyConKey                        = mkPreludeTyConUnique 30
1319 mVarPrimTyConKey                        = mkPreludeTyConUnique 31
1320 ratioTyConKey                           = mkPreludeTyConUnique 32
1321 rationalTyConKey                        = mkPreludeTyConUnique 33
1322 realWorldTyConKey                       = mkPreludeTyConUnique 34
1323 stablePtrPrimTyConKey                   = mkPreludeTyConUnique 35
1324 stablePtrTyConKey                       = mkPreludeTyConUnique 36
1325 anyTyConKey                             = mkPreludeTyConUnique 37
1326 eqTyConKey                              = mkPreludeTyConUnique 38
1327 arrayArrayPrimTyConKey                  = mkPreludeTyConUnique 39
1328 mutableArrayArrayPrimTyConKey           = mkPreludeTyConUnique 40
1329
1330 statePrimTyConKey, stableNamePrimTyConKey, stableNameTyConKey,
1331     mutVarPrimTyConKey, ioTyConKey,
1332     wordPrimTyConKey, wordTyConKey, word8TyConKey, word16TyConKey,
1333     word32PrimTyConKey, word32TyConKey, word64PrimTyConKey, word64TyConKey,
1334     liftedConKey, unliftedConKey, anyBoxConKey, kindConKey, boxityConKey,
1335     typeConKey, threadIdPrimTyConKey, bcoPrimTyConKey, ptrTyConKey,
1336     funPtrTyConKey, tVarPrimTyConKey, eqPrimTyConKey,
1337     eqReprPrimTyConKey :: Unique
1338 statePrimTyConKey                       = mkPreludeTyConUnique 50
1339 stableNamePrimTyConKey                  = mkPreludeTyConUnique 51
1340 stableNameTyConKey                      = mkPreludeTyConUnique 52
1341 eqPrimTyConKey                          = mkPreludeTyConUnique 53
1342 eqReprPrimTyConKey                      = mkPreludeTyConUnique 54
1343 mutVarPrimTyConKey                      = mkPreludeTyConUnique 55
1344 ioTyConKey                              = mkPreludeTyConUnique 56
1345 wordPrimTyConKey                        = mkPreludeTyConUnique 58
1346 wordTyConKey                            = mkPreludeTyConUnique 59
1347 word8TyConKey                           = mkPreludeTyConUnique 60
1348 word16TyConKey                          = mkPreludeTyConUnique 61
1349 word32PrimTyConKey                      = mkPreludeTyConUnique 62
1350 word32TyConKey                          = mkPreludeTyConUnique 63
1351 word64PrimTyConKey                      = mkPreludeTyConUnique 64
1352 word64TyConKey                          = mkPreludeTyConUnique 65
1353 liftedConKey                            = mkPreludeTyConUnique 66
1354 unliftedConKey                          = mkPreludeTyConUnique 67
1355 anyBoxConKey                            = mkPreludeTyConUnique 68
1356 kindConKey                              = mkPreludeTyConUnique 69
1357 boxityConKey                            = mkPreludeTyConUnique 70
1358 typeConKey                              = mkPreludeTyConUnique 71
1359 threadIdPrimTyConKey                    = mkPreludeTyConUnique 72
1360 bcoPrimTyConKey                         = mkPreludeTyConUnique 73
1361 ptrTyConKey                             = mkPreludeTyConUnique 74
1362 funPtrTyConKey                          = mkPreludeTyConUnique 75
1363 tVarPrimTyConKey                        = mkPreludeTyConUnique 76
1364
1365 -- Parallel array type constructor
1366 parrTyConKey :: Unique
1367 parrTyConKey                            = mkPreludeTyConUnique 82
1368
1369 -- dotnet interop
1370 objectTyConKey :: Unique
1371 objectTyConKey                          = mkPreludeTyConUnique 83
1372
1373 eitherTyConKey :: Unique
1374 eitherTyConKey                          = mkPreludeTyConUnique 84
1375
1376 -- Super Kinds constructors
1377 superKindTyConKey :: Unique
1378 superKindTyConKey                     = mkPreludeTyConUnique 85
1379
1380 -- Kind constructors
1381 liftedTypeKindTyConKey, anyKindTyConKey, openTypeKindTyConKey,
1382   unliftedTypeKindTyConKey, constraintKindTyConKey :: Unique
1383 anyKindTyConKey                         = mkPreludeTyConUnique 86
1384 liftedTypeKindTyConKey                  = mkPreludeTyConUnique 87
1385 openTypeKindTyConKey                    = mkPreludeTyConUnique 88
1386 unliftedTypeKindTyConKey                = mkPreludeTyConUnique 89
1387 constraintKindTyConKey                  = mkPreludeTyConUnique 92
1388
1389 -- Coercion constructors
1390 symCoercionTyConKey, transCoercionTyConKey, leftCoercionTyConKey,
1391     rightCoercionTyConKey, instCoercionTyConKey, unsafeCoercionTyConKey,
1392     csel1CoercionTyConKey, csel2CoercionTyConKey, cselRCoercionTyConKey
1393     :: Unique
1394 symCoercionTyConKey                     = mkPreludeTyConUnique 93
1395 transCoercionTyConKey                   = mkPreludeTyConUnique 94
1396 leftCoercionTyConKey                    = mkPreludeTyConUnique 95
1397 rightCoercionTyConKey                   = mkPreludeTyConUnique 96
1398 instCoercionTyConKey                    = mkPreludeTyConUnique 97
1399 unsafeCoercionTyConKey                  = mkPreludeTyConUnique 98
1400 csel1CoercionTyConKey                   = mkPreludeTyConUnique 99
1401 csel2CoercionTyConKey                   = mkPreludeTyConUnique 100
1402 cselRCoercionTyConKey                   = mkPreludeTyConUnique 101
1403
1404 pluginTyConKey :: Unique
1405 pluginTyConKey                          = mkPreludeTyConUnique 102
1406
1407 unknownTyConKey, unknown1TyConKey, unknown2TyConKey, unknown3TyConKey,
1408     opaqueTyConKey :: Unique
1409 unknownTyConKey                         = mkPreludeTyConUnique 129
1410 unknown1TyConKey                        = mkPreludeTyConUnique 130
1411 unknown2TyConKey                        = mkPreludeTyConUnique 131
1412 unknown3TyConKey                        = mkPreludeTyConUnique 132
1413 opaqueTyConKey                          = mkPreludeTyConUnique 133
1414
1415 stringTyConKey :: Unique
1416 stringTyConKey                          = mkPreludeTyConUnique 134
1417
1418 -- Generics (Unique keys)
1419 v1TyConKey, u1TyConKey, par1TyConKey, rec1TyConKey,
1420   k1TyConKey, m1TyConKey, sumTyConKey, prodTyConKey,
1421   compTyConKey, rTyConKey, pTyConKey, dTyConKey,
1422   cTyConKey, sTyConKey, rec0TyConKey, par0TyConKey,
1423   d1TyConKey, c1TyConKey, s1TyConKey, noSelTyConKey,
1424   repTyConKey, rep1TyConKey :: Unique
1425
1426 v1TyConKey    = mkPreludeTyConUnique 135
1427 u1TyConKey    = mkPreludeTyConUnique 136
1428 par1TyConKey  = mkPreludeTyConUnique 137
1429 rec1TyConKey  = mkPreludeTyConUnique 138
1430 k1TyConKey    = mkPreludeTyConUnique 139
1431 m1TyConKey    = mkPreludeTyConUnique 140
1432
1433 sumTyConKey   = mkPreludeTyConUnique 141
1434 prodTyConKey  = mkPreludeTyConUnique 142
1435 compTyConKey  = mkPreludeTyConUnique 143
1436
1437 rTyConKey = mkPreludeTyConUnique 144
1438 pTyConKey = mkPreludeTyConUnique 145
1439 dTyConKey = mkPreludeTyConUnique 146
1440 cTyConKey = mkPreludeTyConUnique 147
1441 sTyConKey = mkPreludeTyConUnique 148
1442
1443 rec0TyConKey  = mkPreludeTyConUnique 149
1444 par0TyConKey  = mkPreludeTyConUnique 150
1445 d1TyConKey    = mkPreludeTyConUnique 151
1446 c1TyConKey    = mkPreludeTyConUnique 152
1447 s1TyConKey    = mkPreludeTyConUnique 153
1448 noSelTyConKey = mkPreludeTyConUnique 154
1449
1450 repTyConKey  = mkPreludeTyConUnique 155
1451 rep1TyConKey = mkPreludeTyConUnique 156
1452
1453 -- Type-level naturals
1454 typeNatKindConNameKey, typeSymbolKindConNameKey,
1455   typeNatAddTyFamNameKey, typeNatMulTyFamNameKey, typeNatExpTyFamNameKey
1456   :: Unique
1457 typeNatKindConNameKey     = mkPreludeTyConUnique 160
1458 typeSymbolKindConNameKey  = mkPreludeTyConUnique 161
1459 typeNatAddTyFamNameKey    = mkPreludeTyConUnique 162
1460 typeNatMulTyFamNameKey    = mkPreludeTyConUnique 163
1461 typeNatExpTyFamNameKey    = mkPreludeTyConUnique 164
1462
1463 -- SIMD vector types (Unique keys)
1464 floatX4PrimTyConKey, doubleX2PrimTyConKey, int32X4PrimTyConKey,
1465   int64X2PrimTyConKey :: Unique
1466
1467 floatX4PrimTyConKey  = mkPreludeTyConUnique 170
1468 doubleX2PrimTyConKey = mkPreludeTyConUnique 171
1469 int32X4PrimTyConKey  = mkPreludeTyConUnique 172
1470 int64X2PrimTyConKey  = mkPreludeTyConUnique 173
1471
1472 ---------------- Template Haskell -------------------
1473 --      USES TyConUniques 200-299
1474 -----------------------------------------------------
1475
1476 unitTyConKey :: Unique
1477 unitTyConKey = mkTupleTyConUnique BoxedTuple 0
1478 \end{code}
1479
1480 %************************************************************************
1481 %*                                                                      *
1482 \subsubsection[Uniques-prelude-DataCons]{@Uniques@ for wired-in @DataCons@}
1483 %*                                                                      *
1484 %************************************************************************
1485
1486 \begin{code}
1487 charDataConKey, consDataConKey, doubleDataConKey, falseDataConKey,
1488     floatDataConKey, intDataConKey, nilDataConKey, ratioDataConKey,
1489     stableNameDataConKey, trueDataConKey, wordDataConKey,
1490     ioDataConKey, integerDataConKey, eqBoxDataConKey :: Unique
1491 charDataConKey                          = mkPreludeDataConUnique  1
1492 consDataConKey                          = mkPreludeDataConUnique  2
1493 doubleDataConKey                        = mkPreludeDataConUnique  3
1494 falseDataConKey                         = mkPreludeDataConUnique  4
1495 floatDataConKey                         = mkPreludeDataConUnique  5
1496 intDataConKey                           = mkPreludeDataConUnique  6
1497 nilDataConKey                           = mkPreludeDataConUnique 11
1498 ratioDataConKey                         = mkPreludeDataConUnique 12
1499 stableNameDataConKey                    = mkPreludeDataConUnique 14
1500 trueDataConKey                          = mkPreludeDataConUnique 15
1501 wordDataConKey                          = mkPreludeDataConUnique 16
1502 ioDataConKey                            = mkPreludeDataConUnique 17
1503 integerDataConKey                       = mkPreludeDataConUnique 18
1504 eqBoxDataConKey                         = mkPreludeDataConUnique 19
1505
1506 -- Generic data constructors
1507 crossDataConKey, inlDataConKey, inrDataConKey, genUnitDataConKey :: Unique
1508 crossDataConKey                         = mkPreludeDataConUnique 20
1509 inlDataConKey                           = mkPreludeDataConUnique 21
1510 inrDataConKey                           = mkPreludeDataConUnique 22
1511 genUnitDataConKey                       = mkPreludeDataConUnique 23
1512
1513 -- Data constructor for parallel arrays
1514 parrDataConKey :: Unique
1515 parrDataConKey                          = mkPreludeDataConUnique 24
1516
1517 leftDataConKey, rightDataConKey :: Unique
1518 leftDataConKey                          = mkPreludeDataConUnique 25
1519 rightDataConKey                         = mkPreludeDataConUnique 26
1520
1521 ltDataConKey, eqDataConKey, gtDataConKey :: Unique
1522 ltDataConKey                            = mkPreludeDataConUnique 27
1523 eqDataConKey                            = mkPreludeDataConUnique 28
1524 gtDataConKey                            = mkPreludeDataConUnique 29
1525
1526 -- For integer-gmp only
1527 integerGmpSDataConKey, integerGmpJDataConKey :: Unique
1528 integerGmpSDataConKey                   = mkPreludeDataConUnique 30
1529 integerGmpJDataConKey                   = mkPreludeDataConUnique 31
1530 \end{code}
1531
1532 %************************************************************************
1533 %*                                                                      *
1534 \subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}
1535 %*                                                                      *
1536 %************************************************************************
1537
1538 \begin{code}
1539 wildCardKey, absentErrorIdKey, augmentIdKey, appendIdKey,
1540     buildIdKey, errorIdKey, foldrIdKey, recSelErrorIdKey,
1541     seqIdKey, irrefutPatErrorIdKey, eqStringIdKey,
1542     noMethodBindingErrorIdKey, nonExhaustiveGuardsErrorIdKey,
1543     runtimeErrorIdKey, patErrorIdKey,
1544     realWorldPrimIdKey, recConErrorIdKey,
1545     unpackCStringUtf8IdKey, unpackCStringAppendIdKey,
1546     unpackCStringFoldrIdKey, unpackCStringIdKey :: Unique
1547 wildCardKey                   = mkPreludeMiscIdUnique  0  -- See Note [WildCard]
1548 absentErrorIdKey              = mkPreludeMiscIdUnique  1
1549 augmentIdKey                  = mkPreludeMiscIdUnique  2
1550 appendIdKey                   = mkPreludeMiscIdUnique  3
1551 buildIdKey                    = mkPreludeMiscIdUnique  4
1552 errorIdKey                    = mkPreludeMiscIdUnique  5
1553 foldrIdKey                    = mkPreludeMiscIdUnique  6
1554 recSelErrorIdKey              = mkPreludeMiscIdUnique  7
1555 seqIdKey                      = mkPreludeMiscIdUnique  8
1556 irrefutPatErrorIdKey          = mkPreludeMiscIdUnique  9
1557 eqStringIdKey                 = mkPreludeMiscIdUnique 10
1558 noMethodBindingErrorIdKey     = mkPreludeMiscIdUnique 11
1559 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 12
1560 runtimeErrorIdKey             = mkPreludeMiscIdUnique 13
1561 patErrorIdKey                 = mkPreludeMiscIdUnique 14
1562 realWorldPrimIdKey            = mkPreludeMiscIdUnique 15
1563 recConErrorIdKey              = mkPreludeMiscIdUnique 16
1564 unpackCStringUtf8IdKey        = mkPreludeMiscIdUnique 17
1565 unpackCStringAppendIdKey      = mkPreludeMiscIdUnique 18
1566 unpackCStringFoldrIdKey       = mkPreludeMiscIdUnique 19
1567 unpackCStringIdKey            = mkPreludeMiscIdUnique 20
1568
1569 unsafeCoerceIdKey, concatIdKey, filterIdKey, zipIdKey, bindIOIdKey,
1570     returnIOIdKey, newStablePtrIdKey,
1571     printIdKey, failIOIdKey, nullAddrIdKey, voidArgIdKey,
1572     fstIdKey, sndIdKey, otherwiseIdKey, assertIdKey, runSTRepIdKey :: Unique
1573 unsafeCoerceIdKey             = mkPreludeMiscIdUnique 30
1574 concatIdKey                   = mkPreludeMiscIdUnique 31
1575 filterIdKey                   = mkPreludeMiscIdUnique 32
1576 zipIdKey                      = mkPreludeMiscIdUnique 33
1577 bindIOIdKey                   = mkPreludeMiscIdUnique 34
1578 returnIOIdKey                 = mkPreludeMiscIdUnique 35
1579 newStablePtrIdKey             = mkPreludeMiscIdUnique 36
1580 printIdKey                    = mkPreludeMiscIdUnique 37
1581 failIOIdKey                   = mkPreludeMiscIdUnique 38
1582 nullAddrIdKey                 = mkPreludeMiscIdUnique 39
1583 voidArgIdKey                  = mkPreludeMiscIdUnique 40
1584 fstIdKey                      = mkPreludeMiscIdUnique 41
1585 sndIdKey                      = mkPreludeMiscIdUnique 42
1586 otherwiseIdKey                = mkPreludeMiscIdUnique 43
1587 assertIdKey                   = mkPreludeMiscIdUnique 44
1588 runSTRepIdKey                 = mkPreludeMiscIdUnique 45
1589
1590 mkIntegerIdKey, smallIntegerIdKey, wordToIntegerIdKey,
1591     integerToWordIdKey, integerToIntIdKey,
1592     integerToWord64IdKey, integerToInt64IdKey,
1593     word64ToIntegerIdKey, int64ToIntegerIdKey,
1594     plusIntegerIdKey, timesIntegerIdKey, minusIntegerIdKey,
1595     negateIntegerIdKey,
1596     eqIntegerIdKey, neqIntegerIdKey, absIntegerIdKey, signumIntegerIdKey,
1597     leIntegerIdKey, gtIntegerIdKey, ltIntegerIdKey, geIntegerIdKey,
1598     compareIntegerIdKey, quotRemIntegerIdKey, divModIntegerIdKey,
1599     quotIntegerIdKey, remIntegerIdKey,
1600     floatFromIntegerIdKey, doubleFromIntegerIdKey,
1601     encodeFloatIntegerIdKey, encodeDoubleIntegerIdKey,
1602     decodeDoubleIntegerIdKey,
1603     gcdIntegerIdKey, lcmIntegerIdKey,
1604     andIntegerIdKey, orIntegerIdKey, xorIntegerIdKey, complementIntegerIdKey,
1605     shiftLIntegerIdKey, shiftRIntegerIdKey :: Unique
1606 mkIntegerIdKey                = mkPreludeMiscIdUnique 60
1607 smallIntegerIdKey             = mkPreludeMiscIdUnique 61
1608 integerToWordIdKey            = mkPreludeMiscIdUnique 62
1609 integerToIntIdKey             = mkPreludeMiscIdUnique 63
1610 integerToWord64IdKey          = mkPreludeMiscIdUnique 64
1611 integerToInt64IdKey           = mkPreludeMiscIdUnique 65
1612 plusIntegerIdKey              = mkPreludeMiscIdUnique 66
1613 timesIntegerIdKey             = mkPreludeMiscIdUnique 67
1614 minusIntegerIdKey             = mkPreludeMiscIdUnique 68
1615 negateIntegerIdKey            = mkPreludeMiscIdUnique 69
1616 eqIntegerIdKey                = mkPreludeMiscIdUnique 70
1617 neqIntegerIdKey               = mkPreludeMiscIdUnique 71
1618 absIntegerIdKey               = mkPreludeMiscIdUnique 72
1619 signumIntegerIdKey            = mkPreludeMiscIdUnique 73
1620 leIntegerIdKey                = mkPreludeMiscIdUnique 74
1621 gtIntegerIdKey                = mkPreludeMiscIdUnique 75
1622 ltIntegerIdKey                = mkPreludeMiscIdUnique 76
1623 geIntegerIdKey                = mkPreludeMiscIdUnique 77
1624 compareIntegerIdKey           = mkPreludeMiscIdUnique 78
1625 quotRemIntegerIdKey           = mkPreludeMiscIdUnique 79
1626 divModIntegerIdKey            = mkPreludeMiscIdUnique 80
1627 quotIntegerIdKey              = mkPreludeMiscIdUnique 81
1628 remIntegerIdKey               = mkPreludeMiscIdUnique 82
1629 floatFromIntegerIdKey         = mkPreludeMiscIdUnique 83
1630 doubleFromIntegerIdKey        = mkPreludeMiscIdUnique 84
1631 encodeFloatIntegerIdKey       = mkPreludeMiscIdUnique 85
1632 encodeDoubleIntegerIdKey      = mkPreludeMiscIdUnique 86
1633 gcdIntegerIdKey               = mkPreludeMiscIdUnique 87
1634 lcmIntegerIdKey               = mkPreludeMiscIdUnique 88
1635 andIntegerIdKey               = mkPreludeMiscIdUnique 89
1636 orIntegerIdKey                = mkPreludeMiscIdUnique 90
1637 xorIntegerIdKey               = mkPreludeMiscIdUnique 91
1638 complementIntegerIdKey        = mkPreludeMiscIdUnique 92
1639 shiftLIntegerIdKey            = mkPreludeMiscIdUnique 93
1640 shiftRIntegerIdKey            = mkPreludeMiscIdUnique 94
1641 wordToIntegerIdKey            = mkPreludeMiscIdUnique 95
1642 word64ToIntegerIdKey          = mkPreludeMiscIdUnique 96
1643 int64ToIntegerIdKey           = mkPreludeMiscIdUnique 97
1644 decodeDoubleIntegerIdKey      = mkPreludeMiscIdUnique 98
1645
1646 rootMainKey, runMainKey :: Unique
1647 rootMainKey                   = mkPreludeMiscIdUnique 100
1648 runMainKey                    = mkPreludeMiscIdUnique 101
1649
1650 thenIOIdKey, lazyIdKey, assertErrorIdKey :: Unique
1651 thenIOIdKey                   = mkPreludeMiscIdUnique 102
1652 lazyIdKey                     = mkPreludeMiscIdUnique 103
1653 assertErrorIdKey              = mkPreludeMiscIdUnique 104
1654
1655 breakpointIdKey, breakpointCondIdKey, breakpointAutoIdKey,
1656     breakpointJumpIdKey, breakpointCondJumpIdKey,
1657     breakpointAutoJumpIdKey :: Unique
1658 breakpointIdKey               = mkPreludeMiscIdUnique 110
1659 breakpointCondIdKey           = mkPreludeMiscIdUnique 111
1660 breakpointAutoIdKey           = mkPreludeMiscIdUnique 112
1661 breakpointJumpIdKey           = mkPreludeMiscIdUnique 113
1662 breakpointCondJumpIdKey       = mkPreludeMiscIdUnique 114
1663 breakpointAutoJumpIdKey       = mkPreludeMiscIdUnique 115
1664
1665 inlineIdKey :: Unique
1666 inlineIdKey                   = mkPreludeMiscIdUnique 120
1667
1668 mapIdKey, groupWithIdKey, dollarIdKey :: Unique
1669 mapIdKey              = mkPreludeMiscIdUnique 121
1670 groupWithIdKey        = mkPreludeMiscIdUnique 122
1671 dollarIdKey           = mkPreludeMiscIdUnique 123
1672
1673 coercionTokenIdKey :: Unique
1674 coercionTokenIdKey    = mkPreludeMiscIdUnique 124
1675
1676 rationalToFloatIdKey, rationalToDoubleIdKey :: Unique
1677 rationalToFloatIdKey   = mkPreludeMiscIdUnique 130
1678 rationalToDoubleIdKey  = mkPreludeMiscIdUnique 131
1679
1680 -- dotnet interop
1681 unmarshalObjectIdKey, marshalObjectIdKey, marshalStringIdKey,
1682     unmarshalStringIdKey, checkDotnetResNameIdKey :: Unique
1683 unmarshalObjectIdKey          = mkPreludeMiscIdUnique 150
1684 marshalObjectIdKey            = mkPreludeMiscIdUnique 151
1685 marshalStringIdKey            = mkPreludeMiscIdUnique 152
1686 unmarshalStringIdKey          = mkPreludeMiscIdUnique 153
1687 checkDotnetResNameIdKey       = mkPreludeMiscIdUnique 154
1688
1689 undefinedKey :: Unique
1690 undefinedKey                  = mkPreludeMiscIdUnique 155
1691
1692 magicSingIKey :: Unique
1693 magicSingIKey              = mkPreludeMiscIdUnique 156
1694 \end{code}
1695
1696 Certain class operations from Prelude classes.  They get their own
1697 uniques so we can look them up easily when we want to conjure them up
1698 during type checking.
1699
1700 \begin{code}
1701         -- Just a place holder for  unbound variables  produced by the renamer:
1702 unboundKey :: Unique
1703 unboundKey                    = mkPreludeMiscIdUnique 160
1704
1705 fromIntegerClassOpKey, minusClassOpKey, fromRationalClassOpKey,
1706     enumFromClassOpKey, enumFromThenClassOpKey, enumFromToClassOpKey,
1707     enumFromThenToClassOpKey, eqClassOpKey, geClassOpKey, negateClassOpKey,
1708     failMClassOpKey, bindMClassOpKey, thenMClassOpKey, returnMClassOpKey,
1709     fmapClassOpKey
1710     :: Unique
1711 fromIntegerClassOpKey         = mkPreludeMiscIdUnique 160
1712 minusClassOpKey               = mkPreludeMiscIdUnique 161
1713 fromRationalClassOpKey        = mkPreludeMiscIdUnique 162
1714 enumFromClassOpKey            = mkPreludeMiscIdUnique 163
1715 enumFromThenClassOpKey        = mkPreludeMiscIdUnique 164
1716 enumFromToClassOpKey          = mkPreludeMiscIdUnique 165
1717 enumFromThenToClassOpKey      = mkPreludeMiscIdUnique 166
1718 eqClassOpKey                  = mkPreludeMiscIdUnique 167
1719 geClassOpKey                  = mkPreludeMiscIdUnique 168
1720 negateClassOpKey              = mkPreludeMiscIdUnique 169
1721 failMClassOpKey               = mkPreludeMiscIdUnique 170
1722 bindMClassOpKey               = mkPreludeMiscIdUnique 171 -- (>>=)
1723 thenMClassOpKey               = mkPreludeMiscIdUnique 172 -- (>>)
1724 fmapClassOpKey                = mkPreludeMiscIdUnique 173
1725 returnMClassOpKey             = mkPreludeMiscIdUnique 174
1726
1727 -- Recursive do notation
1728 mfixIdKey :: Unique
1729 mfixIdKey       = mkPreludeMiscIdUnique 175
1730
1731 -- Arrow notation
1732 arrAIdKey, composeAIdKey, firstAIdKey, appAIdKey, choiceAIdKey,
1733     loopAIdKey :: Unique
1734 arrAIdKey       = mkPreludeMiscIdUnique 180
1735 composeAIdKey   = mkPreludeMiscIdUnique 181 -- >>>
1736 firstAIdKey     = mkPreludeMiscIdUnique 182
1737 appAIdKey       = mkPreludeMiscIdUnique 183
1738 choiceAIdKey    = mkPreludeMiscIdUnique 184 --  |||
1739 loopAIdKey      = mkPreludeMiscIdUnique 185
1740
1741 fromStringClassOpKey :: Unique
1742 fromStringClassOpKey          = mkPreludeMiscIdUnique 186
1743
1744 -- Annotation type checking
1745 toAnnotationWrapperIdKey :: Unique
1746 toAnnotationWrapperIdKey      = mkPreludeMiscIdUnique 187
1747
1748 -- Conversion functions
1749 fromIntegralIdKey, realToFracIdKey, toIntegerClassOpKey, toRationalClassOpKey :: Unique
1750 fromIntegralIdKey    = mkPreludeMiscIdUnique 190
1751 realToFracIdKey      = mkPreludeMiscIdUnique 191
1752 toIntegerClassOpKey  = mkPreludeMiscIdUnique 192
1753 toRationalClassOpKey = mkPreludeMiscIdUnique 193
1754
1755 -- Monad comprehensions
1756 guardMIdKey, liftMIdKey, mzipIdKey :: Unique
1757 guardMIdKey     = mkPreludeMiscIdUnique 194
1758 liftMIdKey      = mkPreludeMiscIdUnique 195
1759 mzipIdKey       = mkPreludeMiscIdUnique 196
1760
1761 -- GHCi
1762 ghciStepIoMClassOpKey :: Unique
1763 ghciStepIoMClassOpKey = mkPreludeMiscIdUnique 197
1764
1765 -- Overloaded lists
1766 isListClassKey, fromListClassOpKey, fromListNClassOpKey, toListClassOpKey :: Unique
1767 isListClassKey = mkPreludeMiscIdUnique 198
1768 fromListClassOpKey = mkPreludeMiscIdUnique 199
1769 fromListNClassOpKey = mkPreludeMiscIdUnique 500
1770 toListClassOpKey = mkPreludeMiscIdUnique 501
1771
1772 ---------------- Template Haskell -------------------
1773 --      USES IdUniques 200-499
1774 -----------------------------------------------------
1775 \end{code}
1776
1777 %************************************************************************
1778 %*                                                                      *
1779 \subsection[Class-std-groups]{Standard groups of Prelude classes}
1780 %*                                                                      *
1781 %************************************************************************
1782
1783 NOTE: @Eq@ and @Text@ do need to appear in @standardClasses@
1784 even though every numeric class has these two as a superclass,
1785 because the list of ambiguous dictionaries hasn't been simplified.
1786
1787 \begin{code}
1788 numericClassKeys :: [Unique]
1789 numericClassKeys =
1790         [ numClassKey
1791         , realClassKey
1792         , integralClassKey
1793         ]
1794         ++ fractionalClassKeys
1795
1796 fractionalClassKeys :: [Unique]
1797 fractionalClassKeys =
1798         [ fractionalClassKey
1799         , floatingClassKey
1800         , realFracClassKey
1801         , realFloatClassKey
1802         ]
1803
1804 -- The "standard classes" are used in defaulting (Haskell 98 report 4.3.4),
1805 -- and are: "classes defined in the Prelude or a standard library"
1806 standardClassKeys :: [Unique]
1807 standardClassKeys = derivableClassKeys ++ numericClassKeys
1808                   ++ [randomClassKey, randomGenClassKey,
1809                       functorClassKey,
1810                       monadClassKey, monadPlusClassKey,
1811                       isStringClassKey,
1812                       applicativeClassKey, foldableClassKey, traversableClassKey
1813                      ]
1814 \end{code}
1815
1816 @derivableClassKeys@ is also used in checking \tr{deriving} constructs
1817 (@TcDeriv@).
1818
1819 \begin{code}
1820 derivableClassKeys :: [Unique]
1821 derivableClassKeys
1822   = [ eqClassKey, ordClassKey, enumClassKey, ixClassKey,
1823       boundedClassKey, showClassKey, readClassKey ]
1824 \end{code}
1825