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