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