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