2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4 \section[PrelNames]{Definitions of prelude modules and names}
7 Nota Bene: all Names defined in here should come from the base package
9 * ModuleNames for prelude modules,
10 e.g. pREL_BASE_Name :: ModuleName
12 * Modules for prelude modules
13 e.g. pREL_Base :: Module
15 * Uniques for Ids, DataCons, TyCons and Classes that the compiler
16 "knows about" in some way
17 e.g. intTyConKey :: Unique
18 minusClassOpKey :: Unique
20 * Names for Ids, DataCons, TyCons and Classes that the compiler
21 "knows about" in some way
22 e.g. intTyConName :: Name
24 One of these Names contains
25 (a) the module and occurrence name of the thing
27 The may way the compiler "knows about" one of these things is
28 where the type checker or desugarer needs to look it up. For
29 example, when desugaring list comprehensions the desugarer
30 needs to conjure up 'foldr'. It does this by looking up
31 foldrName in the environment.
33 * RdrNames for Ids, DataCons etc that the compiler may emit into
34 generated code (e.g. for deriving). It's not necessary to know
35 the uniques for these guys, only their names
40 Unique, Uniquable(..), hasKey, -- Re-exported for convenience
42 -----------------------------------------------------------
43 module PrelNames, -- A huge bunch of (a) Names, e.g. intTyConName
44 -- (b) Uniques e.g. intTyConKey
45 -- (c) Groups of classes and types
46 -- (d) miscellaneous things
47 -- So many that we export them all
50 #include "HsVersions.h"
54 import RdrName ( RdrName, nameRdrName, mkOrig, rdrNameOcc, mkUnqual )
55 import Unique ( Unique, Uniquable(..), hasKey,
56 mkPreludeMiscIdUnique, mkPreludeDataConUnique,
57 mkPreludeTyConUnique, mkPreludeClassUnique,
60 import BasicTypes ( Boxity(..), Arity )
61 import Name ( Name, mkInternalName, mkExternalName )
67 %************************************************************************
69 \subsection{Local Names}
71 %************************************************************************
73 This *local* name is used by the interactive stuff
76 itName :: Unique -> Name
77 itName uniq = mkInternalName uniq (mkOccNameFS varName (fsLit "it")) noSrcSpan
81 -- mkUnboundName makes a place-holder Name; it shouldn't be looked at except possibly
82 -- during compiler debugging.
83 mkUnboundName :: RdrName -> Name
84 mkUnboundName rdr_name = mkInternalName unboundKey (rdrNameOcc rdr_name) noSrcSpan
86 isUnboundName :: Name -> Bool
87 isUnboundName name = name `hasKey` unboundKey
91 %************************************************************************
93 \subsection{Known key Names}
95 %************************************************************************
97 This section tells what the compiler knows about the assocation of
98 names with uniques. These ones are the *non* wired-in ones. The
99 wired in ones are defined in TysWiredIn etc.
102 basicKnownKeyNames :: [Name]
105 ++ typeableClassNames
106 ++ [ -- Type constructors (synonyms especially)
107 ioTyConName, ioDataConName,
114 integerTyConName, smallIntegerName,
116 -- Classes. *Must* include:
117 -- classes that are grabbed by key (e.g., eqClassKey)
118 -- classes in "Class.standardClassKeys" (quite a few)
119 eqClassName, -- mentioned, derivable
120 ordClassName, -- derivable
121 boundedClassName, -- derivable
122 numClassName, -- mentioned, numeric
123 enumClassName, -- derivable
126 realClassName, -- numeric
127 integralClassName, -- numeric
128 fractionalClassName, -- numeric
129 floatingClassName, -- numeric
130 realFracClassName, -- numeric
131 realFloatClassName, -- numeric
136 negateName, minusName,
137 fromRationalName, fromIntegerName,
144 enumFromName, enumFromThenName,
145 enumFromThenToName, enumFromToName,
146 enumFromToPName, enumFromThenToPName,
149 thenIOName, bindIOName, returnIOName, failIOName,
150 failMName, bindMName, thenMName, returnMName,
156 arrAName, composeAName, firstAName,
157 appAName, choiceAName, loopAName,
175 unpackCStringName, unpackCStringAppendName,
176 unpackCStringFoldrName, unpackCStringUtf8Name,
179 concatName, filterName, mapName,
180 zipName, foldrName, buildName, augmentName, appendName,
182 -- Parallel array operations
183 nullPName, lengthPName, replicatePName, singletonPName, mapPName,
184 filterPName, zipPName, crossMapPName, indexPName,
185 toPName, bpermutePName, bpermuteDftPName, indexOfPName,
187 -- FFI primitive types that are not wired-in.
188 stablePtrTyConName, ptrTyConName, funPtrTyConName,
189 int8TyConName, int16TyConName, int32TyConName, int64TyConName,
190 wordTyConName, word8TyConName, word16TyConName, word32TyConName, word64TyConName,
193 otherwiseIdName, inlineIdName,
194 plusIntegerName, timesIntegerName,
195 eqStringName, assertName, breakpointName, breakpointCondName,
196 breakpointAutoName, opaqueTyConName,
197 assertErrorName, runSTRepName,
198 printName, fstName, sndName,
201 monadFixClassName, mfixName,
204 randomClassName, randomGenClassName, monadPlusClassName,
210 , eitherTyConName, leftDataConName, rightDataConName
213 , objectTyConName, marshalObjectName, unmarshalObjectName
214 , marshalStringName, unmarshalStringName, checkDotnetResName
217 genericTyConNames :: [Name]
218 genericTyConNames = [crossTyConName, plusTyConName, genUnitTyConName]
222 %************************************************************************
224 \subsection{Module names}
226 %************************************************************************
229 --MetaHaskell Extension Add a new module here
232 pRELUDE = mkBaseModule_ pRELUDE_NAME
234 gHC_PRIM, gHC_BOOL, gHC_ORDERING, gHC_GENERICS, gHC_BASE, gHC_ENUM,
235 gHC_SHOW, gHC_READ, gHC_NUM, gHC_INTEGER, gHC_LIST, gHC_PARR,
236 dATA_TUP, dATA_EITHER, dATA_STRING, gHC_PACK, gHC_CONC, gHC_IO_BASE,
237 gHC_ST, gHC_ARR, gHC_STABLE, gHC_ADDR, gHC_PTR, gHC_ERR, gHC_REAL,
238 gHC_FLOAT, gHC_TOP_HANDLER, sYSTEM_IO, dYNAMIC, tYPEABLE, gENERICS,
239 dOTNET, rEAD_PREC, lEX, gHC_INT, gHC_WORD, mONAD, mONAD_FIX, aRROW,
240 gHC_DESUGAR, rANDOM, gHC_EXTS :: Module
241 gHC_PRIM = mkPrimModule (fsLit "GHC.Prim") -- Primitive types and values
242 gHC_BOOL = mkPrimModule (fsLit "GHC.Bool")
243 gHC_ORDERING = mkPrimModule (fsLit "GHC.Ordering")
244 gHC_GENERICS = mkPrimModule (fsLit "GHC.Generics")
245 gHC_BASE = mkBaseModule (fsLit "GHC.Base")
246 gHC_ENUM = mkBaseModule (fsLit "GHC.Enum")
247 gHC_SHOW = mkBaseModule (fsLit "GHC.Show")
248 gHC_READ = mkBaseModule (fsLit "GHC.Read")
249 gHC_NUM = mkBaseModule (fsLit "GHC.Num")
250 gHC_INTEGER = mkIntegerModule (fsLit "GHC.Integer")
251 gHC_LIST = mkBaseModule (fsLit "GHC.List")
252 gHC_PARR = mkBaseModule (fsLit "GHC.PArr")
253 dATA_TUP = mkBaseModule (fsLit "Data.Tuple")
254 dATA_EITHER = mkBaseModule (fsLit "Data.Either")
255 dATA_STRING = mkBaseModule (fsLit "Data.String")
256 gHC_PACK = mkBaseModule (fsLit "GHC.Pack")
257 gHC_CONC = mkBaseModule (fsLit "GHC.Conc")
258 gHC_IO_BASE = mkBaseModule (fsLit "GHC.IOBase")
259 gHC_ST = mkBaseModule (fsLit "GHC.ST")
260 gHC_ARR = mkBaseModule (fsLit "GHC.Arr")
261 gHC_STABLE = mkBaseModule (fsLit "GHC.Stable")
262 gHC_ADDR = mkBaseModule (fsLit "GHC.Addr")
263 gHC_PTR = mkBaseModule (fsLit "GHC.Ptr")
264 gHC_ERR = mkBaseModule (fsLit "GHC.Err")
265 gHC_REAL = mkBaseModule (fsLit "GHC.Real")
266 gHC_FLOAT = mkBaseModule (fsLit "GHC.Float")
267 gHC_TOP_HANDLER = mkBaseModule (fsLit "GHC.TopHandler")
268 sYSTEM_IO = mkBaseModule (fsLit "System.IO")
269 dYNAMIC = mkBaseModule (fsLit "Data.Dynamic")
270 tYPEABLE = mkBaseModule (fsLit "Data.Typeable")
271 gENERICS = mkBaseModule (fsLit "Data.Generics.Basics")
272 dOTNET = mkBaseModule (fsLit "GHC.Dotnet")
273 rEAD_PREC = mkBaseModule (fsLit "Text.ParserCombinators.ReadPrec")
274 lEX = mkBaseModule (fsLit "Text.Read.Lex")
275 gHC_INT = mkBaseModule (fsLit "GHC.Int")
276 gHC_WORD = mkBaseModule (fsLit "GHC.Word")
277 mONAD = mkBaseModule (fsLit "Control.Monad")
278 mONAD_FIX = mkBaseModule (fsLit "Control.Monad.Fix")
279 aRROW = mkBaseModule (fsLit "Control.Arrow")
280 gHC_DESUGAR = mkBaseModule (fsLit "GHC.Desugar")
281 rANDOM = mkBaseModule (fsLit "System.Random")
282 gHC_EXTS = mkBaseModule (fsLit "GHC.Exts")
284 mAIN, rOOT_MAIN :: Module
285 mAIN = mkMainModule_ mAIN_NAME
286 rOOT_MAIN = mkMainModule (fsLit ":Main") -- Root module for initialisation
288 -- The ':xxx' makes a module name that the user can never
289 -- use himself. The z-encoding for ':' is "ZC", so the z-encoded
290 -- module name still starts with a capital letter, which keeps
291 -- the z-encoded version consistent.
292 iNTERACTIVE, thFAKE :: Module
293 iNTERACTIVE = mkMainModule (fsLit ":Interactive")
294 thFAKE = mkMainModule (fsLit ":THFake")
296 pRELUDE_NAME, mAIN_NAME :: ModuleName
297 pRELUDE_NAME = mkModuleNameFS (fsLit "Prelude")
298 mAIN_NAME = mkModuleNameFS (fsLit "Main")
300 mkPrimModule :: FastString -> Module
301 mkPrimModule m = mkModule primPackageId (mkModuleNameFS m)
303 mkIntegerModule :: FastString -> Module
304 mkIntegerModule m = mkModule integerPackageId (mkModuleNameFS m)
306 mkBaseModule :: FastString -> Module
307 mkBaseModule m = mkModule basePackageId (mkModuleNameFS m)
309 mkBaseModule_ :: ModuleName -> Module
310 mkBaseModule_ m = mkModule basePackageId m
312 mkMainModule :: FastString -> Module
313 mkMainModule m = mkModule mainPackageId (mkModuleNameFS m)
315 mkMainModule_ :: ModuleName -> Module
316 mkMainModule_ m = mkModule mainPackageId m
319 %************************************************************************
321 \subsection{Constructing the names of tuples
323 %************************************************************************
326 mkTupleModule :: Boxity -> Arity -> Module
327 mkTupleModule Boxed 0 = gHC_BASE
328 mkTupleModule Boxed _ = dATA_TUP
329 mkTupleModule Unboxed _ = gHC_PRIM
333 %************************************************************************
337 %************************************************************************
340 main_RDR_Unqual :: RdrName
341 main_RDR_Unqual = mkUnqual varName (fsLit "main")
342 -- We definitely don't want an Orig RdrName, because
343 -- main might, in principle, be imported into module Main
345 forall_tv_RDR, dot_tv_RDR :: RdrName
346 forall_tv_RDR = mkUnqual tvName (fsLit "forall")
347 dot_tv_RDR = mkUnqual tvName (fsLit ".")
349 eq_RDR, ge_RDR, ne_RDR, le_RDR, lt_RDR, gt_RDR, compare_RDR,
350 ltTag_RDR, eqTag_RDR, gtTag_RDR :: RdrName
351 eq_RDR = nameRdrName eqName
352 ge_RDR = nameRdrName geName
353 ne_RDR = varQual_RDR gHC_BASE (fsLit "/=")
354 le_RDR = varQual_RDR gHC_BASE (fsLit "<=")
355 lt_RDR = varQual_RDR gHC_BASE (fsLit "<")
356 gt_RDR = varQual_RDR gHC_BASE (fsLit ">")
357 compare_RDR = varQual_RDR gHC_BASE (fsLit "compare")
358 ltTag_RDR = dataQual_RDR gHC_ORDERING (fsLit "LT")
359 eqTag_RDR = dataQual_RDR gHC_ORDERING (fsLit "EQ")
360 gtTag_RDR = dataQual_RDR gHC_ORDERING (fsLit "GT")
362 eqClass_RDR, numClass_RDR, ordClass_RDR, enumClass_RDR, monadClass_RDR
364 eqClass_RDR = nameRdrName eqClassName
365 numClass_RDR = nameRdrName numClassName
366 ordClass_RDR = nameRdrName ordClassName
367 enumClass_RDR = nameRdrName enumClassName
368 monadClass_RDR = nameRdrName monadClassName
370 map_RDR, append_RDR :: RdrName
371 map_RDR = varQual_RDR gHC_BASE (fsLit "map")
372 append_RDR = varQual_RDR gHC_BASE (fsLit "++")
374 foldr_RDR, build_RDR, returnM_RDR, bindM_RDR, failM_RDR :: RdrName
375 foldr_RDR = nameRdrName foldrName
376 build_RDR = nameRdrName buildName
377 returnM_RDR = nameRdrName returnMName
378 bindM_RDR = nameRdrName bindMName
379 failM_RDR = nameRdrName failMName
382 and_RDR = nameRdrName andName
384 left_RDR, right_RDR :: RdrName
385 left_RDR = nameRdrName leftDataConName
386 right_RDR = nameRdrName rightDataConName
388 fromEnum_RDR, toEnum_RDR :: RdrName
389 fromEnum_RDR = varQual_RDR gHC_ENUM (fsLit "fromEnum")
390 toEnum_RDR = varQual_RDR gHC_ENUM (fsLit "toEnum")
392 enumFrom_RDR, enumFromTo_RDR, enumFromThen_RDR, enumFromThenTo_RDR :: RdrName
393 enumFrom_RDR = nameRdrName enumFromName
394 enumFromTo_RDR = nameRdrName enumFromToName
395 enumFromThen_RDR = nameRdrName enumFromThenName
396 enumFromThenTo_RDR = nameRdrName enumFromThenToName
398 ratioDataCon_RDR, plusInteger_RDR, timesInteger_RDR :: RdrName
399 ratioDataCon_RDR = nameRdrName ratioDataConName
400 plusInteger_RDR = nameRdrName plusIntegerName
401 timesInteger_RDR = nameRdrName timesIntegerName
403 ioDataCon_RDR :: RdrName
404 ioDataCon_RDR = nameRdrName ioDataConName
406 eqString_RDR, unpackCString_RDR, unpackCStringFoldr_RDR,
407 unpackCStringUtf8_RDR :: RdrName
408 eqString_RDR = nameRdrName eqStringName
409 unpackCString_RDR = nameRdrName unpackCStringName
410 unpackCStringFoldr_RDR = nameRdrName unpackCStringFoldrName
411 unpackCStringUtf8_RDR = nameRdrName unpackCStringUtf8Name
413 newStablePtr_RDR, wordDataCon_RDR :: RdrName
414 newStablePtr_RDR = nameRdrName newStablePtrName
415 wordDataCon_RDR = dataQual_RDR gHC_WORD (fsLit "W#")
417 bindIO_RDR, returnIO_RDR :: RdrName
418 bindIO_RDR = nameRdrName bindIOName
419 returnIO_RDR = nameRdrName returnIOName
421 fromInteger_RDR, fromRational_RDR, minus_RDR, times_RDR, plus_RDR :: RdrName
422 fromInteger_RDR = nameRdrName fromIntegerName
423 fromRational_RDR = nameRdrName fromRationalName
424 minus_RDR = nameRdrName minusName
425 times_RDR = varQual_RDR gHC_NUM (fsLit "*")
426 plus_RDR = varQual_RDR gHC_NUM (fsLit "+")
428 fromString_RDR :: RdrName
429 fromString_RDR = nameRdrName fromStringName
431 compose_RDR :: RdrName
432 compose_RDR = varQual_RDR gHC_BASE (fsLit ".")
434 not_RDR, getTag_RDR, succ_RDR, pred_RDR, minBound_RDR, maxBound_RDR,
435 range_RDR, inRange_RDR, index_RDR,
436 unsafeIndex_RDR, unsafeRangeSize_RDR :: RdrName
437 not_RDR = varQual_RDR gHC_BASE (fsLit "not")
438 getTag_RDR = varQual_RDR gHC_BASE (fsLit "getTag")
439 succ_RDR = varQual_RDR gHC_ENUM (fsLit "succ")
440 pred_RDR = varQual_RDR gHC_ENUM (fsLit "pred")
441 minBound_RDR = varQual_RDR gHC_ENUM (fsLit "minBound")
442 maxBound_RDR = varQual_RDR gHC_ENUM (fsLit "maxBound")
443 range_RDR = varQual_RDR gHC_ARR (fsLit "range")
444 inRange_RDR = varQual_RDR gHC_ARR (fsLit "inRange")
445 index_RDR = varQual_RDR gHC_ARR (fsLit "index")
446 unsafeIndex_RDR = varQual_RDR gHC_ARR (fsLit "unsafeIndex")
447 unsafeRangeSize_RDR = varQual_RDR gHC_ARR (fsLit "unsafeRangeSize")
449 readList_RDR, readListDefault_RDR, readListPrec_RDR, readListPrecDefault_RDR,
450 readPrec_RDR, parens_RDR, choose_RDR, lexP_RDR :: RdrName
451 readList_RDR = varQual_RDR gHC_READ (fsLit "readList")
452 readListDefault_RDR = varQual_RDR gHC_READ (fsLit "readListDefault")
453 readListPrec_RDR = varQual_RDR gHC_READ (fsLit "readListPrec")
454 readListPrecDefault_RDR = varQual_RDR gHC_READ (fsLit "readListPrecDefault")
455 readPrec_RDR = varQual_RDR gHC_READ (fsLit "readPrec")
456 parens_RDR = varQual_RDR gHC_READ (fsLit "parens")
457 choose_RDR = varQual_RDR gHC_READ (fsLit "choose")
458 lexP_RDR = varQual_RDR gHC_READ (fsLit "lexP")
460 punc_RDR, ident_RDR, symbol_RDR :: RdrName
461 punc_RDR = dataQual_RDR lEX (fsLit "Punc")
462 ident_RDR = dataQual_RDR lEX (fsLit "Ident")
463 symbol_RDR = dataQual_RDR lEX (fsLit "Symbol")
465 step_RDR, alt_RDR, reset_RDR, prec_RDR :: RdrName
466 step_RDR = varQual_RDR rEAD_PREC (fsLit "step")
467 alt_RDR = varQual_RDR rEAD_PREC (fsLit "+++")
468 reset_RDR = varQual_RDR rEAD_PREC (fsLit "reset")
469 prec_RDR = varQual_RDR rEAD_PREC (fsLit "prec")
471 showList_RDR, showList___RDR, showsPrec_RDR, showString_RDR,
472 showSpace_RDR, showParen_RDR :: RdrName
473 showList_RDR = varQual_RDR gHC_SHOW (fsLit "showList")
474 showList___RDR = varQual_RDR gHC_SHOW (fsLit "showList__")
475 showsPrec_RDR = varQual_RDR gHC_SHOW (fsLit "showsPrec")
476 showString_RDR = varQual_RDR gHC_SHOW (fsLit "showString")
477 showSpace_RDR = varQual_RDR gHC_SHOW (fsLit "showSpace")
478 showParen_RDR = varQual_RDR gHC_SHOW (fsLit "showParen")
480 typeOf_RDR, mkTypeRep_RDR, mkTyConRep_RDR :: RdrName
481 typeOf_RDR = varQual_RDR tYPEABLE (fsLit "typeOf")
482 mkTypeRep_RDR = varQual_RDR tYPEABLE (fsLit "mkTyConApp")
483 mkTyConRep_RDR = varQual_RDR tYPEABLE (fsLit "mkTyCon")
485 undefined_RDR :: RdrName
486 undefined_RDR = varQual_RDR gHC_ERR (fsLit "undefined")
488 crossDataCon_RDR, inlDataCon_RDR, inrDataCon_RDR, genUnitDataCon_RDR :: RdrName
489 crossDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit ":*:")
490 inlDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Inl")
491 inrDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Inr")
492 genUnitDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Unit")
494 ----------------------
495 varQual_RDR, tcQual_RDR, clsQual_RDR, dataQual_RDR
496 :: Module -> FastString -> RdrName
497 varQual_RDR mod str = mkOrig mod (mkOccNameFS varName str)
498 tcQual_RDR mod str = mkOrig mod (mkOccNameFS tcName str)
499 clsQual_RDR mod str = mkOrig mod (mkOccNameFS clsName str)
500 dataQual_RDR mod str = mkOrig mod (mkOccNameFS dataName str)
503 %************************************************************************
505 \subsection{Known-key names}
507 %************************************************************************
509 Many of these Names are not really "built in", but some parts of the
510 compiler (notably the deriving mechanism) need to mention their names,
511 and it's convenient to write them all down in one place.
513 --MetaHaskell Extension add the constrs and the lower case case
514 -- guys as well (perhaps) e.g. see trueDataConName below
518 runMainIOName :: Name
519 runMainIOName = varQual gHC_TOP_HANDLER (fsLit "runMainIO") runMainKey
521 orderingTyConName :: Name
522 orderingTyConName = tcQual gHC_ORDERING (fsLit "Ordering") orderingTyConKey
524 eitherTyConName, leftDataConName, rightDataConName :: Name
525 eitherTyConName = tcQual dATA_EITHER (fsLit "Either") eitherTyConKey
526 leftDataConName = conName dATA_EITHER (fsLit "Left") leftDataConKey
527 rightDataConName = conName dATA_EITHER (fsLit "Right") rightDataConKey
530 crossTyConName, plusTyConName, genUnitTyConName :: Name
531 crossTyConName = tcQual gHC_GENERICS (fsLit ":*:") crossTyConKey
532 plusTyConName = tcQual gHC_GENERICS (fsLit ":+:") plusTyConKey
533 genUnitTyConName = tcQual gHC_GENERICS (fsLit "Unit") genUnitTyConKey
535 -- Base strings Strings
536 unpackCStringName, unpackCStringAppendName, unpackCStringFoldrName,
537 unpackCStringUtf8Name, eqStringName, stringTyConName :: Name
538 unpackCStringName = varQual gHC_BASE (fsLit "unpackCString#") unpackCStringIdKey
539 unpackCStringAppendName = varQual gHC_BASE (fsLit "unpackAppendCString#") unpackCStringAppendIdKey
540 unpackCStringFoldrName = varQual gHC_BASE (fsLit "unpackFoldrCString#") unpackCStringFoldrIdKey
541 unpackCStringUtf8Name = varQual gHC_BASE (fsLit "unpackCStringUtf8#") unpackCStringUtf8IdKey
542 eqStringName = varQual gHC_BASE (fsLit "eqString") eqStringIdKey
543 stringTyConName = tcQual gHC_BASE (fsLit "String") stringTyConKey
545 -- The 'inline' function
547 inlineIdName = varQual gHC_BASE (fsLit "inline") inlineIdKey
549 -- Base classes (Eq, Ord, Functor)
550 eqClassName, eqName, ordClassName, geName, functorClassName :: Name
551 eqClassName = clsQual gHC_BASE (fsLit "Eq") eqClassKey
552 eqName = methName gHC_BASE (fsLit "==") eqClassOpKey
553 ordClassName = clsQual gHC_BASE (fsLit "Ord") ordClassKey
554 geName = methName gHC_BASE (fsLit ">=") geClassOpKey
555 functorClassName = clsQual gHC_BASE (fsLit "Functor") functorClassKey
558 monadClassName, thenMName, bindMName, returnMName, failMName :: Name
559 monadClassName = clsQual gHC_BASE (fsLit "Monad") monadClassKey
560 thenMName = methName gHC_BASE (fsLit ">>") thenMClassOpKey
561 bindMName = methName gHC_BASE (fsLit ">>=") bindMClassOpKey
562 returnMName = methName gHC_BASE (fsLit "return") returnMClassOpKey
563 failMName = methName gHC_BASE (fsLit "fail") failMClassOpKey
565 -- Functions for GHC extensions
566 groupWithName :: Name
567 groupWithName = varQual gHC_EXTS (fsLit "groupWith") groupWithIdKey
569 -- Random PrelBase functions
570 fromStringName, otherwiseIdName, foldrName, buildName, augmentName,
571 mapName, appendName, andName, orName, assertName,
572 breakpointName, breakpointCondName, breakpointAutoName,
573 opaqueTyConName :: Name
574 fromStringName = methName dATA_STRING (fsLit "fromString") fromStringClassOpKey
575 otherwiseIdName = varQual gHC_BASE (fsLit "otherwise") otherwiseIdKey
576 foldrName = varQual gHC_BASE (fsLit "foldr") foldrIdKey
577 buildName = varQual gHC_BASE (fsLit "build") buildIdKey
578 augmentName = varQual gHC_BASE (fsLit "augment") augmentIdKey
579 mapName = varQual gHC_BASE (fsLit "map") mapIdKey
580 appendName = varQual gHC_BASE (fsLit "++") appendIdKey
581 andName = varQual gHC_BASE (fsLit "&&") andIdKey
582 orName = varQual gHC_BASE (fsLit "||") orIdKey
583 assertName = varQual gHC_BASE (fsLit "assert") assertIdKey
584 breakpointName = varQual gHC_BASE (fsLit "breakpoint") breakpointIdKey
585 breakpointCondName= varQual gHC_BASE (fsLit "breakpointCond") breakpointCondIdKey
586 breakpointAutoName= varQual gHC_BASE (fsLit "breakpointAuto") breakpointAutoIdKey
587 opaqueTyConName = tcQual gHC_BASE (fsLit "Opaque") opaqueTyConKey
589 breakpointJumpName :: Name
593 (mkOccNameFS varName (fsLit "breakpointJump"))
595 breakpointCondJumpName :: Name
596 breakpointCondJumpName
598 breakpointCondJumpIdKey
599 (mkOccNameFS varName (fsLit "breakpointCondJump"))
601 breakpointAutoJumpName :: Name
602 breakpointAutoJumpName
604 breakpointAutoJumpIdKey
605 (mkOccNameFS varName (fsLit "breakpointAutoJump"))
609 fstName, sndName :: Name
610 fstName = varQual dATA_TUP (fsLit "fst") fstIdKey
611 sndName = varQual dATA_TUP (fsLit "snd") sndIdKey
614 numClassName, fromIntegerName, minusName, negateName, plusIntegerName,
615 timesIntegerName, integerTyConName, smallIntegerName :: Name
616 numClassName = clsQual gHC_NUM (fsLit "Num") numClassKey
617 fromIntegerName = methName gHC_NUM (fsLit "fromInteger") fromIntegerClassOpKey
618 minusName = methName gHC_NUM (fsLit "-") minusClassOpKey
619 negateName = methName gHC_NUM (fsLit "negate") negateClassOpKey
620 plusIntegerName = varQual gHC_INTEGER (fsLit "plusInteger") plusIntegerIdKey
621 timesIntegerName = varQual gHC_INTEGER (fsLit "timesInteger") timesIntegerIdKey
622 integerTyConName = tcQual gHC_INTEGER (fsLit "Integer") integerTyConKey
623 smallIntegerName = varQual gHC_INTEGER (fsLit "smallInteger") smallIntegerIdKey
625 -- PrelReal types and classes
626 rationalTyConName, ratioTyConName, ratioDataConName, realClassName,
627 integralClassName, realFracClassName, fractionalClassName,
628 fromRationalName :: Name
629 rationalTyConName = tcQual gHC_REAL (fsLit "Rational") rationalTyConKey
630 ratioTyConName = tcQual gHC_REAL (fsLit "Ratio") ratioTyConKey
631 ratioDataConName = conName gHC_REAL (fsLit ":%") ratioDataConKey
632 realClassName = clsQual gHC_REAL (fsLit "Real") realClassKey
633 integralClassName = clsQual gHC_REAL (fsLit "Integral") integralClassKey
634 realFracClassName = clsQual gHC_REAL (fsLit "RealFrac") realFracClassKey
635 fractionalClassName = clsQual gHC_REAL (fsLit "Fractional") fractionalClassKey
636 fromRationalName = methName gHC_REAL (fsLit "fromRational") fromRationalClassOpKey
639 floatingClassName, realFloatClassName :: Name
640 floatingClassName = clsQual gHC_FLOAT (fsLit "Floating") floatingClassKey
641 realFloatClassName = clsQual gHC_FLOAT (fsLit "RealFloat") realFloatClassKey
645 ixClassName = clsQual gHC_ARR (fsLit "Ix") ixClassKey
648 typeableClassName, typeable1ClassName, typeable2ClassName,
649 typeable3ClassName, typeable4ClassName, typeable5ClassName,
650 typeable6ClassName, typeable7ClassName :: Name
651 typeableClassName = clsQual tYPEABLE (fsLit "Typeable") typeableClassKey
652 typeable1ClassName = clsQual tYPEABLE (fsLit "Typeable1") typeable1ClassKey
653 typeable2ClassName = clsQual tYPEABLE (fsLit "Typeable2") typeable2ClassKey
654 typeable3ClassName = clsQual tYPEABLE (fsLit "Typeable3") typeable3ClassKey
655 typeable4ClassName = clsQual tYPEABLE (fsLit "Typeable4") typeable4ClassKey
656 typeable5ClassName = clsQual tYPEABLE (fsLit "Typeable5") typeable5ClassKey
657 typeable6ClassName = clsQual tYPEABLE (fsLit "Typeable6") typeable6ClassKey
658 typeable7ClassName = clsQual tYPEABLE (fsLit "Typeable7") typeable7ClassKey
660 typeableClassNames :: [Name]
661 typeableClassNames = [ typeableClassName, typeable1ClassName, typeable2ClassName
662 , typeable3ClassName, typeable4ClassName, typeable5ClassName
663 , typeable6ClassName, typeable7ClassName ]
666 dataClassName :: Name
667 dataClassName = clsQual gENERICS (fsLit "Data") dataClassKey
670 assertErrorName :: Name
671 assertErrorName = varQual gHC_ERR (fsLit "assertError") assertErrorIdKey
673 -- Enum module (Enum, Bounded)
674 enumClassName, enumFromName, enumFromToName, enumFromThenName,
675 enumFromThenToName, boundedClassName :: Name
676 enumClassName = clsQual gHC_ENUM (fsLit "Enum") enumClassKey
677 enumFromName = methName gHC_ENUM (fsLit "enumFrom") enumFromClassOpKey
678 enumFromToName = methName gHC_ENUM (fsLit "enumFromTo") enumFromToClassOpKey
679 enumFromThenName = methName gHC_ENUM (fsLit "enumFromThen") enumFromThenClassOpKey
680 enumFromThenToName = methName gHC_ENUM (fsLit "enumFromThenTo") enumFromThenToClassOpKey
681 boundedClassName = clsQual gHC_ENUM (fsLit "Bounded") boundedClassKey
684 concatName, filterName, zipName :: Name
685 concatName = varQual gHC_LIST (fsLit "concat") concatIdKey
686 filterName = varQual gHC_LIST (fsLit "filter") filterIdKey
687 zipName = varQual gHC_LIST (fsLit "zip") zipIdKey
690 showClassName :: Name
691 showClassName = clsQual gHC_SHOW (fsLit "Show") showClassKey
694 readClassName :: Name
695 readClassName = clsQual gHC_READ (fsLit "Read") readClassKey
697 -- parallel array types and functions
698 enumFromToPName, enumFromThenToPName, nullPName, lengthPName,
699 singletonPName, replicatePName, mapPName, filterPName,
700 zipPName, crossMapPName, indexPName, toPName, bpermutePName,
701 bpermuteDftPName, indexOfPName :: Name
702 enumFromToPName = varQual gHC_PARR (fsLit "enumFromToP") enumFromToPIdKey
703 enumFromThenToPName= varQual gHC_PARR (fsLit "enumFromThenToP") enumFromThenToPIdKey
704 nullPName = varQual gHC_PARR (fsLit "nullP") nullPIdKey
705 lengthPName = varQual gHC_PARR (fsLit "lengthP") lengthPIdKey
706 singletonPName = varQual gHC_PARR (fsLit "singletonP") singletonPIdKey
707 replicatePName = varQual gHC_PARR (fsLit "replicateP") replicatePIdKey
708 mapPName = varQual gHC_PARR (fsLit "mapP") mapPIdKey
709 filterPName = varQual gHC_PARR (fsLit "filterP") filterPIdKey
710 zipPName = varQual gHC_PARR (fsLit "zipP") zipPIdKey
711 crossMapPName = varQual gHC_PARR (fsLit "crossMapP") crossMapPIdKey
712 indexPName = varQual gHC_PARR (fsLit "!:") indexPIdKey
713 toPName = varQual gHC_PARR (fsLit "toP") toPIdKey
714 bpermutePName = varQual gHC_PARR (fsLit "bpermuteP") bpermutePIdKey
715 bpermuteDftPName = varQual gHC_PARR (fsLit "bpermuteDftP") bpermuteDftPIdKey
716 indexOfPName = varQual gHC_PARR (fsLit "indexOfP") indexOfPIdKey
719 ioTyConName, ioDataConName, thenIOName, bindIOName, returnIOName,
721 ioTyConName = tcQual gHC_IO_BASE (fsLit "IO") ioTyConKey
722 ioDataConName = conName gHC_IO_BASE (fsLit "IO") ioDataConKey
723 thenIOName = varQual gHC_IO_BASE (fsLit "thenIO") thenIOIdKey
724 bindIOName = varQual gHC_IO_BASE (fsLit "bindIO") bindIOIdKey
725 returnIOName = varQual gHC_IO_BASE (fsLit "returnIO") returnIOIdKey
726 failIOName = varQual gHC_IO_BASE (fsLit "failIO") failIOIdKey
730 printName = varQual sYSTEM_IO (fsLit "print") printIdKey
732 -- Int, Word, and Addr things
733 int8TyConName, int16TyConName, int32TyConName, int64TyConName :: Name
734 int8TyConName = tcQual gHC_INT (fsLit "Int8") int8TyConKey
735 int16TyConName = tcQual gHC_INT (fsLit "Int16") int16TyConKey
736 int32TyConName = tcQual gHC_INT (fsLit "Int32") int32TyConKey
737 int64TyConName = tcQual gHC_INT (fsLit "Int64") int64TyConKey
740 word8TyConName, word16TyConName, word32TyConName, word64TyConName,
741 wordTyConName, wordDataConName :: Name
742 word8TyConName = tcQual gHC_WORD (fsLit "Word8") word8TyConKey
743 word16TyConName = tcQual gHC_WORD (fsLit "Word16") word16TyConKey
744 word32TyConName = tcQual gHC_WORD (fsLit "Word32") word32TyConKey
745 word64TyConName = tcQual gHC_WORD (fsLit "Word64") word64TyConKey
746 wordTyConName = tcQual gHC_WORD (fsLit "Word") wordTyConKey
747 wordDataConName = conName gHC_WORD (fsLit "W#") wordDataConKey
750 ptrTyConName, funPtrTyConName :: Name
751 ptrTyConName = tcQual gHC_PTR (fsLit "Ptr") ptrTyConKey
752 funPtrTyConName = tcQual gHC_PTR (fsLit "FunPtr") funPtrTyConKey
754 -- Foreign objects and weak pointers
755 stablePtrTyConName, newStablePtrName :: Name
756 stablePtrTyConName = tcQual gHC_STABLE (fsLit "StablePtr") stablePtrTyConKey
757 newStablePtrName = varQual gHC_STABLE (fsLit "newStablePtr") newStablePtrIdKey
761 runSTRepName = varQual gHC_ST (fsLit "runSTRep") runSTRepIdKey
763 -- Recursive-do notation
764 monadFixClassName, mfixName :: Name
765 monadFixClassName = clsQual mONAD_FIX (fsLit "MonadFix") monadFixClassKey
766 mfixName = methName mONAD_FIX (fsLit "mfix") mfixIdKey
769 arrAName, composeAName, firstAName, appAName, choiceAName, loopAName :: Name
770 arrAName = varQual aRROW (fsLit "arr") arrAIdKey
771 composeAName = varQual gHC_DESUGAR (fsLit ">>>") composeAIdKey
772 firstAName = varQual aRROW (fsLit "first") firstAIdKey
773 appAName = varQual aRROW (fsLit "app") appAIdKey
774 choiceAName = varQual aRROW (fsLit "|||") choiceAIdKey
775 loopAName = varQual aRROW (fsLit "loop") loopAIdKey
777 -- Other classes, needed for type defaulting
778 monadPlusClassName, randomClassName, randomGenClassName,
779 isStringClassName :: Name
780 monadPlusClassName = clsQual mONAD (fsLit "MonadPlus") monadPlusClassKey
781 randomClassName = clsQual rANDOM (fsLit "Random") randomClassKey
782 randomGenClassName = clsQual rANDOM (fsLit "RandomGen") randomGenClassKey
783 isStringClassName = clsQual dATA_STRING (fsLit "IsString") isStringClassKey
786 objectTyConName :: Name
787 objectTyConName = tcQual dOTNET (fsLit "Object") objectTyConKey
788 -- objectTyConName was "wTcQual", but that's gone now, and
789 -- I can't see why it was wired in anyway...
790 unmarshalObjectName, marshalObjectName, marshalStringName,
791 unmarshalStringName, checkDotnetResName :: Name
792 unmarshalObjectName = varQual dOTNET (fsLit "unmarshalObject") unmarshalObjectIdKey
793 marshalObjectName = varQual dOTNET (fsLit "marshalObject") marshalObjectIdKey
794 marshalStringName = varQual dOTNET (fsLit "marshalString") marshalStringIdKey
795 unmarshalStringName = varQual dOTNET (fsLit "unmarshalString") unmarshalStringIdKey
796 checkDotnetResName = varQual dOTNET (fsLit "checkResult") checkDotnetResNameIdKey
799 %************************************************************************
801 \subsection{Local helpers}
803 %************************************************************************
805 All these are original names; hence mkOrig
808 varQual, tcQual, clsQual :: Module -> FastString -> Unique -> Name
809 varQual = mk_known_key_name varName
810 tcQual = mk_known_key_name tcName
811 clsQual = mk_known_key_name clsName
813 mk_known_key_name :: NameSpace -> Module -> FastString -> Unique -> Name
814 mk_known_key_name space modu str unique
815 = mkExternalName unique modu (mkOccNameFS space str) noSrcSpan
817 conName :: Module -> FastString -> Unique -> Name
818 conName modu occ unique
819 = mkExternalName unique modu (mkOccNameFS dataName occ) noSrcSpan
821 methName :: Module -> FastString -> Unique -> Name
822 methName modu occ unique
823 = mkExternalName unique modu (mkVarOccFS occ) noSrcSpan
826 %************************************************************************
828 \subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@}
830 %************************************************************************
831 --MetaHaskell extension hand allocate keys here
834 boundedClassKey, enumClassKey, eqClassKey, floatingClassKey,
835 fractionalClassKey, integralClassKey, monadClassKey, dataClassKey,
836 functorClassKey, numClassKey, ordClassKey, readClassKey, realClassKey,
837 realFloatClassKey, realFracClassKey, showClassKey, ixClassKey :: Unique
838 boundedClassKey = mkPreludeClassUnique 1
839 enumClassKey = mkPreludeClassUnique 2
840 eqClassKey = mkPreludeClassUnique 3
841 floatingClassKey = mkPreludeClassUnique 5
842 fractionalClassKey = mkPreludeClassUnique 6
843 integralClassKey = mkPreludeClassUnique 7
844 monadClassKey = mkPreludeClassUnique 8
845 dataClassKey = mkPreludeClassUnique 9
846 functorClassKey = mkPreludeClassUnique 10
847 numClassKey = mkPreludeClassUnique 11
848 ordClassKey = mkPreludeClassUnique 12
849 readClassKey = mkPreludeClassUnique 13
850 realClassKey = mkPreludeClassUnique 14
851 realFloatClassKey = mkPreludeClassUnique 15
852 realFracClassKey = mkPreludeClassUnique 16
853 showClassKey = mkPreludeClassUnique 17
854 ixClassKey = mkPreludeClassUnique 18
856 typeableClassKey, typeable1ClassKey, typeable2ClassKey, typeable3ClassKey,
857 typeable4ClassKey, typeable5ClassKey, typeable6ClassKey, typeable7ClassKey
859 typeableClassKey = mkPreludeClassUnique 20
860 typeable1ClassKey = mkPreludeClassUnique 21
861 typeable2ClassKey = mkPreludeClassUnique 22
862 typeable3ClassKey = mkPreludeClassUnique 23
863 typeable4ClassKey = mkPreludeClassUnique 24
864 typeable5ClassKey = mkPreludeClassUnique 25
865 typeable6ClassKey = mkPreludeClassUnique 26
866 typeable7ClassKey = mkPreludeClassUnique 27
868 monadFixClassKey :: Unique
869 monadFixClassKey = mkPreludeClassUnique 28
871 monadPlusClassKey, randomClassKey, randomGenClassKey :: Unique
872 monadPlusClassKey = mkPreludeClassUnique 30
873 randomClassKey = mkPreludeClassUnique 31
874 randomGenClassKey = mkPreludeClassUnique 32
876 isStringClassKey :: Unique
877 isStringClassKey = mkPreludeClassUnique 33
880 %************************************************************************
882 \subsubsection[Uniques-prelude-TyCons]{@Uniques@ for wired-in @TyCons@}
884 %************************************************************************
887 addrPrimTyConKey, arrayPrimTyConKey, boolTyConKey, byteArrayPrimTyConKey,
888 charPrimTyConKey, charTyConKey, doublePrimTyConKey, doubleTyConKey,
889 floatPrimTyConKey, floatTyConKey, funTyConKey, intPrimTyConKey,
890 intTyConKey, int8TyConKey, int16TyConKey, int32PrimTyConKey,
891 int32TyConKey, int64PrimTyConKey, int64TyConKey, integerTyConKey,
892 listTyConKey, foreignObjPrimTyConKey, weakPrimTyConKey,
893 mutableArrayPrimTyConKey, mutableByteArrayPrimTyConKey,
894 orderingTyConKey, mVarPrimTyConKey, ratioTyConKey, rationalTyConKey,
895 realWorldTyConKey, stablePtrPrimTyConKey, stablePtrTyConKey :: Unique
896 addrPrimTyConKey = mkPreludeTyConUnique 1
897 arrayPrimTyConKey = mkPreludeTyConUnique 3
898 boolTyConKey = mkPreludeTyConUnique 4
899 byteArrayPrimTyConKey = mkPreludeTyConUnique 5
900 charPrimTyConKey = mkPreludeTyConUnique 7
901 charTyConKey = mkPreludeTyConUnique 8
902 doublePrimTyConKey = mkPreludeTyConUnique 9
903 doubleTyConKey = mkPreludeTyConUnique 10
904 floatPrimTyConKey = mkPreludeTyConUnique 11
905 floatTyConKey = mkPreludeTyConUnique 12
906 funTyConKey = mkPreludeTyConUnique 13
907 intPrimTyConKey = mkPreludeTyConUnique 14
908 intTyConKey = mkPreludeTyConUnique 15
909 int8TyConKey = mkPreludeTyConUnique 16
910 int16TyConKey = mkPreludeTyConUnique 17
911 int32PrimTyConKey = mkPreludeTyConUnique 18
912 int32TyConKey = mkPreludeTyConUnique 19
913 int64PrimTyConKey = mkPreludeTyConUnique 20
914 int64TyConKey = mkPreludeTyConUnique 21
915 integerTyConKey = mkPreludeTyConUnique 22
916 listTyConKey = mkPreludeTyConUnique 23
917 foreignObjPrimTyConKey = mkPreludeTyConUnique 24
918 weakPrimTyConKey = mkPreludeTyConUnique 27
919 mutableArrayPrimTyConKey = mkPreludeTyConUnique 28
920 mutableByteArrayPrimTyConKey = mkPreludeTyConUnique 29
921 orderingTyConKey = mkPreludeTyConUnique 30
922 mVarPrimTyConKey = mkPreludeTyConUnique 31
923 ratioTyConKey = mkPreludeTyConUnique 32
924 rationalTyConKey = mkPreludeTyConUnique 33
925 realWorldTyConKey = mkPreludeTyConUnique 34
926 stablePtrPrimTyConKey = mkPreludeTyConUnique 35
927 stablePtrTyConKey = mkPreludeTyConUnique 36
929 anyPrimTyConKey, anyPrimTyCon1Key :: Unique
930 anyPrimTyConKey = mkPreludeTyConUnique 37
931 anyPrimTyCon1Key = mkPreludeTyConUnique 38
933 statePrimTyConKey, stableNamePrimTyConKey, stableNameTyConKey,
934 mutVarPrimTyConKey, ioTyConKey,
935 wordPrimTyConKey, wordTyConKey, word8TyConKey, word16TyConKey,
936 word32PrimTyConKey, word32TyConKey, word64PrimTyConKey, word64TyConKey,
937 liftedConKey, unliftedConKey, anyBoxConKey, kindConKey, boxityConKey,
938 typeConKey, threadIdPrimTyConKey, bcoPrimTyConKey, ptrTyConKey,
939 funPtrTyConKey, tVarPrimTyConKey :: Unique
940 statePrimTyConKey = mkPreludeTyConUnique 50
941 stableNamePrimTyConKey = mkPreludeTyConUnique 51
942 stableNameTyConKey = mkPreludeTyConUnique 52
943 mutVarPrimTyConKey = mkPreludeTyConUnique 55
944 ioTyConKey = mkPreludeTyConUnique 56
945 wordPrimTyConKey = mkPreludeTyConUnique 58
946 wordTyConKey = mkPreludeTyConUnique 59
947 word8TyConKey = mkPreludeTyConUnique 60
948 word16TyConKey = mkPreludeTyConUnique 61
949 word32PrimTyConKey = mkPreludeTyConUnique 62
950 word32TyConKey = mkPreludeTyConUnique 63
951 word64PrimTyConKey = mkPreludeTyConUnique 64
952 word64TyConKey = mkPreludeTyConUnique 65
953 liftedConKey = mkPreludeTyConUnique 66
954 unliftedConKey = mkPreludeTyConUnique 67
955 anyBoxConKey = mkPreludeTyConUnique 68
956 kindConKey = mkPreludeTyConUnique 69
957 boxityConKey = mkPreludeTyConUnique 70
958 typeConKey = mkPreludeTyConUnique 71
959 threadIdPrimTyConKey = mkPreludeTyConUnique 72
960 bcoPrimTyConKey = mkPreludeTyConUnique 73
961 ptrTyConKey = mkPreludeTyConUnique 74
962 funPtrTyConKey = mkPreludeTyConUnique 75
963 tVarPrimTyConKey = mkPreludeTyConUnique 76
965 -- Generic Type Constructors
966 crossTyConKey, plusTyConKey, genUnitTyConKey :: Unique
967 crossTyConKey = mkPreludeTyConUnique 79
968 plusTyConKey = mkPreludeTyConUnique 80
969 genUnitTyConKey = mkPreludeTyConUnique 81
971 -- Parallel array type constructor
972 parrTyConKey :: Unique
973 parrTyConKey = mkPreludeTyConUnique 82
976 objectTyConKey :: Unique
977 objectTyConKey = mkPreludeTyConUnique 83
979 eitherTyConKey :: Unique
980 eitherTyConKey = mkPreludeTyConUnique 84
982 -- Super Kinds constructors
983 tySuperKindTyConKey, coSuperKindTyConKey :: Unique
984 tySuperKindTyConKey = mkPreludeTyConUnique 85
985 coSuperKindTyConKey = mkPreludeTyConUnique 86
988 liftedTypeKindTyConKey, openTypeKindTyConKey, unliftedTypeKindTyConKey,
989 ubxTupleKindTyConKey, argTypeKindTyConKey :: Unique
990 liftedTypeKindTyConKey = mkPreludeTyConUnique 87
991 openTypeKindTyConKey = mkPreludeTyConUnique 88
992 unliftedTypeKindTyConKey = mkPreludeTyConUnique 89
993 ubxTupleKindTyConKey = mkPreludeTyConUnique 90
994 argTypeKindTyConKey = mkPreludeTyConUnique 91
996 -- Coercion constructors
997 symCoercionTyConKey, transCoercionTyConKey, leftCoercionTyConKey,
998 rightCoercionTyConKey, instCoercionTyConKey, unsafeCoercionTyConKey
1000 symCoercionTyConKey = mkPreludeTyConUnique 93
1001 transCoercionTyConKey = mkPreludeTyConUnique 94
1002 leftCoercionTyConKey = mkPreludeTyConUnique 95
1003 rightCoercionTyConKey = mkPreludeTyConUnique 96
1004 instCoercionTyConKey = mkPreludeTyConUnique 97
1005 unsafeCoercionTyConKey = mkPreludeTyConUnique 98
1007 unknownTyConKey, unknown1TyConKey, unknown2TyConKey, unknown3TyConKey,
1008 opaqueTyConKey :: Unique
1009 unknownTyConKey = mkPreludeTyConUnique 99
1010 unknown1TyConKey = mkPreludeTyConUnique 130
1011 unknown2TyConKey = mkPreludeTyConUnique 131
1012 unknown3TyConKey = mkPreludeTyConUnique 132
1013 opaqueTyConKey = mkPreludeTyConUnique 133
1015 stringTyConKey :: Unique
1016 stringTyConKey = mkPreludeTyConUnique 134
1018 ---------------- Template Haskell -------------------
1019 -- USES TyConUniques 100-129
1020 -----------------------------------------------------
1022 unitTyConKey :: Unique
1023 unitTyConKey = mkTupleTyConUnique Boxed 0
1026 %************************************************************************
1028 \subsubsection[Uniques-prelude-DataCons]{@Uniques@ for wired-in @DataCons@}
1030 %************************************************************************
1033 charDataConKey, consDataConKey, doubleDataConKey, falseDataConKey,
1034 floatDataConKey, intDataConKey, nilDataConKey, ratioDataConKey,
1035 stableNameDataConKey, trueDataConKey, wordDataConKey,
1036 ioDataConKey :: Unique
1037 charDataConKey = mkPreludeDataConUnique 1
1038 consDataConKey = mkPreludeDataConUnique 2
1039 doubleDataConKey = mkPreludeDataConUnique 3
1040 falseDataConKey = mkPreludeDataConUnique 4
1041 floatDataConKey = mkPreludeDataConUnique 5
1042 intDataConKey = mkPreludeDataConUnique 6
1043 nilDataConKey = mkPreludeDataConUnique 11
1044 ratioDataConKey = mkPreludeDataConUnique 12
1045 stableNameDataConKey = mkPreludeDataConUnique 14
1046 trueDataConKey = mkPreludeDataConUnique 15
1047 wordDataConKey = mkPreludeDataConUnique 16
1048 ioDataConKey = mkPreludeDataConUnique 17
1050 -- Generic data constructors
1051 crossDataConKey, inlDataConKey, inrDataConKey, genUnitDataConKey :: Unique
1052 crossDataConKey = mkPreludeDataConUnique 20
1053 inlDataConKey = mkPreludeDataConUnique 21
1054 inrDataConKey = mkPreludeDataConUnique 22
1055 genUnitDataConKey = mkPreludeDataConUnique 23
1057 -- Data constructor for parallel arrays
1058 parrDataConKey :: Unique
1059 parrDataConKey = mkPreludeDataConUnique 24
1061 leftDataConKey, rightDataConKey :: Unique
1062 leftDataConKey = mkPreludeDataConUnique 25
1063 rightDataConKey = mkPreludeDataConUnique 26
1066 %************************************************************************
1068 \subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}
1070 %************************************************************************
1073 absentErrorIdKey, augmentIdKey, appendIdKey, buildIdKey, errorIdKey,
1074 foldlIdKey, foldrIdKey, recSelErrorIdKey,
1075 integerMinusOneIdKey, integerPlusOneIdKey,
1076 integerPlusTwoIdKey, integerZeroIdKey,
1077 int2IntegerIdKey, seqIdKey, irrefutPatErrorIdKey, eqStringIdKey,
1078 noMethodBindingErrorIdKey, nonExhaustiveGuardsErrorIdKey,
1079 runtimeErrorIdKey, parErrorIdKey, parIdKey, patErrorIdKey,
1080 realWorldPrimIdKey, recConErrorIdKey, recUpdErrorIdKey,
1082 unpackCStringUtf8IdKey, unpackCStringAppendIdKey,
1083 unpackCStringFoldrIdKey, unpackCStringIdKey :: Unique
1084 absentErrorIdKey = mkPreludeMiscIdUnique 1
1085 augmentIdKey = mkPreludeMiscIdUnique 3
1086 appendIdKey = mkPreludeMiscIdUnique 4
1087 buildIdKey = mkPreludeMiscIdUnique 5
1088 errorIdKey = mkPreludeMiscIdUnique 6
1089 foldlIdKey = mkPreludeMiscIdUnique 7
1090 foldrIdKey = mkPreludeMiscIdUnique 8
1091 recSelErrorIdKey = mkPreludeMiscIdUnique 9
1092 integerMinusOneIdKey = mkPreludeMiscIdUnique 10
1093 integerPlusOneIdKey = mkPreludeMiscIdUnique 11
1094 integerPlusTwoIdKey = mkPreludeMiscIdUnique 12
1095 integerZeroIdKey = mkPreludeMiscIdUnique 13
1096 int2IntegerIdKey = mkPreludeMiscIdUnique 14
1097 seqIdKey = mkPreludeMiscIdUnique 15
1098 irrefutPatErrorIdKey = mkPreludeMiscIdUnique 16
1099 eqStringIdKey = mkPreludeMiscIdUnique 17
1100 noMethodBindingErrorIdKey = mkPreludeMiscIdUnique 18
1101 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 19
1102 runtimeErrorIdKey = mkPreludeMiscIdUnique 20
1103 parErrorIdKey = mkPreludeMiscIdUnique 21
1104 parIdKey = mkPreludeMiscIdUnique 22
1105 patErrorIdKey = mkPreludeMiscIdUnique 23
1106 realWorldPrimIdKey = mkPreludeMiscIdUnique 24
1107 recConErrorIdKey = mkPreludeMiscIdUnique 25
1108 recUpdErrorIdKey = mkPreludeMiscIdUnique 26
1109 traceIdKey = mkPreludeMiscIdUnique 27
1110 unpackCStringUtf8IdKey = mkPreludeMiscIdUnique 28
1111 unpackCStringAppendIdKey = mkPreludeMiscIdUnique 29
1112 unpackCStringFoldrIdKey = mkPreludeMiscIdUnique 30
1113 unpackCStringIdKey = mkPreludeMiscIdUnique 31
1115 unsafeCoerceIdKey, concatIdKey, filterIdKey, zipIdKey, bindIOIdKey,
1116 returnIOIdKey, deRefStablePtrIdKey, newStablePtrIdKey,
1117 smallIntegerIdKey, plusIntegerIdKey, timesIntegerIdKey,
1118 printIdKey, failIOIdKey, nullAddrIdKey, voidArgIdKey,
1119 fstIdKey, sndIdKey, otherwiseIdKey, assertIdKey, runSTRepIdKey :: Unique
1120 unsafeCoerceIdKey = mkPreludeMiscIdUnique 32
1121 concatIdKey = mkPreludeMiscIdUnique 33
1122 filterIdKey = mkPreludeMiscIdUnique 34
1123 zipIdKey = mkPreludeMiscIdUnique 35
1124 bindIOIdKey = mkPreludeMiscIdUnique 36
1125 returnIOIdKey = mkPreludeMiscIdUnique 37
1126 deRefStablePtrIdKey = mkPreludeMiscIdUnique 38
1127 newStablePtrIdKey = mkPreludeMiscIdUnique 39
1128 smallIntegerIdKey = mkPreludeMiscIdUnique 40
1129 plusIntegerIdKey = mkPreludeMiscIdUnique 41
1130 timesIntegerIdKey = mkPreludeMiscIdUnique 42
1131 printIdKey = mkPreludeMiscIdUnique 43
1132 failIOIdKey = mkPreludeMiscIdUnique 44
1133 nullAddrIdKey = mkPreludeMiscIdUnique 46
1134 voidArgIdKey = mkPreludeMiscIdUnique 47
1135 fstIdKey = mkPreludeMiscIdUnique 49
1136 sndIdKey = mkPreludeMiscIdUnique 50
1137 otherwiseIdKey = mkPreludeMiscIdUnique 51
1138 assertIdKey = mkPreludeMiscIdUnique 53
1139 runSTRepIdKey = mkPreludeMiscIdUnique 54
1141 rootMainKey, runMainKey :: Unique
1142 rootMainKey = mkPreludeMiscIdUnique 55
1143 runMainKey = mkPreludeMiscIdUnique 56
1145 andIdKey, orIdKey, thenIOIdKey, lazyIdKey, assertErrorIdKey :: Unique
1146 andIdKey = mkPreludeMiscIdUnique 57
1147 orIdKey = mkPreludeMiscIdUnique 58
1148 thenIOIdKey = mkPreludeMiscIdUnique 59
1149 lazyIdKey = mkPreludeMiscIdUnique 60
1150 assertErrorIdKey = mkPreludeMiscIdUnique 61
1152 breakpointIdKey, breakpointCondIdKey, breakpointAutoIdKey,
1153 breakpointJumpIdKey, breakpointCondJumpIdKey,
1154 breakpointAutoJumpIdKey :: Unique
1155 breakpointIdKey = mkPreludeMiscIdUnique 62
1156 breakpointCondIdKey = mkPreludeMiscIdUnique 63
1157 breakpointAutoIdKey = mkPreludeMiscIdUnique 64
1158 breakpointJumpIdKey = mkPreludeMiscIdUnique 65
1159 breakpointCondJumpIdKey = mkPreludeMiscIdUnique 66
1160 breakpointAutoJumpIdKey = mkPreludeMiscIdUnique 67
1162 inlineIdKey :: Unique
1163 inlineIdKey = mkPreludeMiscIdUnique 68
1165 mapIdKey, groupWithIdKey :: Unique
1166 mapIdKey = mkPreludeMiscIdUnique 69
1167 groupWithIdKey = mkPreludeMiscIdUnique 70
1169 -- Parallel array functions
1170 singletonPIdKey, nullPIdKey, lengthPIdKey, replicatePIdKey, mapPIdKey,
1171 filterPIdKey, zipPIdKey, crossMapPIdKey, indexPIdKey, toPIdKey,
1172 enumFromToPIdKey, enumFromThenToPIdKey,
1173 bpermutePIdKey, bpermuteDftPIdKey, indexOfPIdKey :: Unique
1174 singletonPIdKey = mkPreludeMiscIdUnique 79
1175 nullPIdKey = mkPreludeMiscIdUnique 80
1176 lengthPIdKey = mkPreludeMiscIdUnique 81
1177 replicatePIdKey = mkPreludeMiscIdUnique 82
1178 mapPIdKey = mkPreludeMiscIdUnique 83
1179 filterPIdKey = mkPreludeMiscIdUnique 84
1180 zipPIdKey = mkPreludeMiscIdUnique 85
1181 crossMapPIdKey = mkPreludeMiscIdUnique 86
1182 indexPIdKey = mkPreludeMiscIdUnique 87
1183 toPIdKey = mkPreludeMiscIdUnique 88
1184 enumFromToPIdKey = mkPreludeMiscIdUnique 89
1185 enumFromThenToPIdKey = mkPreludeMiscIdUnique 90
1186 bpermutePIdKey = mkPreludeMiscIdUnique 91
1187 bpermuteDftPIdKey = mkPreludeMiscIdUnique 92
1188 indexOfPIdKey = mkPreludeMiscIdUnique 93
1191 unmarshalObjectIdKey, marshalObjectIdKey, marshalStringIdKey,
1192 unmarshalStringIdKey, checkDotnetResNameIdKey :: Unique
1193 unmarshalObjectIdKey = mkPreludeMiscIdUnique 94
1194 marshalObjectIdKey = mkPreludeMiscIdUnique 95
1195 marshalStringIdKey = mkPreludeMiscIdUnique 96
1196 unmarshalStringIdKey = mkPreludeMiscIdUnique 97
1197 checkDotnetResNameIdKey = mkPreludeMiscIdUnique 98
1201 Certain class operations from Prelude classes. They get their own
1202 uniques so we can look them up easily when we want to conjure them up
1203 during type checking.
1206 -- Just a place holder for unbound variables produced by the renamer:
1207 unboundKey :: Unique
1208 unboundKey = mkPreludeMiscIdUnique 101
1210 fromIntegerClassOpKey, minusClassOpKey, fromRationalClassOpKey,
1211 enumFromClassOpKey, enumFromThenClassOpKey, enumFromToClassOpKey,
1212 enumFromThenToClassOpKey, eqClassOpKey, geClassOpKey, negateClassOpKey,
1213 failMClassOpKey, bindMClassOpKey, thenMClassOpKey, returnMClassOpKey
1215 fromIntegerClassOpKey = mkPreludeMiscIdUnique 102
1216 minusClassOpKey = mkPreludeMiscIdUnique 103
1217 fromRationalClassOpKey = mkPreludeMiscIdUnique 104
1218 enumFromClassOpKey = mkPreludeMiscIdUnique 105
1219 enumFromThenClassOpKey = mkPreludeMiscIdUnique 106
1220 enumFromToClassOpKey = mkPreludeMiscIdUnique 107
1221 enumFromThenToClassOpKey = mkPreludeMiscIdUnique 108
1222 eqClassOpKey = mkPreludeMiscIdUnique 109
1223 geClassOpKey = mkPreludeMiscIdUnique 110
1224 negateClassOpKey = mkPreludeMiscIdUnique 111
1225 failMClassOpKey = mkPreludeMiscIdUnique 112
1226 bindMClassOpKey = mkPreludeMiscIdUnique 113 -- (>>=)
1227 thenMClassOpKey = mkPreludeMiscIdUnique 114 -- (>>)
1228 returnMClassOpKey = mkPreludeMiscIdUnique 117
1230 -- Recursive do notation
1232 mfixIdKey = mkPreludeMiscIdUnique 118
1235 arrAIdKey, composeAIdKey, firstAIdKey, appAIdKey, choiceAIdKey,
1236 loopAIdKey :: Unique
1237 arrAIdKey = mkPreludeMiscIdUnique 119
1238 composeAIdKey = mkPreludeMiscIdUnique 120 -- >>>
1239 firstAIdKey = mkPreludeMiscIdUnique 121
1240 appAIdKey = mkPreludeMiscIdUnique 122
1241 choiceAIdKey = mkPreludeMiscIdUnique 123 -- |||
1242 loopAIdKey = mkPreludeMiscIdUnique 124
1244 fromStringClassOpKey :: Unique
1245 fromStringClassOpKey = mkPreludeMiscIdUnique 125
1247 ---------------- Template Haskell -------------------
1248 -- USES IdUniques 200-399
1249 -----------------------------------------------------
1253 %************************************************************************
1255 \subsection{Standard groups of types}
1257 %************************************************************************
1260 numericTyKeys :: [Unique]
1271 %************************************************************************
1273 \subsection[Class-std-groups]{Standard groups of Prelude classes}
1275 %************************************************************************
1277 NOTE: @Eq@ and @Text@ do need to appear in @standardClasses@
1278 even though every numeric class has these two as a superclass,
1279 because the list of ambiguous dictionaries hasn't been simplified.
1282 numericClassKeys :: [Unique]
1288 ++ fractionalClassKeys
1290 fractionalClassKeys :: [Unique]
1291 fractionalClassKeys =
1292 [ fractionalClassKey
1298 -- the strictness analyser needs to know about numeric types
1299 -- (see SaAbsInt.lhs)
1300 needsDataDeclCtxtClassKeys :: [Unique]
1301 needsDataDeclCtxtClassKeys = -- see comments in TcDeriv
1305 -- The "standard classes" are used in defaulting (Haskell 98 report 4.3.4),
1306 -- and are: "classes defined in the Prelude or a standard library"
1307 standardClassKeys :: [Unique]
1308 standardClassKeys = derivableClassKeys ++ numericClassKeys
1309 ++ [randomClassKey, randomGenClassKey,
1311 monadClassKey, monadPlusClassKey,
1316 @derivableClassKeys@ is also used in checking \tr{deriving} constructs
1320 derivableClassKeys :: [Unique]
1322 = [ eqClassKey, ordClassKey, enumClassKey, ixClassKey,
1323 boundedClassKey, showClassKey, readClassKey ]