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