Comparison primops return Int# (Fixes #6135)
[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, eqIntegerPrimName, neqIntegerPrimName,
269         absIntegerName, signumIntegerName,
270         leIntegerPrimName, gtIntegerPrimName, ltIntegerPrimName, geIntegerPrimName,
271         compareIntegerName, quotRemIntegerName, divModIntegerName,
272         quotIntegerName, remIntegerName, divIntegerName, modIntegerName,
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_PRIMWRAPPERS, gHC_TYPES, gHC_GENERICS, gHC_MAGIC,
354     gHC_CLASSES, gHC_BASE, gHC_ENUM, gHC_GHCI, gHC_CSTRING,
355     gHC_SHOW, gHC_READ, gHC_NUM, gHC_INTEGER_TYPE, gHC_LIST,
356     gHC_TUPLE, dATA_TUPLE, dATA_EITHER, dATA_STRING, dATA_FOLDABLE, dATA_TRAVERSABLE, dATA_MONOID,
357     gHC_CONC, gHC_IO, gHC_IO_Exception,
358     gHC_ST, gHC_ARR, gHC_STABLE, gHC_PTR, gHC_ERR, gHC_REAL,
359     gHC_FLOAT, gHC_TOP_HANDLER, sYSTEM_IO, dYNAMIC,
360     tYPEABLE, tYPEABLE_INTERNAL, oLDTYPEABLE, oLDTYPEABLE_INTERNAL, gENERICS,
361     dOTNET, rEAD_PREC, lEX, gHC_INT, gHC_WORD, mONAD, mONAD_FIX, mONAD_ZIP,
362     aRROW, cONTROL_APPLICATIVE, gHC_DESUGAR, rANDOM, gHC_EXTS,
363     cONTROL_EXCEPTION_BASE, gHC_TYPELITS, gHC_IP :: Module
364
365 gHC_PRIM        = mkPrimModule (fsLit "GHC.Prim")   -- Primitive types and values
366 gHC_PRIMWRAPPERS = mkPrimModule (fsLit "GHC.PrimWrappers")
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 :: RdrName
562 newStablePtr_RDR        = nameRdrName newStablePtrName
563
564 bindIO_RDR, returnIO_RDR :: RdrName
565 bindIO_RDR              = nameRdrName bindIOName
566 returnIO_RDR            = nameRdrName returnIOName
567
568 fromInteger_RDR, fromRational_RDR, minus_RDR, times_RDR, plus_RDR :: RdrName
569 fromInteger_RDR         = nameRdrName fromIntegerName
570 fromRational_RDR        = nameRdrName fromRationalName
571 minus_RDR               = nameRdrName minusName
572 times_RDR               = varQual_RDR  gHC_NUM (fsLit "*")
573 plus_RDR                = varQual_RDR gHC_NUM (fsLit "+")
574
575 fromString_RDR :: RdrName
576 fromString_RDR          = nameRdrName fromStringName
577
578 fromList_RDR, fromListN_RDR, toList_RDR :: RdrName
579 fromList_RDR = nameRdrName fromListName
580 fromListN_RDR = nameRdrName fromListNName
581 toList_RDR = nameRdrName toListName
582
583 compose_RDR :: RdrName
584 compose_RDR             = varQual_RDR gHC_BASE (fsLit ".")
585
586 not_RDR, getTag_RDR, succ_RDR, pred_RDR, minBound_RDR, maxBound_RDR,
587     and_RDR, range_RDR, inRange_RDR, index_RDR,
588     unsafeIndex_RDR, unsafeRangeSize_RDR :: RdrName
589 and_RDR                 = varQual_RDR gHC_CLASSES (fsLit "&&")
590 not_RDR                 = varQual_RDR gHC_CLASSES (fsLit "not")
591 getTag_RDR              = varQual_RDR gHC_BASE (fsLit "getTag")
592 succ_RDR                = varQual_RDR gHC_ENUM (fsLit "succ")
593 pred_RDR                = varQual_RDR gHC_ENUM (fsLit "pred")
594 minBound_RDR            = varQual_RDR gHC_ENUM (fsLit "minBound")
595 maxBound_RDR            = varQual_RDR gHC_ENUM (fsLit "maxBound")
596 range_RDR               = varQual_RDR gHC_ARR (fsLit "range")
597 inRange_RDR             = varQual_RDR gHC_ARR (fsLit "inRange")
598 index_RDR               = varQual_RDR gHC_ARR (fsLit "index")
599 unsafeIndex_RDR         = varQual_RDR gHC_ARR (fsLit "unsafeIndex")
600 unsafeRangeSize_RDR     = varQual_RDR gHC_ARR (fsLit "unsafeRangeSize")
601
602 readList_RDR, readListDefault_RDR, readListPrec_RDR, readListPrecDefault_RDR,
603     readPrec_RDR, parens_RDR, choose_RDR, lexP_RDR, expectP_RDR :: RdrName
604 readList_RDR            = varQual_RDR gHC_READ (fsLit "readList")
605 readListDefault_RDR     = varQual_RDR gHC_READ (fsLit "readListDefault")
606 readListPrec_RDR        = varQual_RDR gHC_READ (fsLit "readListPrec")
607 readListPrecDefault_RDR = varQual_RDR gHC_READ (fsLit "readListPrecDefault")
608 readPrec_RDR            = varQual_RDR gHC_READ (fsLit "readPrec")
609 parens_RDR              = varQual_RDR gHC_READ (fsLit "parens")
610 choose_RDR              = varQual_RDR gHC_READ (fsLit "choose")
611 lexP_RDR                = varQual_RDR gHC_READ (fsLit "lexP")
612 expectP_RDR             = varQual_RDR gHC_READ (fsLit "expectP")
613
614 punc_RDR, ident_RDR, symbol_RDR :: RdrName
615 punc_RDR                = dataQual_RDR lEX (fsLit "Punc")
616 ident_RDR               = dataQual_RDR lEX (fsLit "Ident")
617 symbol_RDR              = dataQual_RDR lEX (fsLit "Symbol")
618
619 step_RDR, alt_RDR, reset_RDR, prec_RDR, pfail_RDR :: RdrName
620 step_RDR                = varQual_RDR  rEAD_PREC (fsLit "step")
621 alt_RDR                 = varQual_RDR  rEAD_PREC (fsLit "+++")
622 reset_RDR               = varQual_RDR  rEAD_PREC (fsLit "reset")
623 prec_RDR                = varQual_RDR  rEAD_PREC (fsLit "prec")
624 pfail_RDR               = varQual_RDR  rEAD_PREC (fsLit "pfail")
625
626 showList_RDR, showList___RDR, showsPrec_RDR, showString_RDR,
627     showSpace_RDR, showParen_RDR :: RdrName
628 showList_RDR            = varQual_RDR gHC_SHOW (fsLit "showList")
629 showList___RDR          = varQual_RDR gHC_SHOW (fsLit "showList__")
630 showsPrec_RDR           = varQual_RDR gHC_SHOW (fsLit "showsPrec")
631 showString_RDR          = varQual_RDR gHC_SHOW (fsLit "showString")
632 showSpace_RDR           = varQual_RDR gHC_SHOW (fsLit "showSpace")
633 showParen_RDR           = varQual_RDR gHC_SHOW (fsLit "showParen")
634
635 typeRep_RDR, mkTyCon_RDR, mkTyConApp_RDR,
636     oldTypeOf_RDR, oldMkTyCon_RDR, oldMkTyConApp_RDR :: RdrName
637 typeRep_RDR       = varQual_RDR tYPEABLE_INTERNAL    (fsLit "typeRep")
638 mkTyCon_RDR       = varQual_RDR tYPEABLE_INTERNAL    (fsLit "mkTyCon")
639 mkTyConApp_RDR    = varQual_RDR tYPEABLE_INTERNAL    (fsLit "mkTyConApp")
640 oldTypeOf_RDR     = varQual_RDR oLDTYPEABLE_INTERNAL (fsLit "typeOf")
641 oldMkTyCon_RDR    = varQual_RDR oLDTYPEABLE_INTERNAL (fsLit "mkTyCon")
642 oldMkTyConApp_RDR = varQual_RDR oLDTYPEABLE_INTERNAL (fsLit "mkTyConApp")
643
644 undefined_RDR :: RdrName
645 undefined_RDR = varQual_RDR gHC_ERR (fsLit "undefined")
646
647 error_RDR :: RdrName
648 error_RDR = varQual_RDR gHC_ERR (fsLit "error")
649
650 -- Generics (constructors and functions)
651 u1DataCon_RDR, par1DataCon_RDR, rec1DataCon_RDR,
652   k1DataCon_RDR, m1DataCon_RDR, l1DataCon_RDR, r1DataCon_RDR,
653   prodDataCon_RDR, comp1DataCon_RDR,
654   unPar1_RDR, unRec1_RDR, unK1_RDR, unComp1_RDR,
655   from_RDR, from1_RDR, to_RDR, to1_RDR,
656   datatypeName_RDR, moduleName_RDR, isNewtypeName_RDR,
657   conName_RDR, conFixity_RDR, conIsRecord_RDR,
658   noArityDataCon_RDR, arityDataCon_RDR, selName_RDR,
659   prefixDataCon_RDR, infixDataCon_RDR, leftAssocDataCon_RDR,
660   rightAssocDataCon_RDR, notAssocDataCon_RDR :: RdrName
661
662 u1DataCon_RDR    = dataQual_RDR gHC_GENERICS (fsLit "U1")
663 par1DataCon_RDR  = dataQual_RDR gHC_GENERICS (fsLit "Par1")
664 rec1DataCon_RDR  = dataQual_RDR gHC_GENERICS (fsLit "Rec1")
665 k1DataCon_RDR    = dataQual_RDR gHC_GENERICS (fsLit "K1")
666 m1DataCon_RDR    = dataQual_RDR gHC_GENERICS (fsLit "M1")
667
668 l1DataCon_RDR     = dataQual_RDR gHC_GENERICS (fsLit "L1")
669 r1DataCon_RDR     = dataQual_RDR gHC_GENERICS (fsLit "R1")
670
671 prodDataCon_RDR   = dataQual_RDR gHC_GENERICS (fsLit ":*:")
672 comp1DataCon_RDR  = dataQual_RDR gHC_GENERICS (fsLit "Comp1")
673
674 unPar1_RDR  = varQual_RDR gHC_GENERICS (fsLit "unPar1")
675 unRec1_RDR  = varQual_RDR gHC_GENERICS (fsLit "unRec1")
676 unK1_RDR    = varQual_RDR gHC_GENERICS (fsLit "unK1")
677 unComp1_RDR = varQual_RDR gHC_GENERICS (fsLit "unComp1")
678
679 from_RDR  = varQual_RDR gHC_GENERICS (fsLit "from")
680 from1_RDR = varQual_RDR gHC_GENERICS (fsLit "from1")
681 to_RDR    = varQual_RDR gHC_GENERICS (fsLit "to")
682 to1_RDR   = varQual_RDR gHC_GENERICS (fsLit "to1")
683
684 datatypeName_RDR  = varQual_RDR gHC_GENERICS (fsLit "datatypeName")
685 moduleName_RDR    = varQual_RDR gHC_GENERICS (fsLit "moduleName")
686 isNewtypeName_RDR = varQual_RDR gHC_GENERICS (fsLit "isNewtype")
687 selName_RDR       = varQual_RDR gHC_GENERICS (fsLit "selName")
688 conName_RDR       = varQual_RDR gHC_GENERICS (fsLit "conName")
689 conFixity_RDR     = varQual_RDR gHC_GENERICS (fsLit "conFixity")
690 conIsRecord_RDR   = varQual_RDR gHC_GENERICS (fsLit "conIsRecord")
691
692 noArityDataCon_RDR    = dataQual_RDR gHC_GENERICS (fsLit "NoArity")
693 arityDataCon_RDR      = dataQual_RDR gHC_GENERICS (fsLit "Arity")
694 prefixDataCon_RDR     = dataQual_RDR gHC_GENERICS (fsLit "Prefix")
695 infixDataCon_RDR      = dataQual_RDR gHC_GENERICS (fsLit "Infix")
696 leftAssocDataCon_RDR  = dataQual_RDR gHC_GENERICS (fsLit "LeftAssociative")
697 rightAssocDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "RightAssociative")
698 notAssocDataCon_RDR   = dataQual_RDR gHC_GENERICS (fsLit "NotAssociative")
699
700
701 fmap_RDR, pure_RDR, ap_RDR, foldable_foldr_RDR, foldMap_RDR,
702     traverse_RDR, mempty_RDR, mappend_RDR :: RdrName
703 fmap_RDR                = varQual_RDR gHC_BASE (fsLit "fmap")
704 pure_RDR                = varQual_RDR cONTROL_APPLICATIVE (fsLit "pure")
705 ap_RDR                  = varQual_RDR cONTROL_APPLICATIVE (fsLit "<*>")
706 foldable_foldr_RDR      = varQual_RDR dATA_FOLDABLE       (fsLit "foldr")
707 foldMap_RDR             = varQual_RDR dATA_FOLDABLE       (fsLit "foldMap")
708 traverse_RDR            = varQual_RDR dATA_TRAVERSABLE    (fsLit "traverse")
709 mempty_RDR              = varQual_RDR dATA_MONOID         (fsLit "mempty")
710 mappend_RDR             = varQual_RDR dATA_MONOID         (fsLit "mappend")
711
712 ----------------------
713 varQual_RDR, tcQual_RDR, clsQual_RDR, dataQual_RDR
714     :: Module -> FastString -> RdrName
715 varQual_RDR  mod str = mkOrig mod (mkOccNameFS varName str)
716 tcQual_RDR   mod str = mkOrig mod (mkOccNameFS tcName str)
717 clsQual_RDR  mod str = mkOrig mod (mkOccNameFS clsName str)
718 dataQual_RDR mod str = mkOrig mod (mkOccNameFS dataName str)
719 \end{code}
720
721 %************************************************************************
722 %*                                                                      *
723 \subsection{Known-key names}
724 %*                                                                      *
725 %************************************************************************
726
727 Many of these Names are not really "built in", but some parts of the
728 compiler (notably the deriving mechanism) need to mention their names,
729 and it's convenient to write them all down in one place.
730
731 --MetaHaskell Extension  add the constrs and the lower case case
732 -- guys as well (perhaps) e.g. see  trueDataConName     below
733
734
735 \begin{code}
736 wildCardName :: Name
737 wildCardName = mkSystemVarName wildCardKey (fsLit "wild")
738
739 runMainIOName :: Name
740 runMainIOName = varQual gHC_TOP_HANDLER (fsLit "runMainIO") runMainKey
741
742 orderingTyConName, ltDataConName, eqDataConName, gtDataConName :: Name
743 orderingTyConName = tcQual   gHC_TYPES (fsLit "Ordering") orderingTyConKey
744 ltDataConName = conName gHC_TYPES (fsLit "LT") ltDataConKey
745 eqDataConName = conName gHC_TYPES (fsLit "EQ") eqDataConKey
746 gtDataConName = conName gHC_TYPES (fsLit "GT") gtDataConKey
747
748 eitherTyConName, leftDataConName, rightDataConName :: Name
749 eitherTyConName   = tcQual  dATA_EITHER (fsLit "Either") eitherTyConKey
750 leftDataConName   = conName dATA_EITHER (fsLit "Left")   leftDataConKey
751 rightDataConName  = conName dATA_EITHER (fsLit "Right")  rightDataConKey
752
753 -- Generics (types)
754 v1TyConName, u1TyConName, par1TyConName, rec1TyConName,
755   k1TyConName, m1TyConName, sumTyConName, prodTyConName,
756   compTyConName, rTyConName, pTyConName, dTyConName,
757   cTyConName, sTyConName, rec0TyConName, par0TyConName,
758   d1TyConName, c1TyConName, s1TyConName, noSelTyConName,
759   repTyConName, rep1TyConName :: Name
760
761 v1TyConName  = tcQual gHC_GENERICS (fsLit "V1") v1TyConKey
762 u1TyConName  = tcQual gHC_GENERICS (fsLit "U1") u1TyConKey
763 par1TyConName  = tcQual gHC_GENERICS (fsLit "Par1") par1TyConKey
764 rec1TyConName  = tcQual gHC_GENERICS (fsLit "Rec1") rec1TyConKey
765 k1TyConName  = tcQual gHC_GENERICS (fsLit "K1") k1TyConKey
766 m1TyConName  = tcQual gHC_GENERICS (fsLit "M1") m1TyConKey
767
768 sumTyConName    = tcQual gHC_GENERICS (fsLit ":+:") sumTyConKey
769 prodTyConName   = tcQual gHC_GENERICS (fsLit ":*:") prodTyConKey
770 compTyConName   = tcQual gHC_GENERICS (fsLit ":.:") compTyConKey
771
772 rTyConName  = tcQual gHC_GENERICS (fsLit "R") rTyConKey
773 pTyConName  = tcQual gHC_GENERICS (fsLit "P") pTyConKey
774 dTyConName  = tcQual gHC_GENERICS (fsLit "D") dTyConKey
775 cTyConName  = tcQual gHC_GENERICS (fsLit "C") cTyConKey
776 sTyConName  = tcQual gHC_GENERICS (fsLit "S") sTyConKey
777
778 rec0TyConName  = tcQual gHC_GENERICS (fsLit "Rec0") rec0TyConKey
779 par0TyConName  = tcQual gHC_GENERICS (fsLit "Par0") par0TyConKey
780 d1TyConName  = tcQual gHC_GENERICS (fsLit "D1") d1TyConKey
781 c1TyConName  = tcQual gHC_GENERICS (fsLit "C1") c1TyConKey
782 s1TyConName  = tcQual gHC_GENERICS (fsLit "S1") s1TyConKey
783 noSelTyConName = tcQual gHC_GENERICS (fsLit "NoSelector") noSelTyConKey
784
785 repTyConName  = tcQual gHC_GENERICS (fsLit "Rep")  repTyConKey
786 rep1TyConName = tcQual gHC_GENERICS (fsLit "Rep1") rep1TyConKey
787
788 -- Base strings Strings
789 unpackCStringName, unpackCStringFoldrName,
790     unpackCStringUtf8Name, eqStringName, stringTyConName :: Name
791 unpackCStringName       = varQual gHC_CSTRING (fsLit "unpackCString#") unpackCStringIdKey
792 unpackCStringFoldrName  = varQual gHC_CSTRING (fsLit "unpackFoldrCString#") unpackCStringFoldrIdKey
793 unpackCStringUtf8Name   = varQual gHC_CSTRING (fsLit "unpackCStringUtf8#") unpackCStringUtf8IdKey
794 eqStringName            = varQual gHC_BASE (fsLit "eqString")  eqStringIdKey
795 stringTyConName         = tcQual  gHC_BASE (fsLit "String") stringTyConKey
796
797 -- The 'inline' function
798 inlineIdName :: Name
799 inlineIdName            = varQual gHC_MAGIC (fsLit "inline") inlineIdKey
800
801 -- Base classes (Eq, Ord, Functor)
802 fmapName, eqClassName, eqName, ordClassName, geName, functorClassName :: Name
803 eqClassName       = clsQual  gHC_CLASSES (fsLit "Eq")      eqClassKey
804 eqName            = methName gHC_CLASSES (fsLit "==")      eqClassOpKey
805 ordClassName      = clsQual  gHC_CLASSES (fsLit "Ord")     ordClassKey
806 geName            = methName gHC_CLASSES (fsLit ">=")      geClassOpKey
807 functorClassName  = clsQual  gHC_BASE (fsLit "Functor") functorClassKey
808 fmapName          = methName gHC_BASE (fsLit "fmap")    fmapClassOpKey
809
810 -- Class Monad
811 monadClassName, thenMName, bindMName, returnMName, failMName :: Name
812 monadClassName     = clsQual  gHC_BASE (fsLit "Monad")  monadClassKey
813 thenMName          = methName gHC_BASE (fsLit ">>")     thenMClassOpKey
814 bindMName          = methName gHC_BASE (fsLit ">>=")    bindMClassOpKey
815 returnMName        = methName gHC_BASE (fsLit "return") returnMClassOpKey
816 failMName          = methName gHC_BASE (fsLit "fail")   failMClassOpKey
817
818 -- Classes (Applicative, Foldable, Traversable)
819 applicativeClassName, foldableClassName, traversableClassName :: Name
820 applicativeClassName  = clsQual  cONTROL_APPLICATIVE (fsLit "Applicative") applicativeClassKey
821 foldableClassName     = clsQual  dATA_FOLDABLE       (fsLit "Foldable")    foldableClassKey
822 traversableClassName  = clsQual  dATA_TRAVERSABLE    (fsLit "Traversable") traversableClassKey
823
824 -- Functions for GHC extensions
825 groupWithName :: Name
826 groupWithName = varQual gHC_EXTS (fsLit "groupWith") groupWithIdKey
827
828 -- Random PrelBase functions
829 fromStringName, otherwiseIdName, foldrName, buildName, augmentName,
830     mapName, appendName, assertName,
831     breakpointName, breakpointCondName, breakpointAutoName,
832     dollarName, opaqueTyConName :: Name
833 fromStringName = methName dATA_STRING (fsLit "fromString") fromStringClassOpKey
834 otherwiseIdName   = varQual gHC_BASE (fsLit "otherwise")  otherwiseIdKey
835 foldrName         = varQual gHC_BASE (fsLit "foldr")      foldrIdKey
836 buildName         = varQual gHC_BASE (fsLit "build")      buildIdKey
837 augmentName       = varQual gHC_BASE (fsLit "augment")    augmentIdKey
838 mapName           = varQual gHC_BASE (fsLit "map")        mapIdKey
839 appendName        = varQual gHC_BASE (fsLit "++")         appendIdKey
840 dollarName        = varQual gHC_BASE (fsLit "$")          dollarIdKey
841 assertName        = varQual gHC_BASE (fsLit "assert")     assertIdKey
842 breakpointName    = varQual gHC_BASE (fsLit "breakpoint") breakpointIdKey
843 breakpointCondName= varQual gHC_BASE (fsLit "breakpointCond") breakpointCondIdKey
844 breakpointAutoName= varQual gHC_BASE (fsLit "breakpointAuto") breakpointAutoIdKey
845 opaqueTyConName   = tcQual  gHC_BASE (fsLit "Opaque")   opaqueTyConKey
846
847 breakpointJumpName :: Name
848 breakpointJumpName
849     = mkInternalName
850         breakpointJumpIdKey
851         (mkOccNameFS varName (fsLit "breakpointJump"))
852         noSrcSpan
853 breakpointCondJumpName :: Name
854 breakpointCondJumpName
855     = mkInternalName
856         breakpointCondJumpIdKey
857         (mkOccNameFS varName (fsLit "breakpointCondJump"))
858         noSrcSpan
859 breakpointAutoJumpName :: Name
860 breakpointAutoJumpName
861     = mkInternalName
862         breakpointAutoJumpIdKey
863         (mkOccNameFS varName (fsLit "breakpointAutoJump"))
864         noSrcSpan
865
866 -- PrelTup
867 fstName, sndName :: Name
868 fstName           = varQual dATA_TUPLE (fsLit "fst") fstIdKey
869 sndName           = varQual dATA_TUPLE (fsLit "snd") sndIdKey
870
871 -- Module GHC.Num
872 numClassName, fromIntegerName, minusName, negateName :: Name
873 numClassName      = clsQual  gHC_NUM (fsLit "Num") numClassKey
874 fromIntegerName   = methName gHC_NUM (fsLit "fromInteger") fromIntegerClassOpKey
875 minusName         = methName gHC_NUM (fsLit "-") minusClassOpKey
876 negateName        = methName gHC_NUM (fsLit "negate") negateClassOpKey
877
878 integerTyConName, mkIntegerName,
879     integerToWord64Name, integerToInt64Name,
880     word64ToIntegerName, int64ToIntegerName,
881     plusIntegerName, timesIntegerName, smallIntegerName,
882     wordToIntegerName,
883     integerToWordName, integerToIntName, minusIntegerName,
884     negateIntegerName, eqIntegerPrimName, neqIntegerPrimName,
885     absIntegerName, signumIntegerName,
886     leIntegerPrimName, gtIntegerPrimName, ltIntegerPrimName, geIntegerPrimName,
887     compareIntegerName, quotRemIntegerName, divModIntegerName,
888     quotIntegerName, remIntegerName, divIntegerName, modIntegerName,
889     floatFromIntegerName, doubleFromIntegerName,
890     encodeFloatIntegerName, encodeDoubleIntegerName,
891     decodeDoubleIntegerName,
892     gcdIntegerName, lcmIntegerName,
893     andIntegerName, orIntegerName, xorIntegerName, complementIntegerName,
894     shiftLIntegerName, shiftRIntegerName :: Name
895 integerTyConName      = tcQual  gHC_INTEGER_TYPE (fsLit "Integer")           integerTyConKey
896 mkIntegerName         = varQual gHC_INTEGER_TYPE (fsLit "mkInteger")         mkIntegerIdKey
897 integerToWord64Name   = varQual gHC_INTEGER_TYPE (fsLit "integerToWord64")   integerToWord64IdKey
898 integerToInt64Name    = varQual gHC_INTEGER_TYPE (fsLit "integerToInt64")    integerToInt64IdKey
899 word64ToIntegerName   = varQual gHC_INTEGER_TYPE (fsLit "word64ToInteger")   word64ToIntegerIdKey
900 int64ToIntegerName    = varQual gHC_INTEGER_TYPE (fsLit "int64ToInteger")    int64ToIntegerIdKey
901 plusIntegerName       = varQual gHC_INTEGER_TYPE (fsLit "plusInteger")       plusIntegerIdKey
902 timesIntegerName      = varQual gHC_INTEGER_TYPE (fsLit "timesInteger")      timesIntegerIdKey
903 smallIntegerName      = varQual gHC_INTEGER_TYPE (fsLit "smallInteger")      smallIntegerIdKey
904 wordToIntegerName     = varQual gHC_INTEGER_TYPE (fsLit "wordToInteger")     wordToIntegerIdKey
905 integerToWordName     = varQual gHC_INTEGER_TYPE (fsLit "integerToWord")     integerToWordIdKey
906 integerToIntName      = varQual gHC_INTEGER_TYPE (fsLit "integerToInt")      integerToIntIdKey
907 minusIntegerName      = varQual gHC_INTEGER_TYPE (fsLit "minusInteger")      minusIntegerIdKey
908 negateIntegerName     = varQual gHC_INTEGER_TYPE (fsLit "negateInteger")     negateIntegerIdKey
909 eqIntegerPrimName     = varQual gHC_INTEGER_TYPE (fsLit "eqInteger#")        eqIntegerPrimIdKey
910 neqIntegerPrimName    = varQual gHC_INTEGER_TYPE (fsLit "neqInteger#")       neqIntegerPrimIdKey
911 absIntegerName        = varQual gHC_INTEGER_TYPE (fsLit "absInteger")        absIntegerIdKey
912 signumIntegerName     = varQual gHC_INTEGER_TYPE (fsLit "signumInteger")     signumIntegerIdKey
913 leIntegerPrimName     = varQual gHC_INTEGER_TYPE (fsLit "leInteger#")        leIntegerPrimIdKey
914 gtIntegerPrimName     = varQual gHC_INTEGER_TYPE (fsLit "gtInteger#")        gtIntegerPrimIdKey
915 ltIntegerPrimName     = varQual gHC_INTEGER_TYPE (fsLit "ltInteger#")        ltIntegerPrimIdKey
916 geIntegerPrimName     = varQual gHC_INTEGER_TYPE (fsLit "geInteger#")        geIntegerPrimIdKey
917 compareIntegerName    = varQual gHC_INTEGER_TYPE (fsLit "compareInteger")    compareIntegerIdKey
918 quotRemIntegerName    = varQual gHC_INTEGER_TYPE (fsLit "quotRemInteger")    quotRemIntegerIdKey
919 divModIntegerName     = varQual gHC_INTEGER_TYPE (fsLit "divModInteger")     divModIntegerIdKey
920 quotIntegerName       = varQual gHC_INTEGER_TYPE (fsLit "quotInteger")       quotIntegerIdKey
921 remIntegerName        = varQual gHC_INTEGER_TYPE (fsLit "remInteger")        remIntegerIdKey
922 divIntegerName        = varQual gHC_INTEGER_TYPE (fsLit "divInteger")        divIntegerIdKey
923 modIntegerName        = varQual gHC_INTEGER_TYPE (fsLit "modInteger")        modIntegerIdKey
924 floatFromIntegerName  = varQual gHC_INTEGER_TYPE (fsLit "floatFromInteger")      floatFromIntegerIdKey
925 doubleFromIntegerName = varQual gHC_INTEGER_TYPE (fsLit "doubleFromInteger")     doubleFromIntegerIdKey
926 encodeFloatIntegerName  = varQual gHC_INTEGER_TYPE (fsLit "encodeFloatInteger")  encodeFloatIntegerIdKey
927 encodeDoubleIntegerName = varQual gHC_INTEGER_TYPE (fsLit "encodeDoubleInteger") encodeDoubleIntegerIdKey
928 decodeDoubleIntegerName = varQual gHC_INTEGER_TYPE (fsLit "decodeDoubleInteger") decodeDoubleIntegerIdKey
929 gcdIntegerName        = varQual gHC_INTEGER_TYPE (fsLit "gcdInteger")        gcdIntegerIdKey
930 lcmIntegerName        = varQual gHC_INTEGER_TYPE (fsLit "lcmInteger")        lcmIntegerIdKey
931 andIntegerName        = varQual gHC_INTEGER_TYPE (fsLit "andInteger")        andIntegerIdKey
932 orIntegerName         = varQual gHC_INTEGER_TYPE (fsLit "orInteger")         orIntegerIdKey
933 xorIntegerName        = varQual gHC_INTEGER_TYPE (fsLit "xorInteger")        xorIntegerIdKey
934 complementIntegerName = varQual gHC_INTEGER_TYPE (fsLit "complementInteger") complementIntegerIdKey
935 shiftLIntegerName     = varQual gHC_INTEGER_TYPE (fsLit "shiftLInteger")     shiftLIntegerIdKey
936 shiftRIntegerName     = varQual gHC_INTEGER_TYPE (fsLit "shiftRInteger")     shiftRIntegerIdKey
937
938 -- GHC.Real types and classes
939 rationalTyConName, ratioTyConName, ratioDataConName, realClassName,
940     integralClassName, realFracClassName, fractionalClassName,
941     fromRationalName, toIntegerName, toRationalName, fromIntegralName,
942     realToFracName :: Name
943 rationalTyConName   = tcQual  gHC_REAL (fsLit "Rational") rationalTyConKey
944 ratioTyConName      = tcQual  gHC_REAL (fsLit "Ratio") ratioTyConKey
945 ratioDataConName    = conName gHC_REAL (fsLit ":%") ratioDataConKey
946 realClassName       = clsQual gHC_REAL (fsLit "Real") realClassKey
947 integralClassName   = clsQual gHC_REAL (fsLit "Integral") integralClassKey
948 realFracClassName   = clsQual gHC_REAL (fsLit "RealFrac") realFracClassKey
949 fractionalClassName = clsQual gHC_REAL (fsLit "Fractional") fractionalClassKey
950 fromRationalName    = methName gHC_REAL (fsLit "fromRational") fromRationalClassOpKey
951 toIntegerName       = methName gHC_REAL (fsLit "toInteger") toIntegerClassOpKey
952 toRationalName      = methName gHC_REAL (fsLit "toRational") toRationalClassOpKey
953 fromIntegralName    = varQual  gHC_REAL (fsLit "fromIntegral") fromIntegralIdKey
954 realToFracName      = varQual  gHC_REAL (fsLit "realToFrac") realToFracIdKey
955
956 -- PrelFloat classes
957 floatingClassName, realFloatClassName :: Name
958 floatingClassName  = clsQual  gHC_FLOAT (fsLit "Floating") floatingClassKey
959 realFloatClassName = clsQual  gHC_FLOAT (fsLit "RealFloat") realFloatClassKey
960
961 -- other GHC.Float functions
962 rationalToFloatName, rationalToDoubleName :: Name
963 rationalToFloatName  = varQual gHC_FLOAT (fsLit "rationalToFloat") rationalToFloatIdKey
964 rationalToDoubleName = varQual gHC_FLOAT (fsLit "rationalToDouble") rationalToDoubleIdKey
965
966 -- Class Ix
967 ixClassName :: Name
968 ixClassName = clsQual gHC_ARR (fsLit "Ix") ixClassKey
969
970 -- Class Typeable
971 typeableClassName,
972     oldTypeableClassName, oldTypeable1ClassName, oldTypeable2ClassName,
973     oldTypeable3ClassName, oldTypeable4ClassName, oldTypeable5ClassName,
974     oldTypeable6ClassName, oldTypeable7ClassName :: Name
975 typeableClassName  = clsQual tYPEABLE_INTERNAL (fsLit "Typeable")  typeableClassKey
976 oldTypeableClassName  = clsQual oLDTYPEABLE_INTERNAL (fsLit "Typeable")  oldTypeableClassKey
977 oldTypeable1ClassName = clsQual oLDTYPEABLE_INTERNAL (fsLit "Typeable1") oldTypeable1ClassKey
978 oldTypeable2ClassName = clsQual oLDTYPEABLE_INTERNAL (fsLit "Typeable2") oldTypeable2ClassKey
979 oldTypeable3ClassName = clsQual oLDTYPEABLE_INTERNAL (fsLit "Typeable3") oldTypeable3ClassKey
980 oldTypeable4ClassName = clsQual oLDTYPEABLE_INTERNAL (fsLit "Typeable4") oldTypeable4ClassKey
981 oldTypeable5ClassName = clsQual oLDTYPEABLE_INTERNAL (fsLit "Typeable5") oldTypeable5ClassKey
982 oldTypeable6ClassName = clsQual oLDTYPEABLE_INTERNAL (fsLit "Typeable6") oldTypeable6ClassKey
983 oldTypeable7ClassName = clsQual oLDTYPEABLE_INTERNAL (fsLit "Typeable7") oldTypeable7ClassKey
984
985 oldTypeableClassNames :: [Name]
986 oldTypeableClassNames = [ oldTypeableClassName, oldTypeable1ClassName, oldTypeable2ClassName
987                         , oldTypeable3ClassName, oldTypeable4ClassName, oldTypeable5ClassName
988                         , oldTypeable6ClassName, oldTypeable7ClassName ]
989
990 -- Class Data
991 dataClassName :: Name
992 dataClassName = clsQual gENERICS (fsLit "Data") dataClassKey
993
994 -- Error module
995 assertErrorName    :: Name
996 assertErrorName   = varQual gHC_IO_Exception (fsLit "assertError") assertErrorIdKey
997
998 -- Enum module (Enum, Bounded)
999 enumClassName, enumFromName, enumFromToName, enumFromThenName,
1000     enumFromThenToName, boundedClassName :: Name
1001 enumClassName      = clsQual gHC_ENUM (fsLit "Enum") enumClassKey
1002 enumFromName       = methName gHC_ENUM (fsLit "enumFrom") enumFromClassOpKey
1003 enumFromToName     = methName gHC_ENUM (fsLit "enumFromTo") enumFromToClassOpKey
1004 enumFromThenName   = methName gHC_ENUM (fsLit "enumFromThen") enumFromThenClassOpKey
1005 enumFromThenToName = methName gHC_ENUM (fsLit "enumFromThenTo") enumFromThenToClassOpKey
1006 boundedClassName   = clsQual gHC_ENUM (fsLit "Bounded") boundedClassKey
1007
1008 -- List functions
1009 concatName, filterName, zipName :: Name
1010 concatName        = varQual gHC_LIST (fsLit "concat") concatIdKey
1011 filterName        = varQual gHC_LIST (fsLit "filter") filterIdKey
1012 zipName           = varQual gHC_LIST (fsLit "zip") zipIdKey
1013
1014 -- Overloaded lists
1015 isListClassName, fromListName, fromListNName, toListName :: Name
1016 isListClassName = clsQual gHC_EXTS (fsLit "IsList") isListClassKey
1017 fromListName = methName gHC_EXTS (fsLit "fromList") fromListClassOpKey
1018 fromListNName = methName gHC_EXTS (fsLit "fromListN") fromListNClassOpKey
1019 toListName = methName gHC_EXTS (fsLit "toList") toListClassOpKey
1020
1021 -- Class Show
1022 showClassName :: Name
1023 showClassName     = clsQual gHC_SHOW (fsLit "Show")       showClassKey
1024
1025 -- Class Read
1026 readClassName :: Name
1027 readClassName      = clsQual gHC_READ (fsLit "Read") readClassKey
1028
1029 -- Classes Generic and Generic1, Datatype, Constructor and Selector
1030 genClassName, gen1ClassName, datatypeClassName, constructorClassName,
1031   selectorClassName :: Name
1032 genClassName  = clsQual gHC_GENERICS (fsLit "Generic")  genClassKey
1033 gen1ClassName = clsQual gHC_GENERICS (fsLit "Generic1") gen1ClassKey
1034
1035 datatypeClassName = clsQual gHC_GENERICS (fsLit "Datatype") datatypeClassKey
1036 constructorClassName = clsQual gHC_GENERICS (fsLit "Constructor") constructorClassKey
1037 selectorClassName = clsQual gHC_GENERICS (fsLit "Selector") selectorClassKey
1038
1039 -- GHCi things
1040 ghciIoClassName, ghciStepIoMName :: Name
1041 ghciIoClassName = clsQual gHC_GHCI (fsLit "GHCiSandboxIO") ghciIoClassKey
1042 ghciStepIoMName = methName gHC_GHCI (fsLit "ghciStepIO") ghciStepIoMClassOpKey
1043
1044 -- IO things
1045 ioTyConName, ioDataConName, thenIOName, bindIOName, returnIOName,
1046     failIOName :: Name
1047 ioTyConName       = tcQual  gHC_TYPES (fsLit "IO") ioTyConKey
1048 ioDataConName     = conName gHC_TYPES (fsLit "IO") ioDataConKey
1049 thenIOName        = varQual gHC_BASE (fsLit "thenIO") thenIOIdKey
1050 bindIOName        = varQual gHC_BASE (fsLit "bindIO") bindIOIdKey
1051 returnIOName      = varQual gHC_BASE (fsLit "returnIO") returnIOIdKey
1052 failIOName        = varQual gHC_IO (fsLit "failIO") failIOIdKey
1053
1054 -- IO things
1055 printName :: Name
1056 printName         = varQual sYSTEM_IO (fsLit "print") printIdKey
1057
1058 -- Int, Word, and Addr things
1059 int8TyConName, int16TyConName, int32TyConName, int64TyConName :: Name
1060 int8TyConName     = tcQual gHC_INT  (fsLit "Int8") int8TyConKey
1061 int16TyConName    = tcQual gHC_INT  (fsLit "Int16") int16TyConKey
1062 int32TyConName    = tcQual gHC_INT  (fsLit "Int32") int32TyConKey
1063 int64TyConName    = tcQual gHC_INT  (fsLit "Int64") int64TyConKey
1064
1065 -- Word module
1066 word8TyConName, word16TyConName, word32TyConName, word64TyConName,
1067     wordTyConName, wordDataConName :: Name
1068 word8TyConName    = tcQual  gHC_WORD (fsLit "Word8")  word8TyConKey
1069 word16TyConName   = tcQual  gHC_WORD (fsLit "Word16") word16TyConKey
1070 word32TyConName   = tcQual  gHC_WORD (fsLit "Word32") word32TyConKey
1071 word64TyConName   = tcQual  gHC_WORD (fsLit "Word64") word64TyConKey
1072 wordTyConName     = tcQual  gHC_TYPES (fsLit "Word")   wordTyConKey
1073 wordDataConName   = conName gHC_TYPES (fsLit "W#") wordDataConKey
1074
1075 -- PrelPtr module
1076 ptrTyConName, funPtrTyConName :: Name
1077 ptrTyConName      = tcQual   gHC_PTR (fsLit "Ptr") ptrTyConKey
1078 funPtrTyConName   = tcQual   gHC_PTR (fsLit "FunPtr") funPtrTyConKey
1079
1080 -- Foreign objects and weak pointers
1081 stablePtrTyConName, newStablePtrName :: Name
1082 stablePtrTyConName    = tcQual   gHC_STABLE (fsLit "StablePtr") stablePtrTyConKey
1083 newStablePtrName      = varQual  gHC_STABLE (fsLit "newStablePtr") newStablePtrIdKey
1084
1085 -- PrelST module
1086 runSTRepName :: Name
1087 runSTRepName       = varQual gHC_ST  (fsLit "runSTRep") runSTRepIdKey
1088
1089 -- Recursive-do notation
1090 monadFixClassName, mfixName :: Name
1091 monadFixClassName  = clsQual mONAD_FIX (fsLit "MonadFix") monadFixClassKey
1092 mfixName           = methName mONAD_FIX (fsLit "mfix") mfixIdKey
1093
1094 -- Arrow notation
1095 arrAName, composeAName, firstAName, appAName, choiceAName, loopAName :: Name
1096 arrAName           = varQual aRROW (fsLit "arr")          arrAIdKey
1097 composeAName       = varQual gHC_DESUGAR (fsLit ">>>") composeAIdKey
1098 firstAName         = varQual aRROW (fsLit "first") firstAIdKey
1099 appAName           = varQual aRROW (fsLit "app")          appAIdKey
1100 choiceAName        = varQual aRROW (fsLit "|||")          choiceAIdKey
1101 loopAName          = varQual aRROW (fsLit "loop")  loopAIdKey
1102
1103 -- Monad comprehensions
1104 guardMName, liftMName, mzipName :: Name
1105 guardMName         = varQual mONAD (fsLit "guard") guardMIdKey
1106 liftMName          = varQual mONAD (fsLit "liftM") liftMIdKey
1107 mzipName           = varQual mONAD_ZIP (fsLit "mzip") mzipIdKey
1108
1109
1110 -- Annotation type checking
1111 toAnnotationWrapperName :: Name
1112 toAnnotationWrapperName = varQual gHC_DESUGAR (fsLit "toAnnotationWrapper") toAnnotationWrapperIdKey
1113
1114 -- Other classes, needed for type defaulting
1115 monadPlusClassName, randomClassName, randomGenClassName,
1116     isStringClassName :: Name
1117 monadPlusClassName  = clsQual mONAD (fsLit "MonadPlus")  monadPlusClassKey
1118 randomClassName     = clsQual rANDOM (fsLit "Random")    randomClassKey
1119 randomGenClassName  = clsQual rANDOM (fsLit "RandomGen") randomGenClassKey
1120 isStringClassName   = clsQual dATA_STRING (fsLit "IsString") isStringClassKey
1121
1122 -- Type-level naturals
1123 singIClassName, typeNatLeqClassName,
1124   typeNatAddTyFamName, typeNatMulTyFamName, typeNatExpTyFamName :: Name
1125 singIClassName      = clsQual gHC_TYPELITS (fsLit "SingI") singIClassNameKey
1126 typeNatLeqClassName = clsQual gHC_TYPELITS (fsLit "<=")  typeNatLeqClassNameKey
1127 typeNatAddTyFamName = tcQual  gHC_TYPELITS (fsLit "+")   typeNatAddTyFamNameKey
1128 typeNatMulTyFamName = tcQual  gHC_TYPELITS (fsLit "*")   typeNatMulTyFamNameKey
1129 typeNatExpTyFamName = tcQual  gHC_TYPELITS (fsLit "^")   typeNatExpTyFamNameKey
1130
1131 -- Implicit parameters
1132 ipClassName :: Name
1133 ipClassName         = clsQual gHC_IP (fsLit "IP")      ipClassNameKey
1134
1135
1136
1137 -- dotnet interop
1138 objectTyConName :: Name
1139 objectTyConName     = tcQual   dOTNET (fsLit "Object") objectTyConKey
1140         -- objectTyConName was "wTcQual", but that's gone now, and
1141         -- I can't see why it was wired in anyway...
1142 unmarshalObjectName, marshalObjectName, marshalStringName,
1143     unmarshalStringName, checkDotnetResName :: Name
1144 unmarshalObjectName = varQual  dOTNET (fsLit "unmarshalObject") unmarshalObjectIdKey
1145 marshalObjectName   = varQual  dOTNET (fsLit "marshalObject") marshalObjectIdKey
1146 marshalStringName   = varQual  dOTNET (fsLit "marshalString") marshalStringIdKey
1147 unmarshalStringName = varQual  dOTNET (fsLit "unmarshalString") unmarshalStringIdKey
1148 checkDotnetResName  = varQual  dOTNET (fsLit "checkResult")     checkDotnetResNameIdKey
1149
1150 -- plugins
1151 cORE_MONAD :: Module
1152 cORE_MONAD = mkThisGhcModule (fsLit "CoreMonad")
1153 pluginTyConName :: Name
1154 pluginTyConName = tcQual cORE_MONAD (fsLit "Plugin") pluginTyConKey
1155 \end{code}
1156
1157 %************************************************************************
1158 %*                                                                      *
1159 \subsection{Local helpers}
1160 %*                                                                      *
1161 %************************************************************************
1162
1163 All these are original names; hence mkOrig
1164
1165 \begin{code}
1166 varQual, tcQual, clsQual :: Module -> FastString -> Unique -> Name
1167 varQual  = mk_known_key_name varName
1168 tcQual   = mk_known_key_name tcName
1169 clsQual  = mk_known_key_name clsName
1170
1171 mk_known_key_name :: NameSpace -> Module -> FastString -> Unique -> Name
1172 mk_known_key_name space modu str unique
1173   = mkExternalName unique modu (mkOccNameFS space str) noSrcSpan
1174
1175 conName :: Module -> FastString -> Unique -> Name
1176 conName modu occ unique
1177   = mkExternalName unique modu (mkOccNameFS dataName occ) noSrcSpan
1178
1179 methName :: Module -> FastString -> Unique -> Name
1180 methName modu occ unique
1181   = mkExternalName unique modu (mkVarOccFS occ) noSrcSpan
1182 \end{code}
1183
1184 %************************************************************************
1185 %*                                                                      *
1186 \subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@}
1187 %*                                                                      *
1188 %************************************************************************
1189 --MetaHaskell extension hand allocate keys here
1190
1191 \begin{code}
1192 boundedClassKey, enumClassKey, eqClassKey, floatingClassKey,
1193     fractionalClassKey, integralClassKey, monadClassKey, dataClassKey,
1194     functorClassKey, numClassKey, ordClassKey, readClassKey, realClassKey,
1195     realFloatClassKey, realFracClassKey, showClassKey, ixClassKey :: Unique
1196 boundedClassKey         = mkPreludeClassUnique 1
1197 enumClassKey            = mkPreludeClassUnique 2
1198 eqClassKey              = mkPreludeClassUnique 3
1199 floatingClassKey        = mkPreludeClassUnique 5
1200 fractionalClassKey      = mkPreludeClassUnique 6
1201 integralClassKey        = mkPreludeClassUnique 7
1202 monadClassKey           = mkPreludeClassUnique 8
1203 dataClassKey            = mkPreludeClassUnique 9
1204 functorClassKey         = mkPreludeClassUnique 10
1205 numClassKey             = mkPreludeClassUnique 11
1206 ordClassKey             = mkPreludeClassUnique 12
1207 readClassKey            = mkPreludeClassUnique 13
1208 realClassKey            = mkPreludeClassUnique 14
1209 realFloatClassKey       = mkPreludeClassUnique 15
1210 realFracClassKey        = mkPreludeClassUnique 16
1211 showClassKey            = mkPreludeClassUnique 17
1212 ixClassKey              = mkPreludeClassUnique 18
1213
1214 typeableClassKey, typeable1ClassKey, typeable2ClassKey, typeable3ClassKey,
1215     typeable4ClassKey, typeable5ClassKey, typeable6ClassKey, typeable7ClassKey
1216     :: Unique
1217 typeableClassKey        = mkPreludeClassUnique 20
1218 typeable1ClassKey       = mkPreludeClassUnique 21
1219 typeable2ClassKey       = mkPreludeClassUnique 22
1220 typeable3ClassKey       = mkPreludeClassUnique 23
1221 typeable4ClassKey       = mkPreludeClassUnique 24
1222 typeable5ClassKey       = mkPreludeClassUnique 25
1223 typeable6ClassKey       = mkPreludeClassUnique 26
1224 typeable7ClassKey       = mkPreludeClassUnique 27
1225
1226 monadFixClassKey :: Unique
1227 monadFixClassKey        = mkPreludeClassUnique 28
1228
1229 monadPlusClassKey, randomClassKey, randomGenClassKey :: Unique
1230 monadPlusClassKey       = mkPreludeClassUnique 30
1231 randomClassKey          = mkPreludeClassUnique 31
1232 randomGenClassKey       = mkPreludeClassUnique 32
1233
1234 isStringClassKey :: Unique
1235 isStringClassKey        = mkPreludeClassUnique 33
1236
1237 applicativeClassKey, foldableClassKey, traversableClassKey :: Unique
1238 applicativeClassKey     = mkPreludeClassUnique 34
1239 foldableClassKey        = mkPreludeClassUnique 35
1240 traversableClassKey     = mkPreludeClassUnique 36
1241
1242 genClassKey, gen1ClassKey, datatypeClassKey, constructorClassKey,
1243   selectorClassKey :: Unique
1244 genClassKey   = mkPreludeClassUnique 37
1245 gen1ClassKey  = mkPreludeClassUnique 38
1246
1247 datatypeClassKey    = mkPreludeClassUnique 39
1248 constructorClassKey = mkPreludeClassUnique 40
1249 selectorClassKey    = mkPreludeClassUnique 41
1250
1251 -- SingI: see Note [SingI and EvLit] in TcEvidence
1252 singIClassNameKey, typeNatLeqClassNameKey :: Unique
1253 singIClassNameKey       = mkPreludeClassUnique 42
1254 typeNatLeqClassNameKey  = mkPreludeClassUnique 43
1255
1256 ghciIoClassKey :: Unique
1257 ghciIoClassKey = mkPreludeClassUnique 44
1258
1259 ipClassNameKey :: Unique
1260 ipClassNameKey = mkPreludeClassUnique 45
1261
1262 oldTypeableClassKey, oldTypeable1ClassKey, oldTypeable2ClassKey,
1263     oldTypeable3ClassKey, oldTypeable4ClassKey, oldTypeable5ClassKey,
1264     oldTypeable6ClassKey, oldTypeable7ClassKey :: Unique
1265 oldTypeableClassKey        = mkPreludeClassUnique 46
1266 oldTypeable1ClassKey       = mkPreludeClassUnique 47
1267 oldTypeable2ClassKey       = mkPreludeClassUnique 48
1268 oldTypeable3ClassKey       = mkPreludeClassUnique 49
1269 oldTypeable4ClassKey       = mkPreludeClassUnique 50
1270 oldTypeable5ClassKey       = mkPreludeClassUnique 51
1271 oldTypeable6ClassKey       = mkPreludeClassUnique 52
1272 oldTypeable7ClassKey       = mkPreludeClassUnique 53
1273 \end{code}
1274
1275 %************************************************************************
1276 %*                                                                      *
1277 \subsubsection[Uniques-prelude-TyCons]{@Uniques@ for wired-in @TyCons@}
1278 %*                                                                      *
1279 %************************************************************************
1280
1281 \begin{code}
1282 addrPrimTyConKey, arrayPrimTyConKey, arrayArrayPrimTyConKey, boolTyConKey, byteArrayPrimTyConKey,
1283     charPrimTyConKey, charTyConKey, doublePrimTyConKey, doubleTyConKey,
1284     floatPrimTyConKey, floatTyConKey, funTyConKey, intPrimTyConKey,
1285     intTyConKey, int8TyConKey, int16TyConKey, int32PrimTyConKey,
1286     int32TyConKey, int64PrimTyConKey, int64TyConKey,
1287     integerTyConKey, digitsTyConKey,
1288     listTyConKey, foreignObjPrimTyConKey, weakPrimTyConKey,
1289     mutableArrayPrimTyConKey, mutableArrayArrayPrimTyConKey, mutableByteArrayPrimTyConKey,
1290     orderingTyConKey, mVarPrimTyConKey, ratioTyConKey, rationalTyConKey,
1291     realWorldTyConKey, stablePtrPrimTyConKey, stablePtrTyConKey,
1292     anyTyConKey, eqTyConKey :: Unique
1293 addrPrimTyConKey                        = mkPreludeTyConUnique  1
1294 arrayPrimTyConKey                       = mkPreludeTyConUnique  3
1295 boolTyConKey                            = mkPreludeTyConUnique  4
1296 byteArrayPrimTyConKey                   = mkPreludeTyConUnique  5
1297 charPrimTyConKey                        = mkPreludeTyConUnique  7
1298 charTyConKey                            = mkPreludeTyConUnique  8
1299 doublePrimTyConKey                      = mkPreludeTyConUnique  9
1300 doubleTyConKey                          = mkPreludeTyConUnique 10
1301 floatPrimTyConKey                       = mkPreludeTyConUnique 11
1302 floatTyConKey                           = mkPreludeTyConUnique 12
1303 funTyConKey                             = mkPreludeTyConUnique 13
1304 intPrimTyConKey                         = mkPreludeTyConUnique 14
1305 intTyConKey                             = mkPreludeTyConUnique 15
1306 int8TyConKey                            = mkPreludeTyConUnique 16
1307 int16TyConKey                           = mkPreludeTyConUnique 17
1308 int32PrimTyConKey                       = mkPreludeTyConUnique 18
1309 int32TyConKey                           = mkPreludeTyConUnique 19
1310 int64PrimTyConKey                       = mkPreludeTyConUnique 20
1311 int64TyConKey                           = mkPreludeTyConUnique 21
1312 integerTyConKey                         = mkPreludeTyConUnique 22
1313 digitsTyConKey                          = mkPreludeTyConUnique 23
1314 listTyConKey                            = mkPreludeTyConUnique 24
1315 foreignObjPrimTyConKey                  = mkPreludeTyConUnique 25
1316 weakPrimTyConKey                        = mkPreludeTyConUnique 27
1317 mutableArrayPrimTyConKey                = mkPreludeTyConUnique 28
1318 mutableByteArrayPrimTyConKey            = mkPreludeTyConUnique 29
1319 orderingTyConKey                        = mkPreludeTyConUnique 30
1320 mVarPrimTyConKey                        = mkPreludeTyConUnique 31
1321 ratioTyConKey                           = mkPreludeTyConUnique 32
1322 rationalTyConKey                        = mkPreludeTyConUnique 33
1323 realWorldTyConKey                       = mkPreludeTyConUnique 34
1324 stablePtrPrimTyConKey                   = mkPreludeTyConUnique 35
1325 stablePtrTyConKey                       = mkPreludeTyConUnique 36
1326 anyTyConKey                             = mkPreludeTyConUnique 37
1327 eqTyConKey                              = mkPreludeTyConUnique 38
1328 arrayArrayPrimTyConKey                  = mkPreludeTyConUnique 39
1329 mutableArrayArrayPrimTyConKey           = mkPreludeTyConUnique 40
1330
1331 statePrimTyConKey, stableNamePrimTyConKey, stableNameTyConKey,
1332     mutVarPrimTyConKey, ioTyConKey,
1333     wordPrimTyConKey, wordTyConKey, word8TyConKey, word16TyConKey,
1334     word32PrimTyConKey, word32TyConKey, word64PrimTyConKey, word64TyConKey,
1335     liftedConKey, unliftedConKey, anyBoxConKey, kindConKey, boxityConKey,
1336     typeConKey, threadIdPrimTyConKey, bcoPrimTyConKey, ptrTyConKey,
1337     funPtrTyConKey, tVarPrimTyConKey, eqPrimTyConKey,
1338     eqReprPrimTyConKey :: Unique
1339 statePrimTyConKey                       = mkPreludeTyConUnique 50
1340 stableNamePrimTyConKey                  = mkPreludeTyConUnique 51
1341 stableNameTyConKey                      = mkPreludeTyConUnique 52
1342 eqPrimTyConKey                          = mkPreludeTyConUnique 53
1343 eqReprPrimTyConKey                      = mkPreludeTyConUnique 54
1344 mutVarPrimTyConKey                      = mkPreludeTyConUnique 55
1345 ioTyConKey                              = mkPreludeTyConUnique 56
1346 wordPrimTyConKey                        = mkPreludeTyConUnique 58
1347 wordTyConKey                            = mkPreludeTyConUnique 59
1348 word8TyConKey                           = mkPreludeTyConUnique 60
1349 word16TyConKey                          = mkPreludeTyConUnique 61
1350 word32PrimTyConKey                      = mkPreludeTyConUnique 62
1351 word32TyConKey                          = mkPreludeTyConUnique 63
1352 word64PrimTyConKey                      = mkPreludeTyConUnique 64
1353 word64TyConKey                          = mkPreludeTyConUnique 65
1354 liftedConKey                            = mkPreludeTyConUnique 66
1355 unliftedConKey                          = mkPreludeTyConUnique 67
1356 anyBoxConKey                            = mkPreludeTyConUnique 68
1357 kindConKey                              = mkPreludeTyConUnique 69
1358 boxityConKey                            = mkPreludeTyConUnique 70
1359 typeConKey                              = mkPreludeTyConUnique 71
1360 threadIdPrimTyConKey                    = mkPreludeTyConUnique 72
1361 bcoPrimTyConKey                         = mkPreludeTyConUnique 73
1362 ptrTyConKey                             = mkPreludeTyConUnique 74
1363 funPtrTyConKey                          = mkPreludeTyConUnique 75
1364 tVarPrimTyConKey                        = mkPreludeTyConUnique 76
1365
1366 -- Parallel array type constructor
1367 parrTyConKey :: Unique
1368 parrTyConKey                            = mkPreludeTyConUnique 82
1369
1370 -- dotnet interop
1371 objectTyConKey :: Unique
1372 objectTyConKey                          = mkPreludeTyConUnique 83
1373
1374 eitherTyConKey :: Unique
1375 eitherTyConKey                          = mkPreludeTyConUnique 84
1376
1377 -- Super Kinds constructors
1378 superKindTyConKey :: Unique
1379 superKindTyConKey                     = mkPreludeTyConUnique 85
1380
1381 -- Kind constructors
1382 liftedTypeKindTyConKey, anyKindTyConKey, openTypeKindTyConKey,
1383   unliftedTypeKindTyConKey, constraintKindTyConKey :: Unique
1384 anyKindTyConKey                         = mkPreludeTyConUnique 86
1385 liftedTypeKindTyConKey                  = mkPreludeTyConUnique 87
1386 openTypeKindTyConKey                    = mkPreludeTyConUnique 88
1387 unliftedTypeKindTyConKey                = mkPreludeTyConUnique 89
1388 constraintKindTyConKey                  = mkPreludeTyConUnique 92
1389
1390 -- Coercion constructors
1391 symCoercionTyConKey, transCoercionTyConKey, leftCoercionTyConKey,
1392     rightCoercionTyConKey, instCoercionTyConKey, unsafeCoercionTyConKey,
1393     csel1CoercionTyConKey, csel2CoercionTyConKey, cselRCoercionTyConKey
1394     :: Unique
1395 symCoercionTyConKey                     = mkPreludeTyConUnique 93
1396 transCoercionTyConKey                   = mkPreludeTyConUnique 94
1397 leftCoercionTyConKey                    = mkPreludeTyConUnique 95
1398 rightCoercionTyConKey                   = mkPreludeTyConUnique 96
1399 instCoercionTyConKey                    = mkPreludeTyConUnique 97
1400 unsafeCoercionTyConKey                  = mkPreludeTyConUnique 98
1401 csel1CoercionTyConKey                   = mkPreludeTyConUnique 99
1402 csel2CoercionTyConKey                   = mkPreludeTyConUnique 100
1403 cselRCoercionTyConKey                   = mkPreludeTyConUnique 101
1404
1405 pluginTyConKey :: Unique
1406 pluginTyConKey                          = mkPreludeTyConUnique 102
1407
1408 unknownTyConKey, unknown1TyConKey, unknown2TyConKey, unknown3TyConKey,
1409     opaqueTyConKey :: Unique
1410 unknownTyConKey                         = mkPreludeTyConUnique 129
1411 unknown1TyConKey                        = mkPreludeTyConUnique 130
1412 unknown2TyConKey                        = mkPreludeTyConUnique 131
1413 unknown3TyConKey                        = mkPreludeTyConUnique 132
1414 opaqueTyConKey                          = mkPreludeTyConUnique 133
1415
1416 stringTyConKey :: Unique
1417 stringTyConKey                          = mkPreludeTyConUnique 134
1418
1419 -- Generics (Unique keys)
1420 v1TyConKey, u1TyConKey, par1TyConKey, rec1TyConKey,
1421   k1TyConKey, m1TyConKey, sumTyConKey, prodTyConKey,
1422   compTyConKey, rTyConKey, pTyConKey, dTyConKey,
1423   cTyConKey, sTyConKey, rec0TyConKey, par0TyConKey,
1424   d1TyConKey, c1TyConKey, s1TyConKey, noSelTyConKey,
1425   repTyConKey, rep1TyConKey :: Unique
1426
1427 v1TyConKey    = mkPreludeTyConUnique 135
1428 u1TyConKey    = mkPreludeTyConUnique 136
1429 par1TyConKey  = mkPreludeTyConUnique 137
1430 rec1TyConKey  = mkPreludeTyConUnique 138
1431 k1TyConKey    = mkPreludeTyConUnique 139
1432 m1TyConKey    = mkPreludeTyConUnique 140
1433
1434 sumTyConKey   = mkPreludeTyConUnique 141
1435 prodTyConKey  = mkPreludeTyConUnique 142
1436 compTyConKey  = mkPreludeTyConUnique 143
1437
1438 rTyConKey = mkPreludeTyConUnique 144
1439 pTyConKey = mkPreludeTyConUnique 145
1440 dTyConKey = mkPreludeTyConUnique 146
1441 cTyConKey = mkPreludeTyConUnique 147
1442 sTyConKey = mkPreludeTyConUnique 148
1443
1444 rec0TyConKey  = mkPreludeTyConUnique 149
1445 par0TyConKey  = mkPreludeTyConUnique 150
1446 d1TyConKey    = mkPreludeTyConUnique 151
1447 c1TyConKey    = mkPreludeTyConUnique 152
1448 s1TyConKey    = mkPreludeTyConUnique 153
1449 noSelTyConKey = mkPreludeTyConUnique 154
1450
1451 repTyConKey  = mkPreludeTyConUnique 155
1452 rep1TyConKey = mkPreludeTyConUnique 156
1453
1454 -- Type-level naturals
1455 typeNatKindConNameKey, typeSymbolKindConNameKey,
1456   typeNatAddTyFamNameKey, typeNatMulTyFamNameKey, typeNatExpTyFamNameKey
1457   :: Unique
1458 typeNatKindConNameKey     = mkPreludeTyConUnique 160
1459 typeSymbolKindConNameKey  = mkPreludeTyConUnique 161
1460 typeNatAddTyFamNameKey    = mkPreludeTyConUnique 162
1461 typeNatMulTyFamNameKey    = mkPreludeTyConUnique 163
1462 typeNatExpTyFamNameKey    = mkPreludeTyConUnique 164
1463
1464 -- SIMD vector types (Unique keys)
1465 floatX4PrimTyConKey, doubleX2PrimTyConKey, int32X4PrimTyConKey,
1466   int64X2PrimTyConKey :: Unique
1467
1468 floatX4PrimTyConKey  = mkPreludeTyConUnique 170
1469 doubleX2PrimTyConKey = mkPreludeTyConUnique 171
1470 int32X4PrimTyConKey  = mkPreludeTyConUnique 172
1471 int64X2PrimTyConKey  = mkPreludeTyConUnique 173
1472
1473 ---------------- Template Haskell -------------------
1474 --      USES TyConUniques 200-299
1475 -----------------------------------------------------
1476
1477 unitTyConKey :: Unique
1478 unitTyConKey = mkTupleTyConUnique BoxedTuple 0
1479 \end{code}
1480
1481 %************************************************************************
1482 %*                                                                      *
1483 \subsubsection[Uniques-prelude-DataCons]{@Uniques@ for wired-in @DataCons@}
1484 %*                                                                      *
1485 %************************************************************************
1486
1487 \begin{code}
1488 charDataConKey, consDataConKey, doubleDataConKey, falseDataConKey,
1489     floatDataConKey, intDataConKey, nilDataConKey, ratioDataConKey,
1490     stableNameDataConKey, trueDataConKey, wordDataConKey,
1491     ioDataConKey, integerDataConKey, eqBoxDataConKey :: Unique
1492 charDataConKey                          = mkPreludeDataConUnique  1
1493 consDataConKey                          = mkPreludeDataConUnique  2
1494 doubleDataConKey                        = mkPreludeDataConUnique  3
1495 falseDataConKey                         = mkPreludeDataConUnique  4
1496 floatDataConKey                         = mkPreludeDataConUnique  5
1497 intDataConKey                           = mkPreludeDataConUnique  6
1498 nilDataConKey                           = mkPreludeDataConUnique 11
1499 ratioDataConKey                         = mkPreludeDataConUnique 12
1500 stableNameDataConKey                    = mkPreludeDataConUnique 14
1501 trueDataConKey                          = mkPreludeDataConUnique 15
1502 wordDataConKey                          = mkPreludeDataConUnique 16
1503 ioDataConKey                            = mkPreludeDataConUnique 17
1504 integerDataConKey                       = mkPreludeDataConUnique 18
1505 eqBoxDataConKey                         = mkPreludeDataConUnique 19
1506
1507 -- Generic data constructors
1508 crossDataConKey, inlDataConKey, inrDataConKey, genUnitDataConKey :: Unique
1509 crossDataConKey                         = mkPreludeDataConUnique 20
1510 inlDataConKey                           = mkPreludeDataConUnique 21
1511 inrDataConKey                           = mkPreludeDataConUnique 22
1512 genUnitDataConKey                       = mkPreludeDataConUnique 23
1513
1514 -- Data constructor for parallel arrays
1515 parrDataConKey :: Unique
1516 parrDataConKey                          = mkPreludeDataConUnique 24
1517
1518 leftDataConKey, rightDataConKey :: Unique
1519 leftDataConKey                          = mkPreludeDataConUnique 25
1520 rightDataConKey                         = mkPreludeDataConUnique 26
1521
1522 ltDataConKey, eqDataConKey, gtDataConKey :: Unique
1523 ltDataConKey                            = mkPreludeDataConUnique 27
1524 eqDataConKey                            = mkPreludeDataConUnique 28
1525 gtDataConKey                            = mkPreludeDataConUnique 29
1526
1527 -- For integer-gmp only
1528 integerGmpSDataConKey, integerGmpJDataConKey :: Unique
1529 integerGmpSDataConKey                   = mkPreludeDataConUnique 30
1530 integerGmpJDataConKey                   = mkPreludeDataConUnique 31
1531 \end{code}
1532
1533 %************************************************************************
1534 %*                                                                      *
1535 \subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}
1536 %*                                                                      *
1537 %************************************************************************
1538
1539 \begin{code}
1540 wildCardKey, absentErrorIdKey, augmentIdKey, appendIdKey,
1541     buildIdKey, errorIdKey, foldrIdKey, recSelErrorIdKey,
1542     seqIdKey, irrefutPatErrorIdKey, eqStringIdKey,
1543     noMethodBindingErrorIdKey, nonExhaustiveGuardsErrorIdKey,
1544     runtimeErrorIdKey, patErrorIdKey,
1545     realWorldPrimIdKey, recConErrorIdKey,
1546     unpackCStringUtf8IdKey, unpackCStringAppendIdKey,
1547     unpackCStringFoldrIdKey, unpackCStringIdKey :: Unique
1548 wildCardKey                   = mkPreludeMiscIdUnique  0  -- See Note [WildCard]
1549 absentErrorIdKey              = mkPreludeMiscIdUnique  1
1550 augmentIdKey                  = mkPreludeMiscIdUnique  2
1551 appendIdKey                   = mkPreludeMiscIdUnique  3
1552 buildIdKey                    = mkPreludeMiscIdUnique  4
1553 errorIdKey                    = mkPreludeMiscIdUnique  5
1554 foldrIdKey                    = mkPreludeMiscIdUnique  6
1555 recSelErrorIdKey              = mkPreludeMiscIdUnique  7
1556 seqIdKey                      = mkPreludeMiscIdUnique  8
1557 irrefutPatErrorIdKey          = mkPreludeMiscIdUnique  9
1558 eqStringIdKey                 = mkPreludeMiscIdUnique 10
1559 noMethodBindingErrorIdKey     = mkPreludeMiscIdUnique 11
1560 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 12
1561 runtimeErrorIdKey             = mkPreludeMiscIdUnique 13
1562 patErrorIdKey                 = mkPreludeMiscIdUnique 14
1563 realWorldPrimIdKey            = mkPreludeMiscIdUnique 15
1564 recConErrorIdKey              = mkPreludeMiscIdUnique 16
1565 unpackCStringUtf8IdKey        = mkPreludeMiscIdUnique 17
1566 unpackCStringAppendIdKey      = mkPreludeMiscIdUnique 18
1567 unpackCStringFoldrIdKey       = mkPreludeMiscIdUnique 19
1568 unpackCStringIdKey            = mkPreludeMiscIdUnique 20
1569
1570 unsafeCoerceIdKey, concatIdKey, filterIdKey, zipIdKey, bindIOIdKey,
1571     returnIOIdKey, newStablePtrIdKey,
1572     printIdKey, failIOIdKey, nullAddrIdKey, voidArgIdKey,
1573     fstIdKey, sndIdKey, otherwiseIdKey, assertIdKey, runSTRepIdKey :: Unique
1574 unsafeCoerceIdKey             = mkPreludeMiscIdUnique 30
1575 concatIdKey                   = mkPreludeMiscIdUnique 31
1576 filterIdKey                   = mkPreludeMiscIdUnique 32
1577 zipIdKey                      = mkPreludeMiscIdUnique 33
1578 bindIOIdKey                   = mkPreludeMiscIdUnique 34
1579 returnIOIdKey                 = mkPreludeMiscIdUnique 35
1580 newStablePtrIdKey             = mkPreludeMiscIdUnique 36
1581 printIdKey                    = mkPreludeMiscIdUnique 37
1582 failIOIdKey                   = mkPreludeMiscIdUnique 38
1583 nullAddrIdKey                 = mkPreludeMiscIdUnique 39
1584 voidArgIdKey                  = mkPreludeMiscIdUnique 40
1585 fstIdKey                      = mkPreludeMiscIdUnique 41
1586 sndIdKey                      = mkPreludeMiscIdUnique 42
1587 otherwiseIdKey                = mkPreludeMiscIdUnique 43
1588 assertIdKey                   = mkPreludeMiscIdUnique 44
1589 runSTRepIdKey                 = mkPreludeMiscIdUnique 45
1590
1591 mkIntegerIdKey, smallIntegerIdKey, wordToIntegerIdKey,
1592     integerToWordIdKey, integerToIntIdKey,
1593     integerToWord64IdKey, integerToInt64IdKey,
1594     word64ToIntegerIdKey, int64ToIntegerIdKey,
1595     plusIntegerIdKey, timesIntegerIdKey, minusIntegerIdKey,
1596     negateIntegerIdKey,
1597     eqIntegerPrimIdKey, neqIntegerPrimIdKey, absIntegerIdKey, signumIntegerIdKey,
1598     leIntegerPrimIdKey, gtIntegerPrimIdKey, ltIntegerPrimIdKey, geIntegerPrimIdKey,
1599     compareIntegerIdKey, quotRemIntegerIdKey, divModIntegerIdKey,
1600     quotIntegerIdKey, remIntegerIdKey, divIntegerIdKey, modIntegerIdKey,
1601     floatFromIntegerIdKey, doubleFromIntegerIdKey,
1602     encodeFloatIntegerIdKey, encodeDoubleIntegerIdKey,
1603     decodeDoubleIntegerIdKey,
1604     gcdIntegerIdKey, lcmIntegerIdKey,
1605     andIntegerIdKey, orIntegerIdKey, xorIntegerIdKey, complementIntegerIdKey,
1606     shiftLIntegerIdKey, shiftRIntegerIdKey :: Unique
1607 mkIntegerIdKey                = mkPreludeMiscIdUnique 60
1608 smallIntegerIdKey             = mkPreludeMiscIdUnique 61
1609 integerToWordIdKey            = mkPreludeMiscIdUnique 62
1610 integerToIntIdKey             = mkPreludeMiscIdUnique 63
1611 integerToWord64IdKey          = mkPreludeMiscIdUnique 64
1612 integerToInt64IdKey           = mkPreludeMiscIdUnique 65
1613 plusIntegerIdKey              = mkPreludeMiscIdUnique 66
1614 timesIntegerIdKey             = mkPreludeMiscIdUnique 67
1615 minusIntegerIdKey             = mkPreludeMiscIdUnique 68
1616 negateIntegerIdKey            = mkPreludeMiscIdUnique 69
1617 eqIntegerPrimIdKey            = mkPreludeMiscIdUnique 70
1618 neqIntegerPrimIdKey           = mkPreludeMiscIdUnique 71
1619 absIntegerIdKey               = mkPreludeMiscIdUnique 72
1620 signumIntegerIdKey            = mkPreludeMiscIdUnique 73
1621 leIntegerPrimIdKey            = mkPreludeMiscIdUnique 74
1622 gtIntegerPrimIdKey            = mkPreludeMiscIdUnique 75
1623 ltIntegerPrimIdKey            = mkPreludeMiscIdUnique 76
1624 geIntegerPrimIdKey            = mkPreludeMiscIdUnique 77
1625 compareIntegerIdKey           = mkPreludeMiscIdUnique 78
1626 quotIntegerIdKey              = mkPreludeMiscIdUnique 79
1627 remIntegerIdKey               = mkPreludeMiscIdUnique 80
1628 divIntegerIdKey               = mkPreludeMiscIdUnique 81
1629 modIntegerIdKey               = mkPreludeMiscIdUnique 82
1630 divModIntegerIdKey            = mkPreludeMiscIdUnique 83
1631 quotRemIntegerIdKey           = mkPreludeMiscIdUnique 84
1632 floatFromIntegerIdKey         = mkPreludeMiscIdUnique 85
1633 doubleFromIntegerIdKey        = mkPreludeMiscIdUnique 86
1634 encodeFloatIntegerIdKey       = mkPreludeMiscIdUnique 87
1635 encodeDoubleIntegerIdKey      = mkPreludeMiscIdUnique 88
1636 gcdIntegerIdKey               = mkPreludeMiscIdUnique 89
1637 lcmIntegerIdKey               = mkPreludeMiscIdUnique 90
1638 andIntegerIdKey               = mkPreludeMiscIdUnique 91
1639 orIntegerIdKey                = mkPreludeMiscIdUnique 92
1640 xorIntegerIdKey               = mkPreludeMiscIdUnique 93
1641 complementIntegerIdKey        = mkPreludeMiscIdUnique 94
1642 shiftLIntegerIdKey            = mkPreludeMiscIdUnique 95
1643 shiftRIntegerIdKey            = mkPreludeMiscIdUnique 96
1644 wordToIntegerIdKey            = mkPreludeMiscIdUnique 97
1645 word64ToIntegerIdKey          = mkPreludeMiscIdUnique 98
1646 int64ToIntegerIdKey           = mkPreludeMiscIdUnique 99
1647 decodeDoubleIntegerIdKey      = mkPreludeMiscIdUnique 100
1648
1649 rootMainKey, runMainKey :: Unique
1650 rootMainKey                   = mkPreludeMiscIdUnique 101
1651 runMainKey                    = mkPreludeMiscIdUnique 102
1652
1653 thenIOIdKey, lazyIdKey, assertErrorIdKey :: Unique
1654 thenIOIdKey                   = mkPreludeMiscIdUnique 103
1655 lazyIdKey                     = mkPreludeMiscIdUnique 104
1656 assertErrorIdKey              = mkPreludeMiscIdUnique 105
1657
1658 breakpointIdKey, breakpointCondIdKey, breakpointAutoIdKey,
1659     breakpointJumpIdKey, breakpointCondJumpIdKey,
1660     breakpointAutoJumpIdKey :: Unique
1661 breakpointIdKey               = mkPreludeMiscIdUnique 110
1662 breakpointCondIdKey           = mkPreludeMiscIdUnique 111
1663 breakpointAutoIdKey           = mkPreludeMiscIdUnique 112
1664 breakpointJumpIdKey           = mkPreludeMiscIdUnique 113
1665 breakpointCondJumpIdKey       = mkPreludeMiscIdUnique 114
1666 breakpointAutoJumpIdKey       = mkPreludeMiscIdUnique 115
1667
1668 inlineIdKey :: Unique
1669 inlineIdKey                   = mkPreludeMiscIdUnique 120
1670
1671 mapIdKey, groupWithIdKey, dollarIdKey :: Unique
1672 mapIdKey              = mkPreludeMiscIdUnique 121
1673 groupWithIdKey        = mkPreludeMiscIdUnique 122
1674 dollarIdKey           = mkPreludeMiscIdUnique 123
1675
1676 coercionTokenIdKey :: Unique
1677 coercionTokenIdKey    = mkPreludeMiscIdUnique 124
1678
1679 rationalToFloatIdKey, rationalToDoubleIdKey :: Unique
1680 rationalToFloatIdKey   = mkPreludeMiscIdUnique 130
1681 rationalToDoubleIdKey  = mkPreludeMiscIdUnique 131
1682
1683 -- dotnet interop
1684 unmarshalObjectIdKey, marshalObjectIdKey, marshalStringIdKey,
1685     unmarshalStringIdKey, checkDotnetResNameIdKey :: Unique
1686 unmarshalObjectIdKey          = mkPreludeMiscIdUnique 150
1687 marshalObjectIdKey            = mkPreludeMiscIdUnique 151
1688 marshalStringIdKey            = mkPreludeMiscIdUnique 152
1689 unmarshalStringIdKey          = mkPreludeMiscIdUnique 153
1690 checkDotnetResNameIdKey       = mkPreludeMiscIdUnique 154
1691
1692 undefinedKey :: Unique
1693 undefinedKey                  = mkPreludeMiscIdUnique 155
1694
1695 magicSingIKey :: Unique
1696 magicSingIKey              = mkPreludeMiscIdUnique 156
1697 \end{code}
1698
1699 Certain class operations from Prelude classes.  They get their own
1700 uniques so we can look them up easily when we want to conjure them up
1701 during type checking.
1702
1703 \begin{code}
1704         -- Just a place holder for  unbound variables  produced by the renamer:
1705 unboundKey :: Unique
1706 unboundKey                    = mkPreludeMiscIdUnique 160
1707
1708 fromIntegerClassOpKey, minusClassOpKey, fromRationalClassOpKey,
1709     enumFromClassOpKey, enumFromThenClassOpKey, enumFromToClassOpKey,
1710     enumFromThenToClassOpKey, eqClassOpKey, geClassOpKey, negateClassOpKey,
1711     failMClassOpKey, bindMClassOpKey, thenMClassOpKey, returnMClassOpKey,
1712     fmapClassOpKey
1713     :: Unique
1714 fromIntegerClassOpKey         = mkPreludeMiscIdUnique 160
1715 minusClassOpKey               = mkPreludeMiscIdUnique 161
1716 fromRationalClassOpKey        = mkPreludeMiscIdUnique 162
1717 enumFromClassOpKey            = mkPreludeMiscIdUnique 163
1718 enumFromThenClassOpKey        = mkPreludeMiscIdUnique 164
1719 enumFromToClassOpKey          = mkPreludeMiscIdUnique 165
1720 enumFromThenToClassOpKey      = mkPreludeMiscIdUnique 166
1721 eqClassOpKey                  = mkPreludeMiscIdUnique 167
1722 geClassOpKey                  = mkPreludeMiscIdUnique 168
1723 negateClassOpKey              = mkPreludeMiscIdUnique 169
1724 failMClassOpKey               = mkPreludeMiscIdUnique 170
1725 bindMClassOpKey               = mkPreludeMiscIdUnique 171 -- (>>=)
1726 thenMClassOpKey               = mkPreludeMiscIdUnique 172 -- (>>)
1727 fmapClassOpKey                = mkPreludeMiscIdUnique 173
1728 returnMClassOpKey             = mkPreludeMiscIdUnique 174
1729
1730 -- Recursive do notation
1731 mfixIdKey :: Unique
1732 mfixIdKey       = mkPreludeMiscIdUnique 175
1733
1734 -- Arrow notation
1735 arrAIdKey, composeAIdKey, firstAIdKey, appAIdKey, choiceAIdKey,
1736     loopAIdKey :: Unique
1737 arrAIdKey       = mkPreludeMiscIdUnique 180
1738 composeAIdKey   = mkPreludeMiscIdUnique 181 -- >>>
1739 firstAIdKey     = mkPreludeMiscIdUnique 182
1740 appAIdKey       = mkPreludeMiscIdUnique 183
1741 choiceAIdKey    = mkPreludeMiscIdUnique 184 --  |||
1742 loopAIdKey      = mkPreludeMiscIdUnique 185
1743
1744 fromStringClassOpKey :: Unique
1745 fromStringClassOpKey          = mkPreludeMiscIdUnique 186
1746
1747 -- Annotation type checking
1748 toAnnotationWrapperIdKey :: Unique
1749 toAnnotationWrapperIdKey      = mkPreludeMiscIdUnique 187
1750
1751 -- Conversion functions
1752 fromIntegralIdKey, realToFracIdKey, toIntegerClassOpKey, toRationalClassOpKey :: Unique
1753 fromIntegralIdKey    = mkPreludeMiscIdUnique 190
1754 realToFracIdKey      = mkPreludeMiscIdUnique 191
1755 toIntegerClassOpKey  = mkPreludeMiscIdUnique 192
1756 toRationalClassOpKey = mkPreludeMiscIdUnique 193
1757
1758 -- Monad comprehensions
1759 guardMIdKey, liftMIdKey, mzipIdKey :: Unique
1760 guardMIdKey     = mkPreludeMiscIdUnique 194
1761 liftMIdKey      = mkPreludeMiscIdUnique 195
1762 mzipIdKey       = mkPreludeMiscIdUnique 196
1763
1764 -- GHCi
1765 ghciStepIoMClassOpKey :: Unique
1766 ghciStepIoMClassOpKey = mkPreludeMiscIdUnique 197
1767
1768 -- Overloaded lists
1769 isListClassKey, fromListClassOpKey, fromListNClassOpKey, toListClassOpKey :: Unique
1770 isListClassKey = mkPreludeMiscIdUnique 198
1771 fromListClassOpKey = mkPreludeMiscIdUnique 199
1772 fromListNClassOpKey = mkPreludeMiscIdUnique 500
1773 toListClassOpKey = mkPreludeMiscIdUnique 501
1774
1775 ---------------- Template Haskell -------------------
1776 --      USES IdUniques 200-499
1777 -----------------------------------------------------
1778 \end{code}
1779
1780 %************************************************************************
1781 %*                                                                      *
1782 \subsection[Class-std-groups]{Standard groups of Prelude classes}
1783 %*                                                                      *
1784 %************************************************************************
1785
1786 NOTE: @Eq@ and @Text@ do need to appear in @standardClasses@
1787 even though every numeric class has these two as a superclass,
1788 because the list of ambiguous dictionaries hasn't been simplified.
1789
1790 \begin{code}
1791 numericClassKeys :: [Unique]
1792 numericClassKeys =
1793         [ numClassKey
1794         , realClassKey
1795         , integralClassKey
1796         ]
1797         ++ fractionalClassKeys
1798
1799 fractionalClassKeys :: [Unique]
1800 fractionalClassKeys =
1801         [ fractionalClassKey
1802         , floatingClassKey
1803         , realFracClassKey
1804         , realFloatClassKey
1805         ]
1806
1807 -- The "standard classes" are used in defaulting (Haskell 98 report 4.3.4),
1808 -- and are: "classes defined in the Prelude or a standard library"
1809 standardClassKeys :: [Unique]
1810 standardClassKeys = derivableClassKeys ++ numericClassKeys
1811                   ++ [randomClassKey, randomGenClassKey,
1812                       functorClassKey,
1813                       monadClassKey, monadPlusClassKey,
1814                       isStringClassKey,
1815                       applicativeClassKey, foldableClassKey, traversableClassKey
1816                      ]
1817 \end{code}
1818
1819 @derivableClassKeys@ is also used in checking \tr{deriving} constructs
1820 (@TcDeriv@).
1821
1822 \begin{code}
1823 derivableClassKeys :: [Unique]
1824 derivableClassKeys
1825   = [ eqClassKey, ordClassKey, enumClassKey, ixClassKey,
1826       boundedClassKey, showClassKey, readClassKey ]
1827 \end{code}
1828