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