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