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