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