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