Make typeRep_RDR use typeRep# instead of typeRep
[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         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 :: Name
1087 word8TyConName    = tcQual  gHC_WORD (fsLit "Word8")  word8TyConKey
1088 word16TyConName   = tcQual  gHC_WORD (fsLit "Word16") word16TyConKey
1089 word32TyConName   = tcQual  gHC_WORD (fsLit "Word32") word32TyConKey
1090 word64TyConName   = tcQual  gHC_WORD (fsLit "Word64") word64TyConKey
1091
1092 -- PrelPtr module
1093 ptrTyConName, funPtrTyConName :: Name
1094 ptrTyConName      = tcQual   gHC_PTR (fsLit "Ptr") ptrTyConKey
1095 funPtrTyConName   = tcQual   gHC_PTR (fsLit "FunPtr") funPtrTyConKey
1096
1097 -- Foreign objects and weak pointers
1098 stablePtrTyConName, newStablePtrName :: Name
1099 stablePtrTyConName    = tcQual   gHC_STABLE (fsLit "StablePtr") stablePtrTyConKey
1100 newStablePtrName      = varQual  gHC_STABLE (fsLit "newStablePtr") newStablePtrIdKey
1101
1102 -- PrelST module
1103 runSTRepName :: Name
1104 runSTRepName       = varQual gHC_ST  (fsLit "runSTRep") runSTRepIdKey
1105
1106 -- Recursive-do notation
1107 monadFixClassName, mfixName :: Name
1108 monadFixClassName  = clsQual mONAD_FIX (fsLit "MonadFix") monadFixClassKey
1109 mfixName           = methName mONAD_FIX (fsLit "mfix") mfixIdKey
1110
1111 -- Arrow notation
1112 arrAName, composeAName, firstAName, appAName, choiceAName, loopAName :: Name
1113 arrAName           = varQual aRROW (fsLit "arr")          arrAIdKey
1114 composeAName       = varQual gHC_DESUGAR (fsLit ">>>") composeAIdKey
1115 firstAName         = varQual aRROW (fsLit "first") firstAIdKey
1116 appAName           = varQual aRROW (fsLit "app")          appAIdKey
1117 choiceAName        = varQual aRROW (fsLit "|||")          choiceAIdKey
1118 loopAName          = varQual aRROW (fsLit "loop")  loopAIdKey
1119
1120 -- Monad comprehensions
1121 guardMName, liftMName, mzipName :: Name
1122 guardMName         = varQual mONAD (fsLit "guard") guardMIdKey
1123 liftMName          = varQual mONAD (fsLit "liftM") liftMIdKey
1124 mzipName           = varQual mONAD_ZIP (fsLit "mzip") mzipIdKey
1125
1126
1127 -- Annotation type checking
1128 toAnnotationWrapperName :: Name
1129 toAnnotationWrapperName = varQual gHC_DESUGAR (fsLit "toAnnotationWrapper") toAnnotationWrapperIdKey
1130
1131 -- Other classes, needed for type defaulting
1132 monadPlusClassName, randomClassName, randomGenClassName,
1133     isStringClassName :: Name
1134 monadPlusClassName  = clsQual mONAD (fsLit "MonadPlus")  monadPlusClassKey
1135 randomClassName     = clsQual rANDOM (fsLit "Random")    randomClassKey
1136 randomGenClassName  = clsQual rANDOM (fsLit "RandomGen") randomGenClassKey
1137 isStringClassName   = clsQual dATA_STRING (fsLit "IsString") isStringClassKey
1138
1139 -- Type-level naturals
1140 singIClassName :: Name
1141 singIClassName      = clsQual gHC_TYPELITS (fsLit "SingI") singIClassNameKey
1142
1143 -- Implicit parameters
1144 ipClassName :: Name
1145 ipClassName         = clsQual gHC_IP (fsLit "IP")      ipClassNameKey
1146
1147
1148
1149 -- dotnet interop
1150 objectTyConName :: Name
1151 objectTyConName     = tcQual   dOTNET (fsLit "Object") objectTyConKey
1152         -- objectTyConName was "wTcQual", but that's gone now, and
1153         -- I can't see why it was wired in anyway...
1154 unmarshalObjectName, marshalObjectName, marshalStringName,
1155     unmarshalStringName, checkDotnetResName :: Name
1156 unmarshalObjectName = varQual  dOTNET (fsLit "unmarshalObject") unmarshalObjectIdKey
1157 marshalObjectName   = varQual  dOTNET (fsLit "marshalObject") marshalObjectIdKey
1158 marshalStringName   = varQual  dOTNET (fsLit "marshalString") marshalStringIdKey
1159 unmarshalStringName = varQual  dOTNET (fsLit "unmarshalString") unmarshalStringIdKey
1160 checkDotnetResName  = varQual  dOTNET (fsLit "checkResult")     checkDotnetResNameIdKey
1161
1162 -- plugins
1163 cORE_MONAD :: Module
1164 cORE_MONAD = mkThisGhcModule (fsLit "CoreMonad")
1165 pluginTyConName :: Name
1166 pluginTyConName = tcQual cORE_MONAD (fsLit "Plugin") pluginTyConKey
1167 \end{code}
1168
1169 %************************************************************************
1170 %*                                                                      *
1171 \subsection{Local helpers}
1172 %*                                                                      *
1173 %************************************************************************
1174
1175 All these are original names; hence mkOrig
1176
1177 \begin{code}
1178 varQual, tcQual, clsQual :: Module -> FastString -> Unique -> Name
1179 varQual  = mk_known_key_name varName
1180 tcQual   = mk_known_key_name tcName
1181 clsQual  = mk_known_key_name clsName
1182
1183 mk_known_key_name :: NameSpace -> Module -> FastString -> Unique -> Name
1184 mk_known_key_name space modu str unique
1185   = mkExternalName unique modu (mkOccNameFS space str) noSrcSpan
1186
1187 conName :: Module -> FastString -> Unique -> Name
1188 conName modu occ unique
1189   = mkExternalName unique modu (mkOccNameFS dataName occ) noSrcSpan
1190
1191 methName :: Module -> FastString -> Unique -> Name
1192 methName modu occ unique
1193   = mkExternalName unique modu (mkVarOccFS occ) noSrcSpan
1194 \end{code}
1195
1196 %************************************************************************
1197 %*                                                                      *
1198 \subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@}
1199 %*                                                                      *
1200 %************************************************************************
1201 --MetaHaskell extension hand allocate keys here
1202
1203 \begin{code}
1204 boundedClassKey, enumClassKey, eqClassKey, floatingClassKey,
1205     fractionalClassKey, integralClassKey, monadClassKey, dataClassKey,
1206     functorClassKey, numClassKey, ordClassKey, readClassKey, realClassKey,
1207     realFloatClassKey, realFracClassKey, showClassKey, ixClassKey :: Unique
1208 boundedClassKey         = mkPreludeClassUnique 1
1209 enumClassKey            = mkPreludeClassUnique 2
1210 eqClassKey              = mkPreludeClassUnique 3
1211 floatingClassKey        = mkPreludeClassUnique 5
1212 fractionalClassKey      = mkPreludeClassUnique 6
1213 integralClassKey        = mkPreludeClassUnique 7
1214 monadClassKey           = mkPreludeClassUnique 8
1215 dataClassKey            = mkPreludeClassUnique 9
1216 functorClassKey         = mkPreludeClassUnique 10
1217 numClassKey             = mkPreludeClassUnique 11
1218 ordClassKey             = mkPreludeClassUnique 12
1219 readClassKey            = mkPreludeClassUnique 13
1220 realClassKey            = mkPreludeClassUnique 14
1221 realFloatClassKey       = mkPreludeClassUnique 15
1222 realFracClassKey        = mkPreludeClassUnique 16
1223 showClassKey            = mkPreludeClassUnique 17
1224 ixClassKey              = mkPreludeClassUnique 18
1225
1226 typeableClassKey, typeable1ClassKey, typeable2ClassKey, typeable3ClassKey,
1227     typeable4ClassKey, typeable5ClassKey, typeable6ClassKey, typeable7ClassKey
1228     :: Unique
1229 typeableClassKey        = mkPreludeClassUnique 20
1230 typeable1ClassKey       = mkPreludeClassUnique 21
1231 typeable2ClassKey       = mkPreludeClassUnique 22
1232 typeable3ClassKey       = mkPreludeClassUnique 23
1233 typeable4ClassKey       = mkPreludeClassUnique 24
1234 typeable5ClassKey       = mkPreludeClassUnique 25
1235 typeable6ClassKey       = mkPreludeClassUnique 26
1236 typeable7ClassKey       = mkPreludeClassUnique 27
1237
1238 monadFixClassKey :: Unique
1239 monadFixClassKey        = mkPreludeClassUnique 28
1240
1241 monadPlusClassKey, randomClassKey, randomGenClassKey :: Unique
1242 monadPlusClassKey       = mkPreludeClassUnique 30
1243 randomClassKey          = mkPreludeClassUnique 31
1244 randomGenClassKey       = mkPreludeClassUnique 32
1245
1246 isStringClassKey :: Unique
1247 isStringClassKey        = mkPreludeClassUnique 33
1248
1249 applicativeClassKey, foldableClassKey, traversableClassKey :: Unique
1250 applicativeClassKey     = mkPreludeClassUnique 34
1251 foldableClassKey        = mkPreludeClassUnique 35
1252 traversableClassKey     = mkPreludeClassUnique 36
1253
1254 genClassKey, gen1ClassKey, datatypeClassKey, constructorClassKey,
1255   selectorClassKey :: Unique
1256 genClassKey   = mkPreludeClassUnique 37
1257 gen1ClassKey  = mkPreludeClassUnique 38
1258
1259 datatypeClassKey    = mkPreludeClassUnique 39
1260 constructorClassKey = mkPreludeClassUnique 40
1261 selectorClassKey    = mkPreludeClassUnique 41
1262
1263 -- SingI: see Note [SingI and EvLit] in TcEvidence
1264 singIClassNameKey :: Unique
1265 singIClassNameKey       = mkPreludeClassUnique 42
1266
1267 ghciIoClassKey :: Unique
1268 ghciIoClassKey = mkPreludeClassUnique 44
1269
1270 ipClassNameKey :: Unique
1271 ipClassNameKey = mkPreludeClassUnique 45
1272
1273 oldTypeableClassKey, oldTypeable1ClassKey, oldTypeable2ClassKey,
1274     oldTypeable3ClassKey, oldTypeable4ClassKey, oldTypeable5ClassKey,
1275     oldTypeable6ClassKey, oldTypeable7ClassKey :: Unique
1276 oldTypeableClassKey        = mkPreludeClassUnique 46
1277 oldTypeable1ClassKey       = mkPreludeClassUnique 47
1278 oldTypeable2ClassKey       = mkPreludeClassUnique 48
1279 oldTypeable3ClassKey       = mkPreludeClassUnique 49
1280 oldTypeable4ClassKey       = mkPreludeClassUnique 50
1281 oldTypeable5ClassKey       = mkPreludeClassUnique 51
1282 oldTypeable6ClassKey       = mkPreludeClassUnique 52
1283 oldTypeable7ClassKey       = mkPreludeClassUnique 53
1284 \end{code}
1285
1286 %************************************************************************
1287 %*                                                                      *
1288 \subsubsection[Uniques-prelude-TyCons]{@Uniques@ for wired-in @TyCons@}
1289 %*                                                                      *
1290 %************************************************************************
1291
1292 \begin{code}
1293 addrPrimTyConKey, arrayPrimTyConKey, arrayArrayPrimTyConKey, boolTyConKey, byteArrayPrimTyConKey,
1294     charPrimTyConKey, charTyConKey, doublePrimTyConKey, doubleTyConKey,
1295     floatPrimTyConKey, floatTyConKey, funTyConKey, intPrimTyConKey,
1296     intTyConKey, int8TyConKey, int16TyConKey, int32PrimTyConKey,
1297     int32TyConKey, int64PrimTyConKey, int64TyConKey,
1298     integerTyConKey, digitsTyConKey,
1299     listTyConKey, foreignObjPrimTyConKey, weakPrimTyConKey,
1300     mutableArrayPrimTyConKey, mutableArrayArrayPrimTyConKey, mutableByteArrayPrimTyConKey,
1301     orderingTyConKey, mVarPrimTyConKey, ratioTyConKey, rationalTyConKey,
1302     realWorldTyConKey, stablePtrPrimTyConKey, stablePtrTyConKey,
1303     anyTyConKey, eqTyConKey :: Unique
1304 addrPrimTyConKey                        = mkPreludeTyConUnique  1
1305 arrayPrimTyConKey                       = mkPreludeTyConUnique  3
1306 boolTyConKey                            = mkPreludeTyConUnique  4
1307 byteArrayPrimTyConKey                   = mkPreludeTyConUnique  5
1308 charPrimTyConKey                        = mkPreludeTyConUnique  7
1309 charTyConKey                            = mkPreludeTyConUnique  8
1310 doublePrimTyConKey                      = mkPreludeTyConUnique  9
1311 doubleTyConKey                          = mkPreludeTyConUnique 10
1312 floatPrimTyConKey                       = mkPreludeTyConUnique 11
1313 floatTyConKey                           = mkPreludeTyConUnique 12
1314 funTyConKey                             = mkPreludeTyConUnique 13
1315 intPrimTyConKey                         = mkPreludeTyConUnique 14
1316 intTyConKey                             = mkPreludeTyConUnique 15
1317 int8TyConKey                            = mkPreludeTyConUnique 16
1318 int16TyConKey                           = mkPreludeTyConUnique 17
1319 int32PrimTyConKey                       = mkPreludeTyConUnique 18
1320 int32TyConKey                           = mkPreludeTyConUnique 19
1321 int64PrimTyConKey                       = mkPreludeTyConUnique 20
1322 int64TyConKey                           = mkPreludeTyConUnique 21
1323 integerTyConKey                         = mkPreludeTyConUnique 22
1324 digitsTyConKey                          = mkPreludeTyConUnique 23
1325 listTyConKey                            = mkPreludeTyConUnique 24
1326 foreignObjPrimTyConKey                  = mkPreludeTyConUnique 25
1327 weakPrimTyConKey                        = mkPreludeTyConUnique 27
1328 mutableArrayPrimTyConKey                = mkPreludeTyConUnique 28
1329 mutableByteArrayPrimTyConKey            = mkPreludeTyConUnique 29
1330 orderingTyConKey                        = mkPreludeTyConUnique 30
1331 mVarPrimTyConKey                        = mkPreludeTyConUnique 31
1332 ratioTyConKey                           = mkPreludeTyConUnique 32
1333 rationalTyConKey                        = mkPreludeTyConUnique 33
1334 realWorldTyConKey                       = mkPreludeTyConUnique 34
1335 stablePtrPrimTyConKey                   = mkPreludeTyConUnique 35
1336 stablePtrTyConKey                       = mkPreludeTyConUnique 36
1337 anyTyConKey                             = mkPreludeTyConUnique 37
1338 eqTyConKey                              = mkPreludeTyConUnique 38
1339 arrayArrayPrimTyConKey                  = mkPreludeTyConUnique 39
1340 mutableArrayArrayPrimTyConKey           = mkPreludeTyConUnique 40
1341
1342 statePrimTyConKey, stableNamePrimTyConKey, stableNameTyConKey,
1343     mutVarPrimTyConKey, ioTyConKey,
1344     wordPrimTyConKey, wordTyConKey, word8TyConKey, word16TyConKey,
1345     word32PrimTyConKey, word32TyConKey, word64PrimTyConKey, word64TyConKey,
1346     liftedConKey, unliftedConKey, anyBoxConKey, kindConKey, boxityConKey,
1347     typeConKey, threadIdPrimTyConKey, bcoPrimTyConKey, ptrTyConKey,
1348     funPtrTyConKey, tVarPrimTyConKey, eqPrimTyConKey,
1349     eqReprPrimTyConKey :: Unique
1350 statePrimTyConKey                       = mkPreludeTyConUnique 50
1351 stableNamePrimTyConKey                  = mkPreludeTyConUnique 51
1352 stableNameTyConKey                      = mkPreludeTyConUnique 52
1353 eqPrimTyConKey                          = mkPreludeTyConUnique 53
1354 eqReprPrimTyConKey                      = mkPreludeTyConUnique 54
1355 mutVarPrimTyConKey                      = mkPreludeTyConUnique 55
1356 ioTyConKey                              = mkPreludeTyConUnique 56
1357 wordPrimTyConKey                        = mkPreludeTyConUnique 58
1358 wordTyConKey                            = mkPreludeTyConUnique 59
1359 word8TyConKey                           = mkPreludeTyConUnique 60
1360 word16TyConKey                          = mkPreludeTyConUnique 61
1361 word32PrimTyConKey                      = mkPreludeTyConUnique 62
1362 word32TyConKey                          = mkPreludeTyConUnique 63
1363 word64PrimTyConKey                      = mkPreludeTyConUnique 64
1364 word64TyConKey                          = mkPreludeTyConUnique 65
1365 liftedConKey                            = mkPreludeTyConUnique 66
1366 unliftedConKey                          = mkPreludeTyConUnique 67
1367 anyBoxConKey                            = mkPreludeTyConUnique 68
1368 kindConKey                              = mkPreludeTyConUnique 69
1369 boxityConKey                            = mkPreludeTyConUnique 70
1370 typeConKey                              = mkPreludeTyConUnique 71
1371 threadIdPrimTyConKey                    = mkPreludeTyConUnique 72
1372 bcoPrimTyConKey                         = mkPreludeTyConUnique 73
1373 ptrTyConKey                             = mkPreludeTyConUnique 74
1374 funPtrTyConKey                          = mkPreludeTyConUnique 75
1375 tVarPrimTyConKey                        = mkPreludeTyConUnique 76
1376
1377 -- Parallel array type constructor
1378 parrTyConKey :: Unique
1379 parrTyConKey                            = mkPreludeTyConUnique 82
1380
1381 -- dotnet interop
1382 objectTyConKey :: Unique
1383 objectTyConKey                          = mkPreludeTyConUnique 83
1384
1385 eitherTyConKey :: Unique
1386 eitherTyConKey                          = mkPreludeTyConUnique 84
1387
1388 -- Super Kinds constructors
1389 superKindTyConKey :: Unique
1390 superKindTyConKey                     = mkPreludeTyConUnique 85
1391
1392 -- Kind constructors
1393 liftedTypeKindTyConKey, anyKindTyConKey, openTypeKindTyConKey,
1394   unliftedTypeKindTyConKey, constraintKindTyConKey :: Unique
1395 anyKindTyConKey                         = mkPreludeTyConUnique 86
1396 liftedTypeKindTyConKey                  = mkPreludeTyConUnique 87
1397 openTypeKindTyConKey                    = mkPreludeTyConUnique 88
1398 unliftedTypeKindTyConKey                = mkPreludeTyConUnique 89
1399 constraintKindTyConKey                  = mkPreludeTyConUnique 92
1400
1401 -- Coercion constructors
1402 symCoercionTyConKey, transCoercionTyConKey, leftCoercionTyConKey,
1403     rightCoercionTyConKey, instCoercionTyConKey, unsafeCoercionTyConKey,
1404     csel1CoercionTyConKey, csel2CoercionTyConKey, cselRCoercionTyConKey
1405     :: Unique
1406 symCoercionTyConKey                     = mkPreludeTyConUnique 93
1407 transCoercionTyConKey                   = mkPreludeTyConUnique 94
1408 leftCoercionTyConKey                    = mkPreludeTyConUnique 95
1409 rightCoercionTyConKey                   = mkPreludeTyConUnique 96
1410 instCoercionTyConKey                    = mkPreludeTyConUnique 97
1411 unsafeCoercionTyConKey                  = mkPreludeTyConUnique 98
1412 csel1CoercionTyConKey                   = mkPreludeTyConUnique 99
1413 csel2CoercionTyConKey                   = mkPreludeTyConUnique 100
1414 cselRCoercionTyConKey                   = mkPreludeTyConUnique 101
1415
1416 pluginTyConKey :: Unique
1417 pluginTyConKey                          = mkPreludeTyConUnique 102
1418
1419 unknownTyConKey, unknown1TyConKey, unknown2TyConKey, unknown3TyConKey,
1420     opaqueTyConKey :: Unique
1421 unknownTyConKey                         = mkPreludeTyConUnique 129
1422 unknown1TyConKey                        = mkPreludeTyConUnique 130
1423 unknown2TyConKey                        = mkPreludeTyConUnique 131
1424 unknown3TyConKey                        = mkPreludeTyConUnique 132
1425 opaqueTyConKey                          = mkPreludeTyConUnique 133
1426
1427 stringTyConKey :: Unique
1428 stringTyConKey                          = mkPreludeTyConUnique 134
1429
1430 -- Generics (Unique keys)
1431 v1TyConKey, u1TyConKey, par1TyConKey, rec1TyConKey,
1432   k1TyConKey, m1TyConKey, sumTyConKey, prodTyConKey,
1433   compTyConKey, rTyConKey, pTyConKey, dTyConKey,
1434   cTyConKey, sTyConKey, rec0TyConKey, par0TyConKey,
1435   d1TyConKey, c1TyConKey, s1TyConKey, noSelTyConKey,
1436   repTyConKey, rep1TyConKey :: Unique
1437
1438 v1TyConKey    = mkPreludeTyConUnique 135
1439 u1TyConKey    = mkPreludeTyConUnique 136
1440 par1TyConKey  = mkPreludeTyConUnique 137
1441 rec1TyConKey  = mkPreludeTyConUnique 138
1442 k1TyConKey    = mkPreludeTyConUnique 139
1443 m1TyConKey    = mkPreludeTyConUnique 140
1444
1445 sumTyConKey   = mkPreludeTyConUnique 141
1446 prodTyConKey  = mkPreludeTyConUnique 142
1447 compTyConKey  = mkPreludeTyConUnique 143
1448
1449 rTyConKey = mkPreludeTyConUnique 144
1450 pTyConKey = mkPreludeTyConUnique 145
1451 dTyConKey = mkPreludeTyConUnique 146
1452 cTyConKey = mkPreludeTyConUnique 147
1453 sTyConKey = mkPreludeTyConUnique 148
1454
1455 rec0TyConKey  = mkPreludeTyConUnique 149
1456 par0TyConKey  = mkPreludeTyConUnique 150
1457 d1TyConKey    = mkPreludeTyConUnique 151
1458 c1TyConKey    = mkPreludeTyConUnique 152
1459 s1TyConKey    = mkPreludeTyConUnique 153
1460 noSelTyConKey = mkPreludeTyConUnique 154
1461
1462 repTyConKey  = mkPreludeTyConUnique 155
1463 rep1TyConKey = mkPreludeTyConUnique 156
1464
1465 -- Type-level naturals
1466 typeNatKindConNameKey, typeSymbolKindConNameKey,
1467   typeNatAddTyFamNameKey, typeNatMulTyFamNameKey, typeNatExpTyFamNameKey,
1468   typeNatLeqTyFamNameKey, typeNatSubTyFamNameKey
1469   :: Unique
1470 typeNatKindConNameKey     = mkPreludeTyConUnique 160
1471 typeSymbolKindConNameKey  = mkPreludeTyConUnique 161
1472 typeNatAddTyFamNameKey    = mkPreludeTyConUnique 162
1473 typeNatMulTyFamNameKey    = mkPreludeTyConUnique 163
1474 typeNatExpTyFamNameKey    = mkPreludeTyConUnique 164
1475 typeNatLeqTyFamNameKey    = mkPreludeTyConUnique 165
1476 typeNatSubTyFamNameKey    = mkPreludeTyConUnique 166
1477
1478 ntTyConKey:: Unique
1479 ntTyConKey = mkPreludeTyConUnique 174
1480 coercibleTyConKey :: Unique
1481 coercibleTyConKey = mkPreludeTyConUnique 175
1482
1483 proxyPrimTyConKey :: Unique
1484 proxyPrimTyConKey = mkPreludeTyConUnique 176
1485
1486 ---------------- Template Haskell -------------------
1487 --      USES TyConUniques 200-299
1488 -----------------------------------------------------
1489
1490 ----------------------- SIMD ------------------------
1491 --      USES TyConUniques 300-399
1492 -----------------------------------------------------
1493
1494 #include "primop-vector-uniques.hs-incl"
1495
1496 unitTyConKey :: Unique
1497 unitTyConKey = mkTupleTyConUnique BoxedTuple 0
1498 \end{code}
1499
1500 %************************************************************************
1501 %*                                                                      *
1502 \subsubsection[Uniques-prelude-DataCons]{@Uniques@ for wired-in @DataCons@}
1503 %*                                                                      *
1504 %************************************************************************
1505
1506 \begin{code}
1507 charDataConKey, consDataConKey, doubleDataConKey, falseDataConKey,
1508     floatDataConKey, intDataConKey, nilDataConKey, ratioDataConKey,
1509     stableNameDataConKey, trueDataConKey, wordDataConKey,
1510     ioDataConKey, integerDataConKey, eqBoxDataConKey, coercibleDataConKey :: Unique
1511 charDataConKey                          = mkPreludeDataConUnique  1
1512 consDataConKey                          = mkPreludeDataConUnique  2
1513 doubleDataConKey                        = mkPreludeDataConUnique  3
1514 falseDataConKey                         = mkPreludeDataConUnique  4
1515 floatDataConKey                         = mkPreludeDataConUnique  5
1516 intDataConKey                           = mkPreludeDataConUnique  6
1517 nilDataConKey                           = mkPreludeDataConUnique 11
1518 ratioDataConKey                         = mkPreludeDataConUnique 12
1519 stableNameDataConKey                    = mkPreludeDataConUnique 14
1520 trueDataConKey                          = mkPreludeDataConUnique 15
1521 wordDataConKey                          = mkPreludeDataConUnique 16
1522 ioDataConKey                            = mkPreludeDataConUnique 17
1523 integerDataConKey                       = mkPreludeDataConUnique 18
1524 eqBoxDataConKey                         = mkPreludeDataConUnique 19
1525
1526 -- Generic data constructors
1527 crossDataConKey, inlDataConKey, inrDataConKey, genUnitDataConKey :: Unique
1528 crossDataConKey                         = mkPreludeDataConUnique 20
1529 inlDataConKey                           = mkPreludeDataConUnique 21
1530 inrDataConKey                           = mkPreludeDataConUnique 22
1531 genUnitDataConKey                       = mkPreludeDataConUnique 23
1532
1533 -- Data constructor for parallel arrays
1534 parrDataConKey :: Unique
1535 parrDataConKey                          = mkPreludeDataConUnique 24
1536
1537 leftDataConKey, rightDataConKey :: Unique
1538 leftDataConKey                          = mkPreludeDataConUnique 25
1539 rightDataConKey                         = mkPreludeDataConUnique 26
1540
1541 ltDataConKey, eqDataConKey, gtDataConKey :: Unique
1542 ltDataConKey                            = mkPreludeDataConUnique 27
1543 eqDataConKey                            = mkPreludeDataConUnique 28
1544 gtDataConKey                            = mkPreludeDataConUnique 29
1545
1546 -- For integer-gmp only
1547 integerGmpSDataConKey, integerGmpJDataConKey :: Unique
1548 integerGmpSDataConKey                   = mkPreludeDataConUnique 30
1549 integerGmpJDataConKey                   = mkPreludeDataConUnique 31
1550
1551 coercibleDataConKey                     = mkPreludeDataConUnique 32
1552 \end{code}
1553
1554 %************************************************************************
1555 %*                                                                      *
1556 \subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}
1557 %*                                                                      *
1558 %************************************************************************
1559
1560 \begin{code}
1561 wildCardKey, absentErrorIdKey, augmentIdKey, appendIdKey,
1562     buildIdKey, errorIdKey, foldrIdKey, recSelErrorIdKey,
1563     seqIdKey, irrefutPatErrorIdKey, eqStringIdKey,
1564     noMethodBindingErrorIdKey, nonExhaustiveGuardsErrorIdKey,
1565     runtimeErrorIdKey, patErrorIdKey,
1566     realWorldPrimIdKey, recConErrorIdKey,
1567     unpackCStringUtf8IdKey, unpackCStringAppendIdKey,
1568     unpackCStringFoldrIdKey, unpackCStringIdKey :: Unique
1569 wildCardKey                   = mkPreludeMiscIdUnique  0  -- See Note [WildCard]
1570 absentErrorIdKey              = mkPreludeMiscIdUnique  1
1571 augmentIdKey                  = mkPreludeMiscIdUnique  2
1572 appendIdKey                   = mkPreludeMiscIdUnique  3
1573 buildIdKey                    = mkPreludeMiscIdUnique  4
1574 errorIdKey                    = mkPreludeMiscIdUnique  5
1575 foldrIdKey                    = mkPreludeMiscIdUnique  6
1576 recSelErrorIdKey              = mkPreludeMiscIdUnique  7
1577 seqIdKey                      = mkPreludeMiscIdUnique  8
1578 irrefutPatErrorIdKey          = mkPreludeMiscIdUnique  9
1579 eqStringIdKey                 = mkPreludeMiscIdUnique 10
1580 noMethodBindingErrorIdKey     = mkPreludeMiscIdUnique 11
1581 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 12
1582 runtimeErrorIdKey             = mkPreludeMiscIdUnique 13
1583 patErrorIdKey                 = mkPreludeMiscIdUnique 14
1584 realWorldPrimIdKey            = mkPreludeMiscIdUnique 15
1585 recConErrorIdKey              = mkPreludeMiscIdUnique 16
1586 unpackCStringUtf8IdKey        = mkPreludeMiscIdUnique 17
1587 unpackCStringAppendIdKey      = mkPreludeMiscIdUnique 18
1588 unpackCStringFoldrIdKey       = mkPreludeMiscIdUnique 19
1589 unpackCStringIdKey            = mkPreludeMiscIdUnique 20
1590
1591 unsafeCoerceIdKey, concatIdKey, filterIdKey, zipIdKey, bindIOIdKey,
1592     returnIOIdKey, newStablePtrIdKey,
1593     printIdKey, failIOIdKey, nullAddrIdKey, voidArgIdKey,
1594     fstIdKey, sndIdKey, otherwiseIdKey, assertIdKey, runSTRepIdKey :: Unique
1595 unsafeCoerceIdKey             = mkPreludeMiscIdUnique 30
1596 concatIdKey                   = mkPreludeMiscIdUnique 31
1597 filterIdKey                   = mkPreludeMiscIdUnique 32
1598 zipIdKey                      = mkPreludeMiscIdUnique 33
1599 bindIOIdKey                   = mkPreludeMiscIdUnique 34
1600 returnIOIdKey                 = mkPreludeMiscIdUnique 35
1601 newStablePtrIdKey             = mkPreludeMiscIdUnique 36
1602 printIdKey                    = mkPreludeMiscIdUnique 37
1603 failIOIdKey                   = mkPreludeMiscIdUnique 38
1604 nullAddrIdKey                 = mkPreludeMiscIdUnique 39
1605 voidArgIdKey                  = mkPreludeMiscIdUnique 40
1606 fstIdKey                      = mkPreludeMiscIdUnique 41
1607 sndIdKey                      = mkPreludeMiscIdUnique 42
1608 otherwiseIdKey                = mkPreludeMiscIdUnique 43
1609 assertIdKey                   = mkPreludeMiscIdUnique 44
1610 runSTRepIdKey                 = mkPreludeMiscIdUnique 45
1611
1612 mkIntegerIdKey, smallIntegerIdKey, wordToIntegerIdKey,
1613     integerToWordIdKey, integerToIntIdKey,
1614     integerToWord64IdKey, integerToInt64IdKey,
1615     word64ToIntegerIdKey, int64ToIntegerIdKey,
1616     plusIntegerIdKey, timesIntegerIdKey, minusIntegerIdKey,
1617     negateIntegerIdKey,
1618     eqIntegerPrimIdKey, neqIntegerPrimIdKey, absIntegerIdKey, signumIntegerIdKey,
1619     leIntegerPrimIdKey, gtIntegerPrimIdKey, ltIntegerPrimIdKey, geIntegerPrimIdKey,
1620     compareIntegerIdKey, quotRemIntegerIdKey, divModIntegerIdKey,
1621     quotIntegerIdKey, remIntegerIdKey, divIntegerIdKey, modIntegerIdKey,
1622     floatFromIntegerIdKey, doubleFromIntegerIdKey,
1623     encodeFloatIntegerIdKey, encodeDoubleIntegerIdKey,
1624     decodeDoubleIntegerIdKey,
1625     gcdIntegerIdKey, lcmIntegerIdKey,
1626     andIntegerIdKey, orIntegerIdKey, xorIntegerIdKey, complementIntegerIdKey,
1627     shiftLIntegerIdKey, shiftRIntegerIdKey :: Unique
1628 mkIntegerIdKey                = mkPreludeMiscIdUnique 60
1629 smallIntegerIdKey             = mkPreludeMiscIdUnique 61
1630 integerToWordIdKey            = mkPreludeMiscIdUnique 62
1631 integerToIntIdKey             = mkPreludeMiscIdUnique 63
1632 integerToWord64IdKey          = mkPreludeMiscIdUnique 64
1633 integerToInt64IdKey           = mkPreludeMiscIdUnique 65
1634 plusIntegerIdKey              = mkPreludeMiscIdUnique 66
1635 timesIntegerIdKey             = mkPreludeMiscIdUnique 67
1636 minusIntegerIdKey             = mkPreludeMiscIdUnique 68
1637 negateIntegerIdKey            = mkPreludeMiscIdUnique 69
1638 eqIntegerPrimIdKey            = mkPreludeMiscIdUnique 70
1639 neqIntegerPrimIdKey           = mkPreludeMiscIdUnique 71
1640 absIntegerIdKey               = mkPreludeMiscIdUnique 72
1641 signumIntegerIdKey            = mkPreludeMiscIdUnique 73
1642 leIntegerPrimIdKey            = mkPreludeMiscIdUnique 74
1643 gtIntegerPrimIdKey            = mkPreludeMiscIdUnique 75
1644 ltIntegerPrimIdKey            = mkPreludeMiscIdUnique 76
1645 geIntegerPrimIdKey            = mkPreludeMiscIdUnique 77
1646 compareIntegerIdKey           = mkPreludeMiscIdUnique 78
1647 quotIntegerIdKey              = mkPreludeMiscIdUnique 79
1648 remIntegerIdKey               = mkPreludeMiscIdUnique 80
1649 divIntegerIdKey               = mkPreludeMiscIdUnique 81
1650 modIntegerIdKey               = mkPreludeMiscIdUnique 82
1651 divModIntegerIdKey            = mkPreludeMiscIdUnique 83
1652 quotRemIntegerIdKey           = mkPreludeMiscIdUnique 84
1653 floatFromIntegerIdKey         = mkPreludeMiscIdUnique 85
1654 doubleFromIntegerIdKey        = mkPreludeMiscIdUnique 86
1655 encodeFloatIntegerIdKey       = mkPreludeMiscIdUnique 87
1656 encodeDoubleIntegerIdKey      = mkPreludeMiscIdUnique 88
1657 gcdIntegerIdKey               = mkPreludeMiscIdUnique 89
1658 lcmIntegerIdKey               = mkPreludeMiscIdUnique 90
1659 andIntegerIdKey               = mkPreludeMiscIdUnique 91
1660 orIntegerIdKey                = mkPreludeMiscIdUnique 92
1661 xorIntegerIdKey               = mkPreludeMiscIdUnique 93
1662 complementIntegerIdKey        = mkPreludeMiscIdUnique 94
1663 shiftLIntegerIdKey            = mkPreludeMiscIdUnique 95
1664 shiftRIntegerIdKey            = mkPreludeMiscIdUnique 96
1665 wordToIntegerIdKey            = mkPreludeMiscIdUnique 97
1666 word64ToIntegerIdKey          = mkPreludeMiscIdUnique 98
1667 int64ToIntegerIdKey           = mkPreludeMiscIdUnique 99
1668 decodeDoubleIntegerIdKey      = mkPreludeMiscIdUnique 100
1669
1670 rootMainKey, runMainKey :: Unique
1671 rootMainKey                   = mkPreludeMiscIdUnique 101
1672 runMainKey                    = mkPreludeMiscIdUnique 102
1673
1674 thenIOIdKey, lazyIdKey, assertErrorIdKey :: Unique
1675 thenIOIdKey                   = mkPreludeMiscIdUnique 103
1676 lazyIdKey                     = mkPreludeMiscIdUnique 104
1677 assertErrorIdKey              = mkPreludeMiscIdUnique 105
1678
1679 breakpointIdKey, breakpointCondIdKey, breakpointAutoIdKey,
1680     breakpointJumpIdKey, breakpointCondJumpIdKey,
1681     breakpointAutoJumpIdKey :: Unique
1682 breakpointIdKey               = mkPreludeMiscIdUnique 110
1683 breakpointCondIdKey           = mkPreludeMiscIdUnique 111
1684 breakpointAutoIdKey           = mkPreludeMiscIdUnique 112
1685 breakpointJumpIdKey           = mkPreludeMiscIdUnique 113
1686 breakpointCondJumpIdKey       = mkPreludeMiscIdUnique 114
1687 breakpointAutoJumpIdKey       = mkPreludeMiscIdUnique 115
1688
1689 inlineIdKey :: Unique
1690 inlineIdKey                   = mkPreludeMiscIdUnique 120
1691
1692 mapIdKey, groupWithIdKey, dollarIdKey :: Unique
1693 mapIdKey              = mkPreludeMiscIdUnique 121
1694 groupWithIdKey        = mkPreludeMiscIdUnique 122
1695 dollarIdKey           = mkPreludeMiscIdUnique 123
1696
1697 coercionTokenIdKey :: Unique
1698 coercionTokenIdKey    = mkPreludeMiscIdUnique 124
1699
1700 rationalToFloatIdKey, rationalToDoubleIdKey :: Unique
1701 rationalToFloatIdKey   = mkPreludeMiscIdUnique 130
1702 rationalToDoubleIdKey  = mkPreludeMiscIdUnique 131
1703
1704 -- dotnet interop
1705 unmarshalObjectIdKey, marshalObjectIdKey, marshalStringIdKey,
1706     unmarshalStringIdKey, checkDotnetResNameIdKey :: Unique
1707 unmarshalObjectIdKey          = mkPreludeMiscIdUnique 150
1708 marshalObjectIdKey            = mkPreludeMiscIdUnique 151
1709 marshalStringIdKey            = mkPreludeMiscIdUnique 152
1710 unmarshalStringIdKey          = mkPreludeMiscIdUnique 153
1711 checkDotnetResNameIdKey       = mkPreludeMiscIdUnique 154
1712
1713 undefinedKey :: Unique
1714 undefinedKey                  = mkPreludeMiscIdUnique 155
1715
1716 magicSingIKey :: Unique
1717 magicSingIKey              = mkPreludeMiscIdUnique 156
1718
1719 coerceKey :: Unique
1720 coerceKey                     = mkPreludeMiscIdUnique 157
1721 \end{code}
1722
1723 Certain class operations from Prelude classes.  They get their own
1724 uniques so we can look them up easily when we want to conjure them up
1725 during type checking.
1726
1727 \begin{code}
1728         -- Just a place holder for  unbound variables  produced by the renamer:
1729 unboundKey :: Unique
1730 unboundKey                    = mkPreludeMiscIdUnique 160
1731
1732 fromIntegerClassOpKey, minusClassOpKey, fromRationalClassOpKey,
1733     enumFromClassOpKey, enumFromThenClassOpKey, enumFromToClassOpKey,
1734     enumFromThenToClassOpKey, eqClassOpKey, geClassOpKey, negateClassOpKey,
1735     failMClassOpKey, bindMClassOpKey, thenMClassOpKey, returnMClassOpKey,
1736     fmapClassOpKey
1737     :: Unique
1738 fromIntegerClassOpKey         = mkPreludeMiscIdUnique 160
1739 minusClassOpKey               = mkPreludeMiscIdUnique 161
1740 fromRationalClassOpKey        = mkPreludeMiscIdUnique 162
1741 enumFromClassOpKey            = mkPreludeMiscIdUnique 163
1742 enumFromThenClassOpKey        = mkPreludeMiscIdUnique 164
1743 enumFromToClassOpKey          = mkPreludeMiscIdUnique 165
1744 enumFromThenToClassOpKey      = mkPreludeMiscIdUnique 166
1745 eqClassOpKey                  = mkPreludeMiscIdUnique 167
1746 geClassOpKey                  = mkPreludeMiscIdUnique 168
1747 negateClassOpKey              = mkPreludeMiscIdUnique 169
1748 failMClassOpKey               = mkPreludeMiscIdUnique 170
1749 bindMClassOpKey               = mkPreludeMiscIdUnique 171 -- (>>=)
1750 thenMClassOpKey               = mkPreludeMiscIdUnique 172 -- (>>)
1751 fmapClassOpKey                = mkPreludeMiscIdUnique 173
1752 returnMClassOpKey             = mkPreludeMiscIdUnique 174
1753
1754 -- Recursive do notation
1755 mfixIdKey :: Unique
1756 mfixIdKey       = mkPreludeMiscIdUnique 175
1757
1758 -- Arrow notation
1759 arrAIdKey, composeAIdKey, firstAIdKey, appAIdKey, choiceAIdKey,
1760     loopAIdKey :: Unique
1761 arrAIdKey       = mkPreludeMiscIdUnique 180
1762 composeAIdKey   = mkPreludeMiscIdUnique 181 -- >>>
1763 firstAIdKey     = mkPreludeMiscIdUnique 182
1764 appAIdKey       = mkPreludeMiscIdUnique 183
1765 choiceAIdKey    = mkPreludeMiscIdUnique 184 --  |||
1766 loopAIdKey      = mkPreludeMiscIdUnique 185
1767
1768 fromStringClassOpKey :: Unique
1769 fromStringClassOpKey          = mkPreludeMiscIdUnique 186
1770
1771 -- Annotation type checking
1772 toAnnotationWrapperIdKey :: Unique
1773 toAnnotationWrapperIdKey      = mkPreludeMiscIdUnique 187
1774
1775 -- Conversion functions
1776 fromIntegralIdKey, realToFracIdKey, toIntegerClassOpKey, toRationalClassOpKey :: Unique
1777 fromIntegralIdKey    = mkPreludeMiscIdUnique 190
1778 realToFracIdKey      = mkPreludeMiscIdUnique 191
1779 toIntegerClassOpKey  = mkPreludeMiscIdUnique 192
1780 toRationalClassOpKey = mkPreludeMiscIdUnique 193
1781
1782 -- Monad comprehensions
1783 guardMIdKey, liftMIdKey, mzipIdKey :: Unique
1784 guardMIdKey     = mkPreludeMiscIdUnique 194
1785 liftMIdKey      = mkPreludeMiscIdUnique 195
1786 mzipIdKey       = mkPreludeMiscIdUnique 196
1787
1788 -- GHCi
1789 ghciStepIoMClassOpKey :: Unique
1790 ghciStepIoMClassOpKey = mkPreludeMiscIdUnique 197
1791
1792 -- Overloaded lists
1793 isListClassKey, fromListClassOpKey, fromListNClassOpKey, toListClassOpKey :: Unique
1794 isListClassKey = mkPreludeMiscIdUnique 198
1795 fromListClassOpKey = mkPreludeMiscIdUnique 199
1796 fromListNClassOpKey = mkPreludeMiscIdUnique 500
1797 toListClassOpKey = mkPreludeMiscIdUnique 501
1798
1799 proxyHashKey :: Unique
1800 proxyHashKey = mkPreludeMiscIdUnique 502
1801
1802 ---------------- Template Haskell -------------------
1803 --      USES IdUniques 200-499
1804 -----------------------------------------------------
1805 \end{code}
1806
1807 %************************************************************************
1808 %*                                                                      *
1809 \subsection[Class-std-groups]{Standard groups of Prelude classes}
1810 %*                                                                      *
1811 %************************************************************************
1812
1813 NOTE: @Eq@ and @Text@ do need to appear in @standardClasses@
1814 even though every numeric class has these two as a superclass,
1815 because the list of ambiguous dictionaries hasn't been simplified.
1816
1817 \begin{code}
1818 numericClassKeys :: [Unique]
1819 numericClassKeys =
1820         [ numClassKey
1821         , realClassKey
1822         , integralClassKey
1823         ]
1824         ++ fractionalClassKeys
1825
1826 fractionalClassKeys :: [Unique]
1827 fractionalClassKeys =
1828         [ fractionalClassKey
1829         , floatingClassKey
1830         , realFracClassKey
1831         , realFloatClassKey
1832         ]
1833
1834 -- The "standard classes" are used in defaulting (Haskell 98 report 4.3.4),
1835 -- and are: "classes defined in the Prelude or a standard library"
1836 standardClassKeys :: [Unique]
1837 standardClassKeys = derivableClassKeys ++ numericClassKeys
1838                   ++ [randomClassKey, randomGenClassKey,
1839                       functorClassKey,
1840                       monadClassKey, monadPlusClassKey,
1841                       isStringClassKey,
1842                       applicativeClassKey, foldableClassKey,
1843                       traversableClassKey, alternativeClassKey
1844                      ]
1845 \end{code}
1846
1847 @derivableClassKeys@ is also used in checking \tr{deriving} constructs
1848 (@TcDeriv@).
1849
1850 \begin{code}
1851 derivableClassKeys :: [Unique]
1852 derivableClassKeys
1853   = [ eqClassKey, ordClassKey, enumClassKey, ixClassKey,
1854       boundedClassKey, showClassKey, readClassKey ]
1855 \end{code}
1856