Merge branch 'master' of http://darcs.haskell.org/ghc into ghc-generics
[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 \begin{code}
39 module PrelNames (
40         Unique, Uniquable(..), hasKey,  -- Re-exported for convenience
41
42         -----------------------------------------------------------
43         module PrelNames,       -- A huge bunch of (a) Names,  e.g. intTyConName
44                                 --                 (b) Uniques e.g. intTyConKey
45                                 --                 (c) Groups of classes and types
46                                 --                 (d) miscellaneous things
47                                 -- So many that we export them all
48     ) where
49
50 #include "HsVersions.h"
51
52 import Module
53 import OccName
54 import RdrName    ( RdrName, nameRdrName, mkOrig, rdrNameOcc, mkUnqual )
55 import Unique     ( Unique, Uniquable(..), hasKey,
56                     mkPreludeMiscIdUnique, mkPreludeDataConUnique,
57                     mkPreludeTyConUnique, mkPreludeClassUnique,
58                     mkTupleTyConUnique
59                   ) 
60 import BasicTypes ( Boxity(..), Arity )
61 import Name       ( Name, mkInternalName, mkExternalName, mkSystemVarName )
62 import SrcLoc
63 import FastString
64 \end{code}
65
66
67 %************************************************************************
68 %*                                                                      *
69 \subsection{Local Names}
70 %*                                                                      *
71 %************************************************************************
72
73 This *local* name is used by the interactive stuff
74
75 \begin{code}
76 itName :: Unique -> Name
77 itName uniq = mkInternalName uniq (mkOccNameFS varName (fsLit "it")) noSrcSpan
78 \end{code}
79
80 \begin{code}
81 -- mkUnboundName makes a place-holder Name; it shouldn't be looked at except possibly
82 -- during compiler debugging.
83 mkUnboundName :: RdrName -> Name
84 mkUnboundName rdr_name = mkInternalName unboundKey (rdrNameOcc rdr_name) noSrcSpan
85
86 isUnboundName :: Name -> Bool
87 isUnboundName name = name `hasKey` unboundKey
88 \end{code}
89
90
91 %************************************************************************
92 %*                                                                      *
93 \subsection{Known key Names}
94 %*                                                                      *
95 %************************************************************************
96
97 This section tells what the compiler knows about the association of
98 names with uniques.  These ones are the *non* wired-in ones.  The
99 wired in ones are defined in TysWiredIn etc.
100
101 The names for DPH can come from one of multiple backend packages. At the point where 
102 'basicKnownKeyNames' is used, we don't know which backend it will be.  Hence, we list
103 the names for multiple backends.  That works out fine, although they use the same uniques,
104 as we are guaranteed to only load one backend; hence, only one of the different names
105 sharing a unique will be used.
106
107 \begin{code}
108 basicKnownKeyNames :: [Name]
109 basicKnownKeyNames
110  = genericTyConNames
111  ++ typeableClassNames
112  ++ dphKnownKeyNames dphSeqPackageId ++ dphKnownKeyNames dphParPackageId
113  ++ [   -- Type constructors (synonyms especially)
114         ioTyConName, ioDataConName,
115         runMainIOName,
116         orderingTyConName,
117         rationalTyConName,
118         stringTyConName,
119         ratioDataConName,
120         ratioTyConName,
121         integerTyConName, smallIntegerName,
122
123         --  Classes.  *Must* include:
124         --      classes that are grabbed by key (e.g., eqClassKey)
125         --      classes in "Class.standardClassKeys" (quite a few)
126         eqClassName,                    -- mentioned, derivable
127         ordClassName,                   -- derivable
128         boundedClassName,               -- derivable
129         numClassName,                   -- mentioned, numeric
130         enumClassName,                  -- derivable
131         monadClassName,
132         functorClassName,
133         realClassName,                  -- numeric
134         integralClassName,              -- numeric
135         fractionalClassName,            -- numeric
136         floatingClassName,              -- numeric
137         realFracClassName,              -- numeric
138         realFloatClassName,             -- numeric
139         dataClassName, 
140         isStringClassName,
141         applicativeClassName,
142         foldableClassName,
143         traversableClassName,
144
145         -- Numeric stuff
146         negateName, minusName, geName, eqName,
147
148         -- Conversion functions
149         fromRationalName, fromIntegerName,
150         toIntegerName, toRationalName,
151         fromIntegralName, realToFracName,
152
153         -- String stuff
154         fromStringName,
155         
156         -- Enum stuff
157         enumFromName, enumFromThenName, 
158         enumFromThenToName, enumFromToName,
159
160         -- Monad stuff
161         thenIOName, bindIOName, returnIOName, failIOName,
162         failMName, bindMName, thenMName, returnMName,
163         fmapName,
164
165         -- MonadRec stuff
166         mfixName,
167
168         -- Arrow stuff
169         arrAName, composeAName, firstAName,
170         appAName, choiceAName, loopAName,
171
172         -- Ix stuff
173         ixClassName, 
174
175         -- Show stuff
176         showClassName, 
177
178         -- Read stuff
179         readClassName, 
180
181         -- Stable pointers
182         newStablePtrName,
183
184     -- GHC Extensions
185         groupWithName,
186
187         -- Strings and lists
188         unpackCStringName, unpackCStringAppendName,
189         unpackCStringFoldrName, unpackCStringUtf8Name,
190
191         -- List operations
192         concatName, filterName, mapName,
193         zipName, foldrName, buildName, augmentName, appendName,
194
195         dollarName,         -- The ($) apply function
196
197         -- FFI primitive types that are not wired-in.
198         stablePtrTyConName, ptrTyConName, funPtrTyConName,
199         int8TyConName, int16TyConName, int32TyConName, int64TyConName,
200         wordTyConName, word8TyConName, word16TyConName, word32TyConName, word64TyConName,
201
202         -- Others
203         otherwiseIdName, inlineIdName,
204         plusIntegerName, timesIntegerName,
205         eqStringName, assertName, breakpointName, breakpointCondName,
206         breakpointAutoName,  opaqueTyConName,
207         assertErrorName, runSTRepName,
208         printName, fstName, sndName,
209
210         -- MonadFix
211         monadFixClassName, mfixName,
212
213         -- Other classes
214         randomClassName, randomGenClassName, monadPlusClassName,
215
216         -- Annotation type checking
217         toAnnotationWrapperName
218
219         -- The Either type
220         , eitherTyConName, leftDataConName, rightDataConName
221
222         -- dotnet interop
223         , objectTyConName, marshalObjectName, unmarshalObjectName
224         , marshalStringName, unmarshalStringName, checkDotnetResName
225         
226         -- Generics
227         , genClassName, gen1ClassName
228         , datatypeClassName, constructorClassName, selectorClassName
229         
230         -- Monad comprehensions
231         , guardMName
232         , liftMName
233         , groupMName
234         , mzipName
235     ]
236
237 genericTyConNames :: [Name]
238 genericTyConNames = [
239     v1TyConName, u1TyConName, par1TyConName, rec1TyConName,
240     k1TyConName, m1TyConName, sumTyConName, prodTyConName,
241     compTyConName, rTyConName, pTyConName, dTyConName,
242     cTyConName, sTyConName, rec0TyConName, par0TyConName,
243     d1TyConName, c1TyConName, s1TyConName, noSelTyConName,
244     repTyConName, rep1TyConName
245   ]
246
247 -- Know names from the DPH package which vary depending on the selected DPH backend.
248 --
249 dphKnownKeyNames :: PackageId -> [Name]
250 dphKnownKeyNames dphPkg
251   = map ($ dphPkg)
252     [
253         -- Parallel array operations
254           nullPName, lengthPName, replicatePName,       singletonPName, mapPName,
255           filterPName, zipPName, crossMapPName, indexPName,
256           toPName, emptyPName, appPName,
257         enumFromToPName, enumFromThenToPName
258
259     ]
260 \end{code}
261
262
263 %************************************************************************
264 %*                                                                      *
265 \subsection{Module names}
266 %*                                                                      *
267 %************************************************************************
268
269
270 --MetaHaskell Extension Add a new module here
271 \begin{code}
272 pRELUDE :: Module
273 pRELUDE         = mkBaseModule_ pRELUDE_NAME
274
275 gHC_PRIM, gHC_TYPES, gHC_UNIT, gHC_ORDERING, gHC_GENERICS,
276     gHC_MAGIC,
277     gHC_CLASSES, gHC_BASE, gHC_ENUM, gHC_CSTRING,
278     gHC_SHOW, gHC_READ, gHC_NUM, gHC_INTEGER, gHC_INTEGER_TYPE, gHC_LIST,
279     gHC_TUPLE, dATA_TUPLE, dATA_EITHER, dATA_STRING, dATA_FOLDABLE, dATA_TRAVERSABLE,
280     gHC_PACK, gHC_CONC, gHC_IO, gHC_IO_Exception,
281     gHC_ST, gHC_ARR, gHC_STABLE, gHC_ADDR, gHC_PTR, gHC_ERR, gHC_REAL,
282     gHC_FLOAT, gHC_TOP_HANDLER, sYSTEM_IO, dYNAMIC, tYPEABLE, gENERICS,
283     dOTNET, rEAD_PREC, lEX, gHC_INT, gHC_WORD, mONAD, mONAD_FIX, mONAD_GROUP, mONAD_ZIP,
284     aRROW, cONTROL_APPLICATIVE, gHC_DESUGAR, rANDOM, gHC_EXTS,
285     cONTROL_EXCEPTION_BASE :: Module
286
287 gHC_PRIM        = mkPrimModule (fsLit "GHC.Prim")   -- Primitive types and values
288 gHC_TYPES       = mkPrimModule (fsLit "GHC.Types")
289 gHC_UNIT        = mkPrimModule (fsLit "GHC.Unit")
290 gHC_ORDERING    = mkPrimModule (fsLit "GHC.Ordering")
291 gHC_GENERICS    = mkPrimModule (fsLit "GHC.Generics")
292 gHC_MAGIC       = mkPrimModule (fsLit "GHC.Magic")
293 gHC_CSTRING     = mkPrimModule (fsLit "GHC.CString")
294
295 gHC_CLASSES     = mkBaseModule (fsLit "GHC.Classes")
296 gHC_BASE        = mkBaseModule (fsLit "GHC.Base")
297 gHC_ENUM        = mkBaseModule (fsLit "GHC.Enum")
298 gHC_SHOW        = mkBaseModule (fsLit "GHC.Show")
299 gHC_READ        = mkBaseModule (fsLit "GHC.Read")
300 gHC_NUM         = mkBaseModule (fsLit "GHC.Num")
301 gHC_INTEGER     = mkIntegerModule (fsLit "GHC.Integer")
302 gHC_INTEGER_TYPE= mkIntegerModule (fsLit "GHC.Integer.Type")
303 gHC_LIST        = mkBaseModule (fsLit "GHC.List")
304 gHC_TUPLE       = mkPrimModule (fsLit "GHC.Tuple")
305 dATA_TUPLE      = mkBaseModule (fsLit "Data.Tuple")
306 dATA_EITHER     = mkBaseModule (fsLit "Data.Either")
307 dATA_STRING     = mkBaseModule (fsLit "Data.String")
308 dATA_FOLDABLE   = mkBaseModule (fsLit "Data.Foldable")
309 dATA_TRAVERSABLE= mkBaseModule (fsLit "Data.Traversable")
310 gHC_PACK        = mkBaseModule (fsLit "GHC.Pack")
311 gHC_CONC        = mkBaseModule (fsLit "GHC.Conc")
312 gHC_IO          = mkBaseModule (fsLit "GHC.IO")
313 gHC_IO_Exception = mkBaseModule (fsLit "GHC.IO.Exception")
314 gHC_ST          = mkBaseModule (fsLit "GHC.ST")
315 gHC_ARR         = mkBaseModule (fsLit "GHC.Arr")
316 gHC_STABLE      = mkBaseModule (fsLit "GHC.Stable")
317 gHC_ADDR        = mkBaseModule (fsLit "GHC.Addr")
318 gHC_PTR         = mkBaseModule (fsLit "GHC.Ptr")
319 gHC_ERR         = mkBaseModule (fsLit "GHC.Err")
320 gHC_REAL        = mkBaseModule (fsLit "GHC.Real")
321 gHC_FLOAT       = mkBaseModule (fsLit "GHC.Float")
322 gHC_TOP_HANDLER = mkBaseModule (fsLit "GHC.TopHandler")
323 sYSTEM_IO       = mkBaseModule (fsLit "System.IO")
324 dYNAMIC         = mkBaseModule (fsLit "Data.Dynamic")
325 tYPEABLE        = mkBaseModule (fsLit "Data.Typeable")
326 gENERICS        = mkBaseModule (fsLit "Data.Data")
327 dOTNET          = mkBaseModule (fsLit "GHC.Dotnet")
328 rEAD_PREC       = mkBaseModule (fsLit "Text.ParserCombinators.ReadPrec")
329 lEX             = mkBaseModule (fsLit "Text.Read.Lex")
330 gHC_INT         = mkBaseModule (fsLit "GHC.Int")
331 gHC_WORD        = mkBaseModule (fsLit "GHC.Word")
332 mONAD           = mkBaseModule (fsLit "Control.Monad")
333 mONAD_FIX       = mkBaseModule (fsLit "Control.Monad.Fix")
334 mONAD_GROUP     = mkBaseModule (fsLit "Control.Monad.Group")
335 mONAD_ZIP       = mkBaseModule (fsLit "Control.Monad.Zip")
336 aRROW           = mkBaseModule (fsLit "Control.Arrow")
337 cONTROL_APPLICATIVE = mkBaseModule (fsLit "Control.Applicative")
338 gHC_DESUGAR = mkBaseModule (fsLit "GHC.Desugar")
339 rANDOM          = mkBaseModule (fsLit "System.Random")
340 gHC_EXTS        = mkBaseModule (fsLit "GHC.Exts")
341 cONTROL_EXCEPTION_BASE = mkBaseModule (fsLit "Control.Exception.Base")
342
343 gHC_PARR :: PackageId -> Module
344 gHC_PARR pkg = mkModule pkg (mkModuleNameFS (fsLit "Data.Array.Parallel"))
345
346 gHC_PARR' :: Module
347 gHC_PARR' = mkBaseModule (fsLit "GHC.PArr")
348
349 mAIN, rOOT_MAIN :: Module
350 mAIN            = mkMainModule_ mAIN_NAME
351 rOOT_MAIN       = mkMainModule (fsLit ":Main") -- Root module for initialisation 
352
353         -- The ':xxx' makes a module name that the user can never
354         -- use himself.  The z-encoding for ':' is "ZC", so the z-encoded
355         -- module name still starts with a capital letter, which keeps
356         -- the z-encoded version consistent.
357 iNTERACTIVE :: Module
358 iNTERACTIVE    = mkMainModule (fsLit ":Interactive")
359
360 pRELUDE_NAME, mAIN_NAME :: ModuleName
361 pRELUDE_NAME   = mkModuleNameFS (fsLit "Prelude")
362 mAIN_NAME      = mkModuleNameFS (fsLit "Main")
363
364 mkPrimModule :: FastString -> Module
365 mkPrimModule m = mkModule primPackageId (mkModuleNameFS m)
366
367 mkIntegerModule :: FastString -> Module
368 mkIntegerModule m = mkModule integerPackageId (mkModuleNameFS m)
369
370 mkBaseModule :: FastString -> Module
371 mkBaseModule m = mkModule basePackageId (mkModuleNameFS m)
372
373 mkBaseModule_ :: ModuleName -> Module
374 mkBaseModule_ m = mkModule basePackageId m
375
376 mkMainModule :: FastString -> Module
377 mkMainModule m = mkModule mainPackageId (mkModuleNameFS m)
378
379 mkMainModule_ :: ModuleName -> Module
380 mkMainModule_ m = mkModule mainPackageId m
381 \end{code}
382
383 %************************************************************************
384 %*                                                                      *
385 \subsection{Constructing the names of tuples
386 %*                                                                      *
387 %************************************************************************
388
389 \begin{code}
390 mkTupleModule :: Boxity -> Arity -> Module
391 mkTupleModule Boxed   0 = gHC_UNIT
392 mkTupleModule Boxed   _ = gHC_TUPLE
393 mkTupleModule Unboxed _ = gHC_PRIM
394 \end{code}
395
396
397 %************************************************************************
398 %*                                                                      *
399                         RdrNames
400 %*                                                                      *
401 %************************************************************************
402
403 \begin{code}
404 main_RDR_Unqual    :: RdrName
405 main_RDR_Unqual = mkUnqual varName (fsLit "main")
406         -- We definitely don't want an Orig RdrName, because
407         -- main might, in principle, be imported into module Main
408
409 forall_tv_RDR, dot_tv_RDR :: RdrName
410 forall_tv_RDR = mkUnqual tvName (fsLit "forall")
411 dot_tv_RDR    = mkUnqual tvName (fsLit ".")
412
413 eq_RDR, ge_RDR, ne_RDR, le_RDR, lt_RDR, gt_RDR, compare_RDR,
414     ltTag_RDR, eqTag_RDR, gtTag_RDR :: RdrName
415 eq_RDR                  = nameRdrName eqName
416 ge_RDR                  = nameRdrName geName
417 ne_RDR                  = varQual_RDR  gHC_CLASSES (fsLit "/=")
418 le_RDR                  = varQual_RDR  gHC_CLASSES (fsLit "<=") 
419 lt_RDR                  = varQual_RDR  gHC_CLASSES (fsLit "<") 
420 gt_RDR                  = varQual_RDR  gHC_CLASSES (fsLit ">")  
421 compare_RDR             = varQual_RDR  gHC_CLASSES (fsLit "compare") 
422 ltTag_RDR               = dataQual_RDR gHC_ORDERING (fsLit "LT") 
423 eqTag_RDR               = dataQual_RDR gHC_ORDERING (fsLit "EQ")
424 gtTag_RDR               = dataQual_RDR gHC_ORDERING (fsLit "GT")
425
426 eqClass_RDR, numClass_RDR, ordClass_RDR, enumClass_RDR, monadClass_RDR
427     :: RdrName
428 eqClass_RDR             = nameRdrName eqClassName
429 numClass_RDR            = nameRdrName numClassName
430 ordClass_RDR            = nameRdrName ordClassName
431 enumClass_RDR           = nameRdrName enumClassName
432 monadClass_RDR          = nameRdrName monadClassName
433
434 map_RDR, append_RDR :: RdrName
435 map_RDR                 = varQual_RDR gHC_BASE (fsLit "map")
436 append_RDR              = varQual_RDR gHC_BASE (fsLit "++")
437
438 foldr_RDR, build_RDR, returnM_RDR, bindM_RDR, failM_RDR :: RdrName
439 foldr_RDR               = nameRdrName foldrName
440 build_RDR               = nameRdrName buildName
441 returnM_RDR             = nameRdrName returnMName
442 bindM_RDR               = nameRdrName bindMName
443 failM_RDR               = nameRdrName failMName
444
445 left_RDR, right_RDR :: RdrName
446 left_RDR                = nameRdrName leftDataConName
447 right_RDR               = nameRdrName rightDataConName
448
449 fromEnum_RDR, toEnum_RDR :: RdrName
450 fromEnum_RDR            = varQual_RDR gHC_ENUM (fsLit "fromEnum")
451 toEnum_RDR              = varQual_RDR gHC_ENUM (fsLit "toEnum")
452
453 enumFrom_RDR, enumFromTo_RDR, enumFromThen_RDR, enumFromThenTo_RDR :: RdrName
454 enumFrom_RDR            = nameRdrName enumFromName
455 enumFromTo_RDR          = nameRdrName enumFromToName
456 enumFromThen_RDR        = nameRdrName enumFromThenName
457 enumFromThenTo_RDR      = nameRdrName enumFromThenToName
458
459 ratioDataCon_RDR, plusInteger_RDR, timesInteger_RDR :: RdrName
460 ratioDataCon_RDR        = nameRdrName ratioDataConName
461 plusInteger_RDR         = nameRdrName plusIntegerName
462 timesInteger_RDR        = nameRdrName timesIntegerName
463
464 ioDataCon_RDR :: RdrName
465 ioDataCon_RDR           = nameRdrName ioDataConName
466
467 eqString_RDR, unpackCString_RDR, unpackCStringFoldr_RDR,
468     unpackCStringUtf8_RDR :: RdrName
469 eqString_RDR            = nameRdrName eqStringName
470 unpackCString_RDR       = nameRdrName unpackCStringName
471 unpackCStringFoldr_RDR  = nameRdrName unpackCStringFoldrName
472 unpackCStringUtf8_RDR   = nameRdrName unpackCStringUtf8Name
473
474 newStablePtr_RDR, wordDataCon_RDR :: RdrName
475 newStablePtr_RDR        = nameRdrName newStablePtrName
476 wordDataCon_RDR         = dataQual_RDR gHC_WORD (fsLit "W#")
477
478 bindIO_RDR, returnIO_RDR :: RdrName
479 bindIO_RDR              = nameRdrName bindIOName
480 returnIO_RDR            = nameRdrName returnIOName
481
482 fromInteger_RDR, fromRational_RDR, minus_RDR, times_RDR, plus_RDR :: RdrName
483 fromInteger_RDR         = nameRdrName fromIntegerName
484 fromRational_RDR        = nameRdrName fromRationalName
485 minus_RDR               = nameRdrName minusName
486 times_RDR               = varQual_RDR  gHC_NUM (fsLit "*")
487 plus_RDR                = varQual_RDR gHC_NUM (fsLit "+")
488
489 fromString_RDR :: RdrName
490 fromString_RDR          = nameRdrName fromStringName
491
492 compose_RDR :: RdrName
493 compose_RDR             = varQual_RDR gHC_BASE (fsLit ".")
494
495 not_RDR, getTag_RDR, succ_RDR, pred_RDR, minBound_RDR, maxBound_RDR,
496     and_RDR, range_RDR, inRange_RDR, index_RDR,
497     unsafeIndex_RDR, unsafeRangeSize_RDR :: RdrName
498 and_RDR                 = varQual_RDR gHC_CLASSES (fsLit "&&")
499 not_RDR                 = varQual_RDR gHC_CLASSES (fsLit "not")
500 getTag_RDR              = varQual_RDR gHC_BASE (fsLit "getTag")
501 succ_RDR                = varQual_RDR gHC_ENUM (fsLit "succ")
502 pred_RDR                = varQual_RDR gHC_ENUM (fsLit "pred")
503 minBound_RDR            = varQual_RDR gHC_ENUM (fsLit "minBound")
504 maxBound_RDR            = varQual_RDR gHC_ENUM (fsLit "maxBound")
505 range_RDR               = varQual_RDR gHC_ARR (fsLit "range")
506 inRange_RDR             = varQual_RDR gHC_ARR (fsLit "inRange")
507 index_RDR               = varQual_RDR gHC_ARR (fsLit "index")
508 unsafeIndex_RDR         = varQual_RDR gHC_ARR (fsLit "unsafeIndex")
509 unsafeRangeSize_RDR     = varQual_RDR gHC_ARR (fsLit "unsafeRangeSize")
510
511 readList_RDR, readListDefault_RDR, readListPrec_RDR, readListPrecDefault_RDR,
512     readPrec_RDR, parens_RDR, choose_RDR, lexP_RDR :: RdrName
513 readList_RDR            = varQual_RDR gHC_READ (fsLit "readList")
514 readListDefault_RDR     = varQual_RDR gHC_READ (fsLit "readListDefault")
515 readListPrec_RDR        = varQual_RDR gHC_READ (fsLit "readListPrec")
516 readListPrecDefault_RDR = varQual_RDR gHC_READ (fsLit "readListPrecDefault")
517 readPrec_RDR            = varQual_RDR gHC_READ (fsLit "readPrec")
518 parens_RDR              = varQual_RDR gHC_READ (fsLit "parens")
519 choose_RDR              = varQual_RDR gHC_READ (fsLit "choose")
520 lexP_RDR                = varQual_RDR gHC_READ (fsLit "lexP")
521
522 punc_RDR, ident_RDR, symbol_RDR :: RdrName
523 punc_RDR                = dataQual_RDR lEX (fsLit "Punc")
524 ident_RDR               = dataQual_RDR lEX (fsLit "Ident")
525 symbol_RDR              = dataQual_RDR lEX (fsLit "Symbol")
526
527 step_RDR, alt_RDR, reset_RDR, prec_RDR :: RdrName
528 step_RDR                = varQual_RDR  rEAD_PREC (fsLit "step")
529 alt_RDR                 = varQual_RDR  rEAD_PREC (fsLit "+++") 
530 reset_RDR               = varQual_RDR  rEAD_PREC (fsLit "reset")
531 prec_RDR                = varQual_RDR  rEAD_PREC (fsLit "prec")
532
533 showList_RDR, showList___RDR, showsPrec_RDR, showString_RDR,
534     showSpace_RDR, showParen_RDR :: RdrName
535 showList_RDR            = varQual_RDR gHC_SHOW (fsLit "showList")
536 showList___RDR          = varQual_RDR gHC_SHOW (fsLit "showList__")
537 showsPrec_RDR           = varQual_RDR gHC_SHOW (fsLit "showsPrec") 
538 showString_RDR          = varQual_RDR gHC_SHOW (fsLit "showString")
539 showSpace_RDR           = varQual_RDR gHC_SHOW (fsLit "showSpace") 
540 showParen_RDR           = varQual_RDR gHC_SHOW (fsLit "showParen") 
541
542 typeOf_RDR, mkTypeRep_RDR, mkTyConRep_RDR :: RdrName
543 typeOf_RDR     = varQual_RDR tYPEABLE (fsLit "typeOf")
544 mkTypeRep_RDR  = varQual_RDR tYPEABLE (fsLit "mkTyConApp")
545 mkTyConRep_RDR = varQual_RDR tYPEABLE (fsLit "mkTyCon")
546
547 undefined_RDR :: RdrName
548 undefined_RDR = varQual_RDR gHC_ERR (fsLit "undefined")
549
550 error_RDR :: RdrName
551 error_RDR = varQual_RDR gHC_ERR (fsLit "error")
552
553 -- Old Generics (constructors and functions)
554 crossDataCon_RDR, inlDataCon_RDR, inrDataCon_RDR, genUnitDataCon_RDR :: RdrName
555 crossDataCon_RDR   = dataQual_RDR gHC_GENERICS (fsLit ":*:")
556 inlDataCon_RDR     = dataQual_RDR gHC_GENERICS (fsLit "Inl")
557 inrDataCon_RDR     = dataQual_RDR gHC_GENERICS (fsLit "Inr")
558 genUnitDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Unit")
559
560 -- Generics (constructors and functions)
561 u1DataCon_RDR, par1DataCon_RDR, rec1DataCon_RDR,
562   k1DataCon_RDR, m1DataCon_RDR, l1DataCon_RDR, r1DataCon_RDR,
563   prodDataCon_RDR, comp1DataCon_RDR, from_RDR, from1_RDR,
564   to_RDR, to1_RDR, datatypeName_RDR, moduleName_RDR, conName_RDR,
565   conFixity_RDR, conIsRecord_RDR,
566   noArityDataCon_RDR, arityDataCon_RDR, selName_RDR,
567   prefixDataCon_RDR, infixDataCon_RDR, leftAssocDataCon_RDR,
568   rightAssocDataCon_RDR, notAssocDataCon_RDR :: RdrName
569
570 u1DataCon_RDR    = dataQual_RDR gHC_GENERICS (fsLit "U1")
571 par1DataCon_RDR  = dataQual_RDR gHC_GENERICS (fsLit "Par1")
572 rec1DataCon_RDR  = dataQual_RDR gHC_GENERICS (fsLit "Rec1")
573 k1DataCon_RDR    = dataQual_RDR gHC_GENERICS (fsLit "K1")
574 m1DataCon_RDR    = dataQual_RDR gHC_GENERICS (fsLit "M1")
575
576 l1DataCon_RDR     = dataQual_RDR gHC_GENERICS (fsLit "L1")
577 r1DataCon_RDR     = dataQual_RDR gHC_GENERICS (fsLit "R1")
578
579 prodDataCon_RDR   = dataQual_RDR gHC_GENERICS (fsLit ":*:")
580 comp1DataCon_RDR  = dataQual_RDR gHC_GENERICS (fsLit "Comp1")
581
582 from_RDR  = varQual_RDR gHC_GENERICS (fsLit "from")
583 from1_RDR = varQual_RDR gHC_GENERICS (fsLit "from1")
584 to_RDR    = varQual_RDR gHC_GENERICS (fsLit "to")
585 to1_RDR   = varQual_RDR gHC_GENERICS (fsLit "to1")
586
587 datatypeName_RDR  = varQual_RDR gHC_GENERICS (fsLit "datatypeName")
588 moduleName_RDR    = varQual_RDR gHC_GENERICS (fsLit "moduleName")
589 selName_RDR       = varQual_RDR gHC_GENERICS (fsLit "selName")
590 conName_RDR       = varQual_RDR gHC_GENERICS (fsLit "conName")
591 conFixity_RDR     = varQual_RDR gHC_GENERICS (fsLit "conFixity")
592 conIsRecord_RDR   = varQual_RDR gHC_GENERICS (fsLit "conIsRecord")
593
594 noArityDataCon_RDR    = dataQual_RDR gHC_GENERICS (fsLit "NoArity")
595 arityDataCon_RDR      = dataQual_RDR gHC_GENERICS (fsLit "Arity")
596 prefixDataCon_RDR     = dataQual_RDR gHC_GENERICS (fsLit "Prefix")
597 infixDataCon_RDR      = dataQual_RDR gHC_GENERICS (fsLit "Infix")
598 leftAssocDataCon_RDR  = dataQual_RDR gHC_GENERICS (fsLit "LeftAssociative")
599 rightAssocDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "RightAssociative")
600 notAssocDataCon_RDR   = dataQual_RDR gHC_GENERICS (fsLit "NotAssociative")
601
602
603 fmap_RDR, pure_RDR, ap_RDR, foldable_foldr_RDR, traverse_RDR :: RdrName
604 fmap_RDR                = varQual_RDR gHC_BASE (fsLit "fmap")
605 pure_RDR                = varQual_RDR cONTROL_APPLICATIVE (fsLit "pure")
606 ap_RDR                  = varQual_RDR cONTROL_APPLICATIVE (fsLit "<*>")
607 foldable_foldr_RDR      = varQual_RDR dATA_FOLDABLE       (fsLit "foldr")
608 traverse_RDR            = varQual_RDR dATA_TRAVERSABLE    (fsLit "traverse")
609
610 ----------------------
611 varQual_RDR, tcQual_RDR, clsQual_RDR, dataQual_RDR
612     :: Module -> FastString -> RdrName
613 varQual_RDR  mod str = mkOrig mod (mkOccNameFS varName str)
614 tcQual_RDR   mod str = mkOrig mod (mkOccNameFS tcName str)
615 clsQual_RDR  mod str = mkOrig mod (mkOccNameFS clsName str)
616 dataQual_RDR mod str = mkOrig mod (mkOccNameFS dataName str)
617 \end{code}
618
619 %************************************************************************
620 %*                                                                      *
621 \subsection{Known-key names}
622 %*                                                                      *
623 %************************************************************************
624
625 Many of these Names are not really "built in", but some parts of the
626 compiler (notably the deriving mechanism) need to mention their names,
627 and it's convenient to write them all down in one place.
628
629 --MetaHaskell Extension  add the constrs and the lower case case
630 -- guys as well (perhaps) e.g. see  trueDataConName     below
631
632
633 \begin{code}
634 wildCardName :: Name
635 wildCardName = mkSystemVarName wildCardKey (fsLit "wild")
636
637 runMainIOName :: Name
638 runMainIOName = varQual gHC_TOP_HANDLER (fsLit "runMainIO") runMainKey
639
640 orderingTyConName :: Name
641 orderingTyConName = tcQual   gHC_ORDERING (fsLit "Ordering") orderingTyConKey
642
643 eitherTyConName, leftDataConName, rightDataConName :: Name
644 eitherTyConName   = tcQual  dATA_EITHER (fsLit "Either") eitherTyConKey
645 leftDataConName   = conName dATA_EITHER (fsLit "Left")   leftDataConKey
646 rightDataConName  = conName dATA_EITHER (fsLit "Right")  rightDataConKey
647
648 -- Generics (types)
649 v1TyConName, u1TyConName, par1TyConName, rec1TyConName,
650   k1TyConName, m1TyConName, sumTyConName, prodTyConName,
651   compTyConName, rTyConName, pTyConName, dTyConName, 
652   cTyConName, sTyConName, rec0TyConName, par0TyConName,
653   d1TyConName, c1TyConName, s1TyConName, noSelTyConName,
654   repTyConName, rep1TyConName :: Name
655
656 v1TyConName  = tcQual gHC_GENERICS (fsLit "V1") v1TyConKey
657 u1TyConName  = tcQual gHC_GENERICS (fsLit "U1") u1TyConKey
658 par1TyConName  = tcQual gHC_GENERICS (fsLit "Par1") par1TyConKey
659 rec1TyConName  = tcQual gHC_GENERICS (fsLit "Rec1") rec1TyConKey
660 k1TyConName  = tcQual gHC_GENERICS (fsLit "K1") k1TyConKey
661 m1TyConName  = tcQual gHC_GENERICS (fsLit "M1") m1TyConKey
662
663 sumTyConName    = tcQual gHC_GENERICS (fsLit ":+:") sumTyConKey
664 prodTyConName   = tcQual gHC_GENERICS (fsLit ":*:") prodTyConKey
665 compTyConName   = tcQual gHC_GENERICS (fsLit ":.:") compTyConKey
666
667 rTyConName  = tcQual gHC_GENERICS (fsLit "R") rTyConKey
668 pTyConName  = tcQual gHC_GENERICS (fsLit "P") pTyConKey
669 dTyConName  = tcQual gHC_GENERICS (fsLit "D") dTyConKey
670 cTyConName  = tcQual gHC_GENERICS (fsLit "C") cTyConKey
671 sTyConName  = tcQual gHC_GENERICS (fsLit "S") sTyConKey
672
673 rec0TyConName  = tcQual gHC_GENERICS (fsLit "Rec0") rec0TyConKey
674 par0TyConName  = tcQual gHC_GENERICS (fsLit "Par0") par0TyConKey
675 d1TyConName  = tcQual gHC_GENERICS (fsLit "D1") d1TyConKey
676 c1TyConName  = tcQual gHC_GENERICS (fsLit "C1") c1TyConKey
677 s1TyConName  = tcQual gHC_GENERICS (fsLit "S1") s1TyConKey
678 noSelTyConName = tcQual gHC_GENERICS (fsLit "NoSelector") noSelTyConKey
679
680 repTyConName  = tcQual gHC_GENERICS (fsLit "Rep")  repTyConKey
681 rep1TyConName = tcQual gHC_GENERICS (fsLit "Rep1") rep1TyConKey
682
683 -- Base strings Strings
684 unpackCStringName, unpackCStringAppendName, unpackCStringFoldrName,
685     unpackCStringUtf8Name, eqStringName, stringTyConName :: Name
686 unpackCStringName       = varQual gHC_CSTRING (fsLit "unpackCString#") unpackCStringIdKey
687 unpackCStringAppendName = varQual gHC_CSTRING (fsLit "unpackAppendCString#") unpackCStringAppendIdKey
688 unpackCStringFoldrName  = varQual gHC_CSTRING (fsLit "unpackFoldrCString#") unpackCStringFoldrIdKey
689 unpackCStringUtf8Name   = varQual gHC_CSTRING (fsLit "unpackCStringUtf8#") unpackCStringUtf8IdKey
690 eqStringName            = varQual gHC_BASE (fsLit "eqString")  eqStringIdKey
691 stringTyConName         = tcQual  gHC_BASE (fsLit "String") stringTyConKey
692
693 -- The 'inline' function
694 inlineIdName :: Name
695 inlineIdName            = varQual gHC_MAGIC (fsLit "inline") inlineIdKey
696
697 -- Base classes (Eq, Ord, Functor)
698 fmapName, eqClassName, eqName, ordClassName, geName, functorClassName :: Name
699 eqClassName       = clsQual  gHC_CLASSES (fsLit "Eq")      eqClassKey
700 eqName            = methName gHC_CLASSES (fsLit "==")      eqClassOpKey
701 ordClassName      = clsQual  gHC_CLASSES (fsLit "Ord")     ordClassKey
702 geName            = methName gHC_CLASSES (fsLit ">=")      geClassOpKey
703 functorClassName  = clsQual  gHC_BASE (fsLit "Functor") functorClassKey
704 fmapName          = methName gHC_BASE (fsLit "fmap")    fmapClassOpKey
705
706 -- Class Monad
707 monadClassName, thenMName, bindMName, returnMName, failMName :: Name
708 monadClassName     = clsQual  gHC_BASE (fsLit "Monad")  monadClassKey
709 thenMName          = methName gHC_BASE (fsLit ">>")     thenMClassOpKey
710 bindMName          = methName gHC_BASE (fsLit ">>=")    bindMClassOpKey
711 returnMName        = methName gHC_BASE (fsLit "return") returnMClassOpKey
712 failMName          = methName gHC_BASE (fsLit "fail")   failMClassOpKey
713
714 -- Classes (Applicative, Foldable, Traversable)
715 applicativeClassName, foldableClassName, traversableClassName :: Name
716 applicativeClassName  = clsQual  cONTROL_APPLICATIVE (fsLit "Applicative") applicativeClassKey
717 foldableClassName     = clsQual  dATA_FOLDABLE       (fsLit "Foldable")    foldableClassKey
718 traversableClassName  = clsQual  dATA_TRAVERSABLE    (fsLit "Traversable") traversableClassKey
719
720 -- Functions for GHC extensions
721 groupWithName :: Name
722 groupWithName = varQual gHC_EXTS (fsLit "groupWith") groupWithIdKey
723
724 -- Random PrelBase functions
725 fromStringName, otherwiseIdName, foldrName, buildName, augmentName,
726     mapName, appendName, assertName,
727     breakpointName, breakpointCondName, breakpointAutoName,
728     dollarName, opaqueTyConName :: Name
729 fromStringName = methName dATA_STRING (fsLit "fromString") fromStringClassOpKey
730 otherwiseIdName   = varQual gHC_BASE (fsLit "otherwise")  otherwiseIdKey
731 foldrName         = varQual gHC_BASE (fsLit "foldr")      foldrIdKey
732 buildName         = varQual gHC_BASE (fsLit "build")      buildIdKey
733 augmentName       = varQual gHC_BASE (fsLit "augment")    augmentIdKey
734 mapName           = varQual gHC_BASE (fsLit "map")        mapIdKey
735 appendName        = varQual gHC_BASE (fsLit "++")         appendIdKey
736 dollarName        = varQual gHC_BASE (fsLit "$")          dollarIdKey
737 assertName        = varQual gHC_BASE (fsLit "assert")     assertIdKey
738 breakpointName    = varQual gHC_BASE (fsLit "breakpoint") breakpointIdKey
739 breakpointCondName= varQual gHC_BASE (fsLit "breakpointCond") breakpointCondIdKey
740 breakpointAutoName= varQual gHC_BASE (fsLit "breakpointAuto") breakpointAutoIdKey
741 opaqueTyConName   = tcQual  gHC_BASE (fsLit "Opaque")   opaqueTyConKey
742
743 breakpointJumpName :: Name
744 breakpointJumpName
745     = mkInternalName
746         breakpointJumpIdKey
747         (mkOccNameFS varName (fsLit "breakpointJump"))
748         noSrcSpan
749 breakpointCondJumpName :: Name
750 breakpointCondJumpName
751     = mkInternalName
752         breakpointCondJumpIdKey
753         (mkOccNameFS varName (fsLit "breakpointCondJump"))
754         noSrcSpan
755 breakpointAutoJumpName :: Name
756 breakpointAutoJumpName
757     = mkInternalName
758         breakpointAutoJumpIdKey
759         (mkOccNameFS varName (fsLit "breakpointAutoJump"))
760         noSrcSpan
761
762 -- PrelTup
763 fstName, sndName :: Name
764 fstName           = varQual dATA_TUPLE (fsLit "fst") fstIdKey
765 sndName           = varQual dATA_TUPLE (fsLit "snd") sndIdKey
766
767 -- Module GHC.Num
768 numClassName, fromIntegerName, minusName, negateName, plusIntegerName,
769     timesIntegerName,
770     integerTyConName, smallIntegerName :: Name
771 numClassName      = clsQual  gHC_NUM (fsLit "Num") numClassKey
772 fromIntegerName   = methName gHC_NUM (fsLit "fromInteger") fromIntegerClassOpKey
773 minusName         = methName gHC_NUM (fsLit "-") minusClassOpKey
774 negateName        = methName gHC_NUM (fsLit "negate") negateClassOpKey
775 plusIntegerName   = varQual  gHC_INTEGER (fsLit "plusInteger") plusIntegerIdKey
776 timesIntegerName  = varQual  gHC_INTEGER (fsLit "timesInteger") timesIntegerIdKey
777 integerTyConName  = tcQual   gHC_INTEGER_TYPE (fsLit "Integer") integerTyConKey
778 smallIntegerName = varQual gHC_INTEGER (fsLit "smallInteger") smallIntegerIdKey
779
780 -- GHC.Real types and classes
781 rationalTyConName, ratioTyConName, ratioDataConName, realClassName,
782     integralClassName, realFracClassName, fractionalClassName,
783     fromRationalName, toIntegerName, toRationalName, fromIntegralName,
784     realToFracName :: Name
785 rationalTyConName   = tcQual  gHC_REAL (fsLit "Rational") rationalTyConKey
786 ratioTyConName      = tcQual  gHC_REAL (fsLit "Ratio") ratioTyConKey
787 ratioDataConName    = conName gHC_REAL (fsLit ":%") ratioDataConKey
788 realClassName       = clsQual gHC_REAL (fsLit "Real") realClassKey
789 integralClassName   = clsQual gHC_REAL (fsLit "Integral") integralClassKey
790 realFracClassName   = clsQual gHC_REAL (fsLit "RealFrac") realFracClassKey
791 fractionalClassName = clsQual gHC_REAL (fsLit "Fractional") fractionalClassKey
792 fromRationalName    = methName gHC_REAL (fsLit "fromRational") fromRationalClassOpKey
793 toIntegerName       = methName gHC_REAL (fsLit "toInteger") toIntegerClassOpKey
794 toRationalName      = methName gHC_REAL (fsLit "toRational") toRationalClassOpKey
795 fromIntegralName    = varQual  gHC_REAL (fsLit "fromIntegral") fromIntegralIdKey
796 realToFracName      = varQual  gHC_REAL (fsLit "realToFrac") realToFracIdKey
797
798 -- PrelFloat classes
799 floatingClassName, realFloatClassName :: Name
800 floatingClassName  = clsQual  gHC_FLOAT (fsLit "Floating") floatingClassKey
801 realFloatClassName = clsQual  gHC_FLOAT (fsLit "RealFloat") realFloatClassKey
802
803 -- Class Ix
804 ixClassName :: Name
805 ixClassName = clsQual gHC_ARR (fsLit "Ix") ixClassKey
806
807 -- Class Typeable
808 typeableClassName, typeable1ClassName, typeable2ClassName,
809     typeable3ClassName, typeable4ClassName, typeable5ClassName,
810     typeable6ClassName, typeable7ClassName :: Name
811 typeableClassName  = clsQual tYPEABLE (fsLit "Typeable") typeableClassKey
812 typeable1ClassName = clsQual tYPEABLE (fsLit "Typeable1") typeable1ClassKey
813 typeable2ClassName = clsQual tYPEABLE (fsLit "Typeable2") typeable2ClassKey
814 typeable3ClassName = clsQual tYPEABLE (fsLit "Typeable3") typeable3ClassKey
815 typeable4ClassName = clsQual tYPEABLE (fsLit "Typeable4") typeable4ClassKey
816 typeable5ClassName = clsQual tYPEABLE (fsLit "Typeable5") typeable5ClassKey
817 typeable6ClassName = clsQual tYPEABLE (fsLit "Typeable6") typeable6ClassKey
818 typeable7ClassName = clsQual tYPEABLE (fsLit "Typeable7") typeable7ClassKey
819
820 typeableClassNames :: [Name]
821 typeableClassNames =    [ typeableClassName, typeable1ClassName, typeable2ClassName
822                         , typeable3ClassName, typeable4ClassName, typeable5ClassName
823                         , typeable6ClassName, typeable7ClassName ]
824
825 -- Class Data
826 dataClassName :: Name
827 dataClassName = clsQual gENERICS (fsLit "Data") dataClassKey
828
829 -- Error module
830 assertErrorName    :: Name
831 assertErrorName   = varQual gHC_IO_Exception (fsLit "assertError") assertErrorIdKey
832
833 -- Enum module (Enum, Bounded)
834 enumClassName, enumFromName, enumFromToName, enumFromThenName,
835     enumFromThenToName, boundedClassName :: Name
836 enumClassName      = clsQual gHC_ENUM (fsLit "Enum") enumClassKey
837 enumFromName       = methName gHC_ENUM (fsLit "enumFrom") enumFromClassOpKey
838 enumFromToName     = methName gHC_ENUM (fsLit "enumFromTo") enumFromToClassOpKey
839 enumFromThenName   = methName gHC_ENUM (fsLit "enumFromThen") enumFromThenClassOpKey
840 enumFromThenToName = methName gHC_ENUM (fsLit "enumFromThenTo") enumFromThenToClassOpKey
841 boundedClassName   = clsQual gHC_ENUM (fsLit "Bounded") boundedClassKey
842
843 -- List functions
844 concatName, filterName, zipName :: Name
845 concatName        = varQual gHC_LIST (fsLit "concat") concatIdKey
846 filterName        = varQual gHC_LIST (fsLit "filter") filterIdKey
847 zipName           = varQual gHC_LIST (fsLit "zip") zipIdKey
848
849 -- Class Show
850 showClassName :: Name
851 showClassName     = clsQual gHC_SHOW (fsLit "Show")       showClassKey
852
853 -- Class Read
854 readClassName :: Name
855 readClassName      = clsQual gHC_READ (fsLit "Read") readClassKey
856
857 -- Classes Generic and Generic1, Datatype, Constructor and Selector
858 genClassName, gen1ClassName, datatypeClassName, constructorClassName,
859   selectorClassName :: Name
860 genClassName  = clsQual gHC_GENERICS (fsLit "Generic")  genClassKey
861 gen1ClassName = clsQual gHC_GENERICS (fsLit "Generic1") gen1ClassKey
862
863 datatypeClassName = clsQual gHC_GENERICS (fsLit "Datatype") datatypeClassKey
864 constructorClassName = clsQual gHC_GENERICS (fsLit "Constructor") constructorClassKey
865 selectorClassName = clsQual gHC_GENERICS (fsLit "Selector") selectorClassKey
866
867 -- parallel array types and functions
868 enumFromToPName, enumFromThenToPName, nullPName, lengthPName,
869     singletonPName, replicatePName, mapPName, filterPName,
870     zipPName, crossMapPName, indexPName, toPName,
871     emptyPName, appPName :: PackageId -> Name
872 enumFromToPName     pkg = varQual (gHC_PARR pkg) (fsLit "enumFromToP")     enumFromToPIdKey
873 enumFromThenToPName pkg = varQual (gHC_PARR pkg) (fsLit "enumFromThenToP") enumFromThenToPIdKey
874 nullPName           pkg = varQual (gHC_PARR pkg) (fsLit "nullP")           nullPIdKey
875 lengthPName         pkg = varQual (gHC_PARR pkg) (fsLit "lengthP")         lengthPIdKey
876 singletonPName      pkg = varQual (gHC_PARR pkg) (fsLit "singletonP")      singletonPIdKey
877 replicatePName      pkg = varQual (gHC_PARR pkg) (fsLit "replicateP")      replicatePIdKey
878 mapPName            pkg = varQual (gHC_PARR pkg) (fsLit "mapP")            mapPIdKey
879 filterPName         pkg = varQual (gHC_PARR pkg) (fsLit "filterP")         filterPIdKey
880 zipPName            pkg = varQual (gHC_PARR pkg) (fsLit "zipP")            zipPIdKey
881 crossMapPName       pkg = varQual (gHC_PARR pkg) (fsLit "crossMapP")       crossMapPIdKey
882 indexPName          pkg = varQual (gHC_PARR pkg) (fsLit "!:")              indexPIdKey
883 toPName             pkg = varQual (gHC_PARR pkg) (fsLit "toP")             toPIdKey
884 emptyPName          pkg = varQual (gHC_PARR pkg) (fsLit "emptyP")          emptyPIdKey
885 appPName            pkg = varQual (gHC_PARR pkg) (fsLit "+:+")             appPIdKey
886
887 -- IO things
888 ioTyConName, ioDataConName, thenIOName, bindIOName, returnIOName,
889     failIOName :: Name
890 ioTyConName       = tcQual  gHC_TYPES (fsLit "IO") ioTyConKey
891 ioDataConName     = conName gHC_TYPES (fsLit "IO") ioDataConKey
892 thenIOName        = varQual gHC_BASE (fsLit "thenIO") thenIOIdKey
893 bindIOName        = varQual gHC_BASE (fsLit "bindIO") bindIOIdKey
894 returnIOName      = varQual gHC_BASE (fsLit "returnIO") returnIOIdKey
895 failIOName        = varQual gHC_IO (fsLit "failIO") failIOIdKey
896
897 -- IO things
898 printName :: Name
899 printName         = varQual sYSTEM_IO (fsLit "print") printIdKey
900
901 -- Int, Word, and Addr things
902 int8TyConName, int16TyConName, int32TyConName, int64TyConName :: Name
903 int8TyConName     = tcQual gHC_INT  (fsLit "Int8") int8TyConKey
904 int16TyConName    = tcQual gHC_INT  (fsLit "Int16") int16TyConKey
905 int32TyConName    = tcQual gHC_INT  (fsLit "Int32") int32TyConKey
906 int64TyConName    = tcQual gHC_INT  (fsLit "Int64") int64TyConKey
907
908 -- Word module
909 word8TyConName, word16TyConName, word32TyConName, word64TyConName,
910     wordTyConName, wordDataConName :: Name
911 word8TyConName    = tcQual  gHC_WORD (fsLit "Word8")  word8TyConKey
912 word16TyConName   = tcQual  gHC_WORD (fsLit "Word16") word16TyConKey
913 word32TyConName   = tcQual  gHC_WORD (fsLit "Word32") word32TyConKey
914 word64TyConName   = tcQual  gHC_WORD (fsLit "Word64") word64TyConKey
915 wordTyConName     = tcQual  gHC_WORD (fsLit "Word")   wordTyConKey
916 wordDataConName   = conName gHC_WORD (fsLit "W#") wordDataConKey
917
918 -- PrelPtr module
919 ptrTyConName, funPtrTyConName :: Name
920 ptrTyConName      = tcQual   gHC_PTR (fsLit "Ptr") ptrTyConKey
921 funPtrTyConName   = tcQual   gHC_PTR (fsLit "FunPtr") funPtrTyConKey
922
923 -- Foreign objects and weak pointers
924 stablePtrTyConName, newStablePtrName :: Name
925 stablePtrTyConName    = tcQual   gHC_STABLE (fsLit "StablePtr") stablePtrTyConKey
926 newStablePtrName      = varQual  gHC_STABLE (fsLit "newStablePtr") newStablePtrIdKey
927
928 -- PrelST module
929 runSTRepName :: Name
930 runSTRepName       = varQual gHC_ST  (fsLit "runSTRep") runSTRepIdKey
931
932 -- Recursive-do notation
933 monadFixClassName, mfixName :: Name
934 monadFixClassName  = clsQual mONAD_FIX (fsLit "MonadFix") monadFixClassKey
935 mfixName           = methName mONAD_FIX (fsLit "mfix") mfixIdKey
936
937 -- Arrow notation
938 arrAName, composeAName, firstAName, appAName, choiceAName, loopAName :: Name
939 arrAName           = varQual aRROW (fsLit "arr")          arrAIdKey
940 composeAName       = varQual gHC_DESUGAR (fsLit ">>>") composeAIdKey
941 firstAName         = varQual aRROW (fsLit "first") firstAIdKey
942 appAName           = varQual aRROW (fsLit "app")          appAIdKey
943 choiceAName        = varQual aRROW (fsLit "|||")          choiceAIdKey
944 loopAName          = varQual aRROW (fsLit "loop")  loopAIdKey
945
946 -- Monad comprehensions
947 guardMName, liftMName, groupMName, mzipName :: Name
948 guardMName         = varQual mONAD (fsLit "guard") guardMIdKey
949 liftMName          = varQual mONAD (fsLit "liftM") liftMIdKey
950 groupMName         = varQual mONAD_GROUP (fsLit "mgroupWith") groupMIdKey
951 mzipName           = varQual mONAD_ZIP (fsLit "mzip") mzipIdKey
952
953
954 -- Annotation type checking
955 toAnnotationWrapperName :: Name
956 toAnnotationWrapperName = varQual gHC_DESUGAR (fsLit "toAnnotationWrapper") toAnnotationWrapperIdKey
957
958 -- Other classes, needed for type defaulting
959 monadPlusClassName, randomClassName, randomGenClassName,
960     isStringClassName :: Name
961 monadPlusClassName  = clsQual mONAD (fsLit "MonadPlus")  monadPlusClassKey
962 randomClassName     = clsQual rANDOM (fsLit "Random")    randomClassKey
963 randomGenClassName  = clsQual rANDOM (fsLit "RandomGen") randomGenClassKey
964 isStringClassName   = clsQual dATA_STRING (fsLit "IsString") isStringClassKey
965
966 -- dotnet interop
967 objectTyConName :: Name
968 objectTyConName     = tcQual   dOTNET (fsLit "Object") objectTyConKey
969         -- objectTyConName was "wTcQual", but that's gone now, and
970         -- I can't see why it was wired in anyway...
971 unmarshalObjectName, marshalObjectName, marshalStringName,
972     unmarshalStringName, checkDotnetResName :: Name
973 unmarshalObjectName = varQual  dOTNET (fsLit "unmarshalObject") unmarshalObjectIdKey
974 marshalObjectName   = varQual  dOTNET (fsLit "marshalObject") marshalObjectIdKey
975 marshalStringName   = varQual  dOTNET (fsLit "marshalString") marshalStringIdKey
976 unmarshalStringName = varQual  dOTNET (fsLit "unmarshalString") unmarshalStringIdKey
977 checkDotnetResName  = varQual  dOTNET (fsLit "checkResult")     checkDotnetResNameIdKey
978 \end{code}
979
980 %************************************************************************
981 %*                                                                      *
982 \subsection{Local helpers}
983 %*                                                                      *
984 %************************************************************************
985
986 All these are original names; hence mkOrig
987
988 \begin{code}
989 varQual, tcQual, clsQual :: Module -> FastString -> Unique -> Name
990 varQual  = mk_known_key_name varName
991 tcQual   = mk_known_key_name tcName
992 clsQual  = mk_known_key_name clsName
993
994 mk_known_key_name :: NameSpace -> Module -> FastString -> Unique -> Name
995 mk_known_key_name space modu str unique 
996   = mkExternalName unique modu (mkOccNameFS space str) noSrcSpan
997
998 conName :: Module -> FastString -> Unique -> Name
999 conName modu occ unique
1000   = mkExternalName unique modu (mkOccNameFS dataName occ) noSrcSpan
1001
1002 methName :: Module -> FastString -> Unique -> Name
1003 methName modu occ unique
1004   = mkExternalName unique modu (mkVarOccFS occ) noSrcSpan
1005 \end{code}
1006
1007 %************************************************************************
1008 %*                                                                      *
1009 \subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@}
1010 %*                                                                      *
1011 %************************************************************************
1012 --MetaHaskell extension hand allocate keys here
1013
1014 \begin{code}
1015 boundedClassKey, enumClassKey, eqClassKey, floatingClassKey,
1016     fractionalClassKey, integralClassKey, monadClassKey, dataClassKey,
1017     functorClassKey, numClassKey, ordClassKey, readClassKey, realClassKey,
1018     realFloatClassKey, realFracClassKey, showClassKey, ixClassKey :: Unique
1019 boundedClassKey         = mkPreludeClassUnique 1 
1020 enumClassKey            = mkPreludeClassUnique 2 
1021 eqClassKey              = mkPreludeClassUnique 3 
1022 floatingClassKey        = mkPreludeClassUnique 5 
1023 fractionalClassKey      = mkPreludeClassUnique 6 
1024 integralClassKey        = mkPreludeClassUnique 7 
1025 monadClassKey           = mkPreludeClassUnique 8 
1026 dataClassKey            = mkPreludeClassUnique 9
1027 functorClassKey         = mkPreludeClassUnique 10
1028 numClassKey             = mkPreludeClassUnique 11
1029 ordClassKey             = mkPreludeClassUnique 12
1030 readClassKey            = mkPreludeClassUnique 13
1031 realClassKey            = mkPreludeClassUnique 14
1032 realFloatClassKey       = mkPreludeClassUnique 15
1033 realFracClassKey        = mkPreludeClassUnique 16
1034 showClassKey            = mkPreludeClassUnique 17
1035 ixClassKey              = mkPreludeClassUnique 18
1036
1037 typeableClassKey, typeable1ClassKey, typeable2ClassKey, typeable3ClassKey,
1038     typeable4ClassKey, typeable5ClassKey, typeable6ClassKey, typeable7ClassKey
1039     :: Unique
1040 typeableClassKey        = mkPreludeClassUnique 20
1041 typeable1ClassKey       = mkPreludeClassUnique 21
1042 typeable2ClassKey       = mkPreludeClassUnique 22
1043 typeable3ClassKey       = mkPreludeClassUnique 23
1044 typeable4ClassKey       = mkPreludeClassUnique 24
1045 typeable5ClassKey       = mkPreludeClassUnique 25
1046 typeable6ClassKey       = mkPreludeClassUnique 26
1047 typeable7ClassKey       = mkPreludeClassUnique 27
1048
1049 monadFixClassKey :: Unique
1050 monadFixClassKey        = mkPreludeClassUnique 28
1051
1052 monadPlusClassKey, randomClassKey, randomGenClassKey :: Unique
1053 monadPlusClassKey       = mkPreludeClassUnique 30
1054 randomClassKey          = mkPreludeClassUnique 31
1055 randomGenClassKey       = mkPreludeClassUnique 32
1056
1057 isStringClassKey :: Unique
1058 isStringClassKey        = mkPreludeClassUnique 33
1059
1060 applicativeClassKey, foldableClassKey, traversableClassKey :: Unique
1061 applicativeClassKey     = mkPreludeClassUnique 34
1062 foldableClassKey        = mkPreludeClassUnique 35
1063 traversableClassKey     = mkPreludeClassUnique 36
1064
1065 genClassKey, gen1ClassKey, datatypeClassKey, constructorClassKey,
1066   selectorClassKey :: Unique
1067 genClassKey   = mkPreludeClassUnique 37
1068 gen1ClassKey  = mkPreludeClassUnique 38
1069
1070 datatypeClassKey    = mkPreludeClassUnique 39
1071 constructorClassKey = mkPreludeClassUnique 40
1072 selectorClassKey    = mkPreludeClassUnique 41
1073 \end{code}
1074
1075 %************************************************************************
1076 %*                                                                      *
1077 \subsubsection[Uniques-prelude-TyCons]{@Uniques@ for wired-in @TyCons@}
1078 %*                                                                      *
1079 %************************************************************************
1080
1081 \begin{code}
1082 addrPrimTyConKey, arrayPrimTyConKey, boolTyConKey, byteArrayPrimTyConKey,
1083     charPrimTyConKey, charTyConKey, doublePrimTyConKey, doubleTyConKey,
1084     floatPrimTyConKey, floatTyConKey, funTyConKey, intPrimTyConKey,
1085     intTyConKey, int8TyConKey, int16TyConKey, int32PrimTyConKey,
1086     int32TyConKey, int64PrimTyConKey, int64TyConKey, integerTyConKey,
1087     listTyConKey, foreignObjPrimTyConKey, weakPrimTyConKey,
1088     mutableArrayPrimTyConKey, mutableByteArrayPrimTyConKey,
1089     orderingTyConKey, mVarPrimTyConKey, ratioTyConKey, rationalTyConKey,
1090     realWorldTyConKey, stablePtrPrimTyConKey, stablePtrTyConKey,
1091     anyTyConKey :: Unique
1092 addrPrimTyConKey                        = mkPreludeTyConUnique  1
1093 arrayPrimTyConKey                       = mkPreludeTyConUnique  3
1094 boolTyConKey                            = mkPreludeTyConUnique  4
1095 byteArrayPrimTyConKey                   = mkPreludeTyConUnique  5
1096 charPrimTyConKey                        = mkPreludeTyConUnique  7
1097 charTyConKey                            = mkPreludeTyConUnique  8
1098 doublePrimTyConKey                      = mkPreludeTyConUnique  9
1099 doubleTyConKey                          = mkPreludeTyConUnique 10 
1100 floatPrimTyConKey                       = mkPreludeTyConUnique 11
1101 floatTyConKey                           = mkPreludeTyConUnique 12
1102 funTyConKey                             = mkPreludeTyConUnique 13
1103 intPrimTyConKey                         = mkPreludeTyConUnique 14
1104 intTyConKey                             = mkPreludeTyConUnique 15
1105 int8TyConKey                            = mkPreludeTyConUnique 16
1106 int16TyConKey                           = mkPreludeTyConUnique 17
1107 int32PrimTyConKey                       = mkPreludeTyConUnique 18
1108 int32TyConKey                           = mkPreludeTyConUnique 19
1109 int64PrimTyConKey                       = mkPreludeTyConUnique 20
1110 int64TyConKey                           = mkPreludeTyConUnique 21
1111 integerTyConKey                         = mkPreludeTyConUnique 22
1112 listTyConKey                            = mkPreludeTyConUnique 23
1113 foreignObjPrimTyConKey                  = mkPreludeTyConUnique 24
1114 weakPrimTyConKey                        = mkPreludeTyConUnique 27
1115 mutableArrayPrimTyConKey                = mkPreludeTyConUnique 28
1116 mutableByteArrayPrimTyConKey            = mkPreludeTyConUnique 29
1117 orderingTyConKey                        = mkPreludeTyConUnique 30
1118 mVarPrimTyConKey                        = mkPreludeTyConUnique 31
1119 ratioTyConKey                           = mkPreludeTyConUnique 32
1120 rationalTyConKey                        = mkPreludeTyConUnique 33
1121 realWorldTyConKey                       = mkPreludeTyConUnique 34
1122 stablePtrPrimTyConKey                   = mkPreludeTyConUnique 35
1123 stablePtrTyConKey                       = mkPreludeTyConUnique 36
1124 anyTyConKey                             = mkPreludeTyConUnique 37
1125
1126 statePrimTyConKey, stableNamePrimTyConKey, stableNameTyConKey,
1127     mutVarPrimTyConKey, ioTyConKey,
1128     wordPrimTyConKey, wordTyConKey, word8TyConKey, word16TyConKey,
1129     word32PrimTyConKey, word32TyConKey, word64PrimTyConKey, word64TyConKey,
1130     liftedConKey, unliftedConKey, anyBoxConKey, kindConKey, boxityConKey,
1131     typeConKey, threadIdPrimTyConKey, bcoPrimTyConKey, ptrTyConKey,
1132     funPtrTyConKey, tVarPrimTyConKey, eqPredPrimTyConKey :: Unique
1133 statePrimTyConKey                       = mkPreludeTyConUnique 50
1134 stableNamePrimTyConKey                  = mkPreludeTyConUnique 51
1135 stableNameTyConKey                      = mkPreludeTyConUnique 52
1136 eqPredPrimTyConKey                      = mkPreludeTyConUnique 53
1137 mutVarPrimTyConKey                      = mkPreludeTyConUnique 55
1138 ioTyConKey                              = mkPreludeTyConUnique 56
1139 wordPrimTyConKey                        = mkPreludeTyConUnique 58
1140 wordTyConKey                            = mkPreludeTyConUnique 59
1141 word8TyConKey                           = mkPreludeTyConUnique 60
1142 word16TyConKey                          = mkPreludeTyConUnique 61 
1143 word32PrimTyConKey                      = mkPreludeTyConUnique 62 
1144 word32TyConKey                          = mkPreludeTyConUnique 63
1145 word64PrimTyConKey                      = mkPreludeTyConUnique 64
1146 word64TyConKey                          = mkPreludeTyConUnique 65
1147 liftedConKey                            = mkPreludeTyConUnique 66
1148 unliftedConKey                          = mkPreludeTyConUnique 67
1149 anyBoxConKey                            = mkPreludeTyConUnique 68
1150 kindConKey                              = mkPreludeTyConUnique 69
1151 boxityConKey                            = mkPreludeTyConUnique 70
1152 typeConKey                              = mkPreludeTyConUnique 71
1153 threadIdPrimTyConKey                    = mkPreludeTyConUnique 72
1154 bcoPrimTyConKey                         = mkPreludeTyConUnique 73
1155 ptrTyConKey                             = mkPreludeTyConUnique 74
1156 funPtrTyConKey                          = mkPreludeTyConUnique 75
1157 tVarPrimTyConKey                        = mkPreludeTyConUnique 76
1158
1159 -- Parallel array type constructor
1160 parrTyConKey :: Unique
1161 parrTyConKey                            = mkPreludeTyConUnique 82
1162
1163 -- dotnet interop
1164 objectTyConKey :: Unique
1165 objectTyConKey                          = mkPreludeTyConUnique 83
1166
1167 eitherTyConKey :: Unique
1168 eitherTyConKey                          = mkPreludeTyConUnique 84
1169
1170 -- Super Kinds constructors
1171 tySuperKindTyConKey :: Unique
1172 tySuperKindTyConKey                    = mkPreludeTyConUnique 85
1173
1174 -- Kind constructors
1175 liftedTypeKindTyConKey, openTypeKindTyConKey, unliftedTypeKindTyConKey,
1176     ubxTupleKindTyConKey, argTypeKindTyConKey :: Unique
1177 liftedTypeKindTyConKey                  = mkPreludeTyConUnique 87
1178 openTypeKindTyConKey                    = mkPreludeTyConUnique 88
1179 unliftedTypeKindTyConKey                = mkPreludeTyConUnique 89
1180 ubxTupleKindTyConKey                    = mkPreludeTyConUnique 90
1181 argTypeKindTyConKey                     = mkPreludeTyConUnique 91
1182
1183 -- Coercion constructors
1184 symCoercionTyConKey, transCoercionTyConKey, leftCoercionTyConKey,
1185     rightCoercionTyConKey, instCoercionTyConKey, unsafeCoercionTyConKey,
1186     csel1CoercionTyConKey, csel2CoercionTyConKey, cselRCoercionTyConKey
1187     :: Unique
1188 symCoercionTyConKey                     = mkPreludeTyConUnique 93
1189 transCoercionTyConKey                   = mkPreludeTyConUnique 94
1190 leftCoercionTyConKey                    = mkPreludeTyConUnique 95
1191 rightCoercionTyConKey                   = mkPreludeTyConUnique 96
1192 instCoercionTyConKey                    = mkPreludeTyConUnique 97
1193 unsafeCoercionTyConKey                  = mkPreludeTyConUnique 98
1194 csel1CoercionTyConKey                   = mkPreludeTyConUnique 99
1195 csel2CoercionTyConKey                   = mkPreludeTyConUnique 100
1196 cselRCoercionTyConKey                   = mkPreludeTyConUnique 101
1197
1198 unknownTyConKey, unknown1TyConKey, unknown2TyConKey, unknown3TyConKey,
1199     opaqueTyConKey :: Unique
1200 unknownTyConKey                         = mkPreludeTyConUnique 129
1201 unknown1TyConKey                        = mkPreludeTyConUnique 130
1202 unknown2TyConKey                        = mkPreludeTyConUnique 131
1203 unknown3TyConKey                        = mkPreludeTyConUnique 132
1204 opaqueTyConKey                          = mkPreludeTyConUnique 133
1205
1206 stringTyConKey :: Unique
1207 stringTyConKey                          = mkPreludeTyConUnique 134
1208
1209 -- Generics (Unique keys)
1210 v1TyConKey, u1TyConKey, par1TyConKey, rec1TyConKey,
1211   k1TyConKey, m1TyConKey, sumTyConKey, prodTyConKey,
1212   compTyConKey, rTyConKey, pTyConKey, dTyConKey,
1213   cTyConKey, sTyConKey, rec0TyConKey, par0TyConKey,
1214   d1TyConKey, c1TyConKey, s1TyConKey, noSelTyConKey,
1215   repTyConKey, rep1TyConKey :: Unique
1216
1217 v1TyConKey    = mkPreludeTyConUnique 135
1218 u1TyConKey    = mkPreludeTyConUnique 136
1219 par1TyConKey  = mkPreludeTyConUnique 137
1220 rec1TyConKey  = mkPreludeTyConUnique 138
1221 k1TyConKey    = mkPreludeTyConUnique 139
1222 m1TyConKey    = mkPreludeTyConUnique 140
1223
1224 sumTyConKey   = mkPreludeTyConUnique 141
1225 prodTyConKey  = mkPreludeTyConUnique 142
1226 compTyConKey  = mkPreludeTyConUnique 143
1227
1228 rTyConKey = mkPreludeTyConUnique 144
1229 pTyConKey = mkPreludeTyConUnique 145
1230 dTyConKey = mkPreludeTyConUnique 146
1231 cTyConKey = mkPreludeTyConUnique 147
1232 sTyConKey = mkPreludeTyConUnique 148
1233
1234 rec0TyConKey  = mkPreludeTyConUnique 149
1235 par0TyConKey  = mkPreludeTyConUnique 150
1236 d1TyConKey    = mkPreludeTyConUnique 151
1237 c1TyConKey    = mkPreludeTyConUnique 152
1238 s1TyConKey    = mkPreludeTyConUnique 153
1239 noSelTyConKey = mkPreludeTyConUnique 154
1240
1241 repTyConKey  = mkPreludeTyConUnique 155
1242 rep1TyConKey = mkPreludeTyConUnique 156
1243
1244 ---------------- Template Haskell -------------------
1245 --      USES TyConUniques 200-299
1246 -----------------------------------------------------
1247
1248 unitTyConKey :: Unique
1249 unitTyConKey = mkTupleTyConUnique Boxed 0
1250 \end{code}
1251
1252 %************************************************************************
1253 %*                                                                      *
1254 \subsubsection[Uniques-prelude-DataCons]{@Uniques@ for wired-in @DataCons@}
1255 %*                                                                      *
1256 %************************************************************************
1257
1258 \begin{code}
1259 charDataConKey, consDataConKey, doubleDataConKey, falseDataConKey,
1260     floatDataConKey, intDataConKey, nilDataConKey, ratioDataConKey,
1261     stableNameDataConKey, trueDataConKey, wordDataConKey,
1262     ioDataConKey, integerDataConKey :: Unique
1263 charDataConKey                          = mkPreludeDataConUnique  1
1264 consDataConKey                          = mkPreludeDataConUnique  2
1265 doubleDataConKey                        = mkPreludeDataConUnique  3
1266 falseDataConKey                         = mkPreludeDataConUnique  4
1267 floatDataConKey                         = mkPreludeDataConUnique  5
1268 intDataConKey                           = mkPreludeDataConUnique  6
1269 nilDataConKey                           = mkPreludeDataConUnique 11
1270 ratioDataConKey                         = mkPreludeDataConUnique 12
1271 stableNameDataConKey                    = mkPreludeDataConUnique 14
1272 trueDataConKey                          = mkPreludeDataConUnique 15
1273 wordDataConKey                          = mkPreludeDataConUnique 16
1274 ioDataConKey                            = mkPreludeDataConUnique 17
1275 integerDataConKey                       = mkPreludeDataConUnique 18
1276
1277 -- Generic data constructors
1278 crossDataConKey, inlDataConKey, inrDataConKey, genUnitDataConKey :: Unique
1279 crossDataConKey                         = mkPreludeDataConUnique 20
1280 inlDataConKey                           = mkPreludeDataConUnique 21
1281 inrDataConKey                           = mkPreludeDataConUnique 22
1282 genUnitDataConKey                       = mkPreludeDataConUnique 23
1283
1284 -- Data constructor for parallel arrays
1285 parrDataConKey :: Unique
1286 parrDataConKey                          = mkPreludeDataConUnique 24
1287
1288 leftDataConKey, rightDataConKey :: Unique
1289 leftDataConKey                          = mkPreludeDataConUnique 25
1290 rightDataConKey                         = mkPreludeDataConUnique 26
1291 \end{code}
1292
1293 %************************************************************************
1294 %*                                                                      *
1295 \subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}
1296 %*                                                                      *
1297 %************************************************************************
1298
1299 \begin{code}
1300 absentErrorIdKey, augmentIdKey, appendIdKey, buildIdKey, errorIdKey,
1301     foldlIdKey, foldrIdKey, recSelErrorIdKey, 
1302     integerMinusOneIdKey, integerPlusOneIdKey,
1303     integerPlusTwoIdKey, integerZeroIdKey,
1304     int2IntegerIdKey, seqIdKey, irrefutPatErrorIdKey, eqStringIdKey,
1305     noMethodBindingErrorIdKey, nonExhaustiveGuardsErrorIdKey,
1306     runtimeErrorIdKey, parErrorIdKey, parIdKey, patErrorIdKey,
1307     realWorldPrimIdKey, recConErrorIdKey, recUpdErrorIdKey,
1308     traceIdKey, wildCardKey,
1309     unpackCStringUtf8IdKey, unpackCStringAppendIdKey,
1310     unpackCStringFoldrIdKey, unpackCStringIdKey :: Unique
1311 wildCardKey                   = mkPreludeMiscIdUnique  0  -- See Note [WildCard]
1312 absentErrorIdKey              = mkPreludeMiscIdUnique  1
1313 augmentIdKey                  = mkPreludeMiscIdUnique  3
1314 appendIdKey                   = mkPreludeMiscIdUnique  4
1315 buildIdKey                    = mkPreludeMiscIdUnique  5
1316 errorIdKey                    = mkPreludeMiscIdUnique  6
1317 foldlIdKey                    = mkPreludeMiscIdUnique  7
1318 foldrIdKey                    = mkPreludeMiscIdUnique  8
1319 recSelErrorIdKey              = mkPreludeMiscIdUnique  9
1320 integerMinusOneIdKey          = mkPreludeMiscIdUnique 10
1321 integerPlusOneIdKey           = mkPreludeMiscIdUnique 11
1322 integerPlusTwoIdKey           = mkPreludeMiscIdUnique 12
1323 integerZeroIdKey              = mkPreludeMiscIdUnique 13
1324 int2IntegerIdKey              = mkPreludeMiscIdUnique 14
1325 seqIdKey                      = mkPreludeMiscIdUnique 15
1326 irrefutPatErrorIdKey          = mkPreludeMiscIdUnique 16
1327 eqStringIdKey                 = mkPreludeMiscIdUnique 17
1328 noMethodBindingErrorIdKey     = mkPreludeMiscIdUnique 18
1329 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 19
1330 runtimeErrorIdKey             = mkPreludeMiscIdUnique 20 
1331 parErrorIdKey                 = mkPreludeMiscIdUnique 21
1332 parIdKey                      = mkPreludeMiscIdUnique 22
1333 patErrorIdKey                 = mkPreludeMiscIdUnique 23
1334 realWorldPrimIdKey            = mkPreludeMiscIdUnique 24
1335 recConErrorIdKey              = mkPreludeMiscIdUnique 25
1336 recUpdErrorIdKey              = mkPreludeMiscIdUnique 26
1337 traceIdKey                    = mkPreludeMiscIdUnique 27
1338 unpackCStringUtf8IdKey        = mkPreludeMiscIdUnique 28
1339 unpackCStringAppendIdKey      = mkPreludeMiscIdUnique 29
1340 unpackCStringFoldrIdKey       = mkPreludeMiscIdUnique 30
1341 unpackCStringIdKey            = mkPreludeMiscIdUnique 31
1342
1343 unsafeCoerceIdKey, concatIdKey, filterIdKey, zipIdKey, bindIOIdKey,
1344     returnIOIdKey, deRefStablePtrIdKey, newStablePtrIdKey,
1345     smallIntegerIdKey, plusIntegerIdKey, timesIntegerIdKey,
1346     printIdKey, failIOIdKey, nullAddrIdKey, voidArgIdKey,
1347     fstIdKey, sndIdKey, otherwiseIdKey, assertIdKey, runSTRepIdKey :: Unique
1348 unsafeCoerceIdKey             = mkPreludeMiscIdUnique 32
1349 concatIdKey                   = mkPreludeMiscIdUnique 33
1350 filterIdKey                   = mkPreludeMiscIdUnique 34
1351 zipIdKey                      = mkPreludeMiscIdUnique 35
1352 bindIOIdKey                   = mkPreludeMiscIdUnique 36
1353 returnIOIdKey                 = mkPreludeMiscIdUnique 37
1354 deRefStablePtrIdKey           = mkPreludeMiscIdUnique 38
1355 newStablePtrIdKey             = mkPreludeMiscIdUnique 39
1356 smallIntegerIdKey             = mkPreludeMiscIdUnique 40
1357 plusIntegerIdKey              = mkPreludeMiscIdUnique 41
1358 timesIntegerIdKey             = mkPreludeMiscIdUnique 42
1359 printIdKey                    = mkPreludeMiscIdUnique 43
1360 failIOIdKey                   = mkPreludeMiscIdUnique 44
1361 nullAddrIdKey                 = mkPreludeMiscIdUnique 46
1362 voidArgIdKey                  = mkPreludeMiscIdUnique 47
1363 fstIdKey                      = mkPreludeMiscIdUnique 49
1364 sndIdKey                      = mkPreludeMiscIdUnique 50
1365 otherwiseIdKey                = mkPreludeMiscIdUnique 51
1366 assertIdKey                   = mkPreludeMiscIdUnique 53
1367 runSTRepIdKey                 = mkPreludeMiscIdUnique 54
1368
1369 rootMainKey, runMainKey :: Unique
1370 rootMainKey                   = mkPreludeMiscIdUnique 55
1371 runMainKey                    = mkPreludeMiscIdUnique 56
1372
1373 thenIOIdKey, lazyIdKey, assertErrorIdKey :: Unique
1374 thenIOIdKey                   = mkPreludeMiscIdUnique 59
1375 lazyIdKey                     = mkPreludeMiscIdUnique 60
1376 assertErrorIdKey              = mkPreludeMiscIdUnique 61
1377
1378 breakpointIdKey, breakpointCondIdKey, breakpointAutoIdKey,
1379     breakpointJumpIdKey, breakpointCondJumpIdKey,
1380     breakpointAutoJumpIdKey :: Unique
1381 breakpointIdKey               = mkPreludeMiscIdUnique 62
1382 breakpointCondIdKey           = mkPreludeMiscIdUnique 63
1383 breakpointAutoIdKey           = mkPreludeMiscIdUnique 64
1384 breakpointJumpIdKey           = mkPreludeMiscIdUnique 65
1385 breakpointCondJumpIdKey       = mkPreludeMiscIdUnique 66
1386 breakpointAutoJumpIdKey       = mkPreludeMiscIdUnique 67
1387
1388 inlineIdKey :: Unique
1389 inlineIdKey                   = mkPreludeMiscIdUnique 68
1390
1391 mapIdKey, groupWithIdKey, dollarIdKey :: Unique
1392 mapIdKey              = mkPreludeMiscIdUnique 69
1393 groupWithIdKey        = mkPreludeMiscIdUnique 70
1394 dollarIdKey           = mkPreludeMiscIdUnique 71
1395
1396 coercionTokenIdKey :: Unique
1397 coercionTokenIdKey    = mkPreludeMiscIdUnique 72
1398
1399 -- Parallel array functions
1400 singletonPIdKey, nullPIdKey, lengthPIdKey, replicatePIdKey, mapPIdKey,
1401     filterPIdKey, zipPIdKey, crossMapPIdKey, indexPIdKey, toPIdKey,
1402     enumFromToPIdKey, enumFromThenToPIdKey, emptyPIdKey, appPIdKey :: Unique
1403 singletonPIdKey               = mkPreludeMiscIdUnique 79
1404 nullPIdKey                    = mkPreludeMiscIdUnique 80
1405 lengthPIdKey                  = mkPreludeMiscIdUnique 81
1406 replicatePIdKey               = mkPreludeMiscIdUnique 82
1407 mapPIdKey                     = mkPreludeMiscIdUnique 83
1408 filterPIdKey                  = mkPreludeMiscIdUnique 84
1409 zipPIdKey                     = mkPreludeMiscIdUnique 85
1410 crossMapPIdKey                = mkPreludeMiscIdUnique 86
1411 indexPIdKey                   = mkPreludeMiscIdUnique 87
1412 toPIdKey                      = mkPreludeMiscIdUnique 88
1413 enumFromToPIdKey              = mkPreludeMiscIdUnique 89
1414 enumFromThenToPIdKey          = mkPreludeMiscIdUnique 90
1415 emptyPIdKey                   = mkPreludeMiscIdUnique 91
1416 appPIdKey                     = mkPreludeMiscIdUnique 92
1417
1418 -- dotnet interop
1419 unmarshalObjectIdKey, marshalObjectIdKey, marshalStringIdKey,
1420     unmarshalStringIdKey, checkDotnetResNameIdKey :: Unique
1421 unmarshalObjectIdKey          = mkPreludeMiscIdUnique 94
1422 marshalObjectIdKey            = mkPreludeMiscIdUnique 95
1423 marshalStringIdKey            = mkPreludeMiscIdUnique 96
1424 unmarshalStringIdKey          = mkPreludeMiscIdUnique 97
1425 checkDotnetResNameIdKey       = mkPreludeMiscIdUnique 98
1426
1427 \end{code}
1428
1429 Certain class operations from Prelude classes.  They get their own
1430 uniques so we can look them up easily when we want to conjure them up
1431 during type checking.
1432
1433 \begin{code}
1434         -- Just a place holder for  unbound variables  produced by the renamer:
1435 unboundKey :: Unique
1436 unboundKey                    = mkPreludeMiscIdUnique 101 
1437
1438 fromIntegerClassOpKey, minusClassOpKey, fromRationalClassOpKey,
1439     enumFromClassOpKey, enumFromThenClassOpKey, enumFromToClassOpKey,
1440     enumFromThenToClassOpKey, eqClassOpKey, geClassOpKey, negateClassOpKey,
1441     failMClassOpKey, bindMClassOpKey, thenMClassOpKey, returnMClassOpKey,
1442     fmapClassOpKey
1443     :: Unique
1444 fromIntegerClassOpKey         = mkPreludeMiscIdUnique 102
1445 minusClassOpKey               = mkPreludeMiscIdUnique 103
1446 fromRationalClassOpKey        = mkPreludeMiscIdUnique 104
1447 enumFromClassOpKey            = mkPreludeMiscIdUnique 105
1448 enumFromThenClassOpKey        = mkPreludeMiscIdUnique 106
1449 enumFromToClassOpKey          = mkPreludeMiscIdUnique 107
1450 enumFromThenToClassOpKey      = mkPreludeMiscIdUnique 108
1451 eqClassOpKey                  = mkPreludeMiscIdUnique 109
1452 geClassOpKey                  = mkPreludeMiscIdUnique 110
1453 negateClassOpKey              = mkPreludeMiscIdUnique 111
1454 failMClassOpKey               = mkPreludeMiscIdUnique 112
1455 bindMClassOpKey               = mkPreludeMiscIdUnique 113 -- (>>=)
1456 thenMClassOpKey               = mkPreludeMiscIdUnique 114 -- (>>)
1457 fmapClassOpKey                = mkPreludeMiscIdUnique 115
1458 returnMClassOpKey             = mkPreludeMiscIdUnique 117
1459
1460 -- Recursive do notation
1461 mfixIdKey :: Unique
1462 mfixIdKey       = mkPreludeMiscIdUnique 118
1463
1464 -- Arrow notation
1465 arrAIdKey, composeAIdKey, firstAIdKey, appAIdKey, choiceAIdKey,
1466     loopAIdKey :: Unique
1467 arrAIdKey       = mkPreludeMiscIdUnique 119
1468 composeAIdKey   = mkPreludeMiscIdUnique 120 -- >>>
1469 firstAIdKey     = mkPreludeMiscIdUnique 121
1470 appAIdKey       = mkPreludeMiscIdUnique 122
1471 choiceAIdKey    = mkPreludeMiscIdUnique 123 --  |||
1472 loopAIdKey      = mkPreludeMiscIdUnique 124
1473
1474 fromStringClassOpKey :: Unique
1475 fromStringClassOpKey          = mkPreludeMiscIdUnique 125
1476
1477 -- Annotation type checking
1478 toAnnotationWrapperIdKey :: Unique
1479 toAnnotationWrapperIdKey      = mkPreludeMiscIdUnique 126
1480
1481 -- Conversion functions
1482 fromIntegralIdKey, realToFracIdKey, toIntegerClassOpKey, toRationalClassOpKey :: Unique
1483 fromIntegralIdKey    = mkPreludeMiscIdUnique 127
1484 realToFracIdKey      = mkPreludeMiscIdUnique 128
1485 toIntegerClassOpKey  = mkPreludeMiscIdUnique 129
1486 toRationalClassOpKey = mkPreludeMiscIdUnique 130
1487
1488 -- Monad comprehensions
1489 guardMIdKey, liftMIdKey, groupMIdKey, mzipIdKey :: Unique
1490 guardMIdKey     = mkPreludeMiscIdUnique 131
1491 liftMIdKey      = mkPreludeMiscIdUnique 132
1492 groupMIdKey     = mkPreludeMiscIdUnique 133
1493 mzipIdKey       = mkPreludeMiscIdUnique 134
1494
1495
1496 ---------------- Template Haskell -------------------
1497 --      USES IdUniques 200-499
1498 -----------------------------------------------------
1499 \end{code}
1500
1501
1502 %************************************************************************
1503 %*                                                                      *
1504 \subsection{Standard groups of types}
1505 %*                                                                      *
1506 %************************************************************************
1507
1508 \begin{code}
1509 numericTyKeys :: [Unique]
1510 numericTyKeys = 
1511         [ wordTyConKey
1512         , intTyConKey
1513         , integerTyConKey
1514         , doubleTyConKey
1515         , floatTyConKey
1516         ]
1517
1518 kindKeys :: [Unique] 
1519 kindKeys = [ liftedTypeKindTyConKey
1520            , openTypeKindTyConKey
1521            , unliftedTypeKindTyConKey
1522            , ubxTupleKindTyConKey 
1523            , argTypeKindTyConKey ]
1524 \end{code}
1525
1526
1527 %************************************************************************
1528 %*                                                                      *
1529 \subsection[Class-std-groups]{Standard groups of Prelude classes}
1530 %*                                                                      *
1531 %************************************************************************
1532
1533 NOTE: @Eq@ and @Text@ do need to appear in @standardClasses@
1534 even though every numeric class has these two as a superclass,
1535 because the list of ambiguous dictionaries hasn't been simplified.
1536
1537 \begin{code}
1538 numericClassKeys :: [Unique]
1539 numericClassKeys =
1540         [ numClassKey
1541         , realClassKey
1542         , integralClassKey
1543         ]
1544         ++ fractionalClassKeys
1545
1546 fractionalClassKeys :: [Unique]
1547 fractionalClassKeys = 
1548         [ fractionalClassKey
1549         , floatingClassKey
1550         , realFracClassKey
1551         , realFloatClassKey
1552         ]
1553
1554         -- the strictness analyser needs to know about numeric types
1555         -- (see SaAbsInt.lhs)
1556 needsDataDeclCtxtClassKeys :: [Unique]
1557 needsDataDeclCtxtClassKeys = -- see comments in TcDeriv
1558         [ readClassKey
1559         ]
1560
1561 -- The "standard classes" are used in defaulting (Haskell 98 report 4.3.4),
1562 -- and are: "classes defined in the Prelude or a standard library"
1563 standardClassKeys :: [Unique]
1564 standardClassKeys = derivableClassKeys ++ numericClassKeys
1565                   ++ [randomClassKey, randomGenClassKey,
1566                       functorClassKey, 
1567                       monadClassKey, monadPlusClassKey,
1568                       isStringClassKey,
1569                       applicativeClassKey, foldableClassKey, traversableClassKey
1570                      ]
1571 \end{code}
1572
1573 @derivableClassKeys@ is also used in checking \tr{deriving} constructs
1574 (@TcDeriv@).
1575
1576 \begin{code}
1577 derivableClassKeys :: [Unique]
1578 derivableClassKeys
1579   = [ eqClassKey, ordClassKey, enumClassKey, ixClassKey,
1580       boundedClassKey, showClassKey, readClassKey ]
1581 \end{code}
1582