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