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