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