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