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