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