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, emptyPName, appPName,
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_TYPES, gHC_BOOL, gHC_UNIT, gHC_ORDERING, gHC_GENERICS, gHC_CLASSES, gHC_BASE, gHC_ENUM,
235 gHC_SHOW, gHC_READ, gHC_NUM, gHC_INTEGER, gHC_INTEGER_INTERNALS, gHC_LIST, gHC_PARR,
236 gHC_TUPLE, dATA_TUPLE, 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, cONTROL_EXCEPTION_BASE :: Module
241 gHC_PRIM = mkPrimModule (fsLit "GHC.Prim") -- Primitive types and values
242 gHC_TYPES = mkPrimModule (fsLit "GHC.Types")
243 gHC_UNIT = mkPrimModule (fsLit "GHC.Unit")
244 gHC_BOOL = mkPrimModule (fsLit "GHC.Bool")
245 gHC_ORDERING = mkPrimModule (fsLit "GHC.Ordering")
246 gHC_GENERICS = mkPrimModule (fsLit "GHC.Generics")
247 gHC_CLASSES = mkBaseModule (fsLit "GHC.Classes")
248 gHC_BASE = mkBaseModule (fsLit "GHC.Base")
249 gHC_ENUM = mkBaseModule (fsLit "GHC.Enum")
250 gHC_SHOW = mkBaseModule (fsLit "GHC.Show")
251 gHC_READ = mkBaseModule (fsLit "GHC.Read")
252 gHC_NUM = mkBaseModule (fsLit "GHC.Num")
253 gHC_INTEGER = mkIntegerModule (fsLit "GHC.Integer")
254 gHC_INTEGER_INTERNALS = mkIntegerModule (fsLit "GHC.Integer.Internals")
255 gHC_LIST = mkBaseModule (fsLit "GHC.List")
256 gHC_PARR = mkBaseModule (fsLit "GHC.PArr")
257 gHC_TUPLE = mkPrimModule (fsLit "GHC.Tuple")
258 dATA_TUPLE = mkBaseModule (fsLit "Data.Tuple")
259 dATA_EITHER = mkBaseModule (fsLit "Data.Either")
260 dATA_STRING = mkBaseModule (fsLit "Data.String")
261 gHC_PACK = mkBaseModule (fsLit "GHC.Pack")
262 gHC_CONC = mkBaseModule (fsLit "GHC.Conc")
263 gHC_IO_BASE = mkBaseModule (fsLit "GHC.IOBase")
264 gHC_ST = mkBaseModule (fsLit "GHC.ST")
265 gHC_ARR = mkBaseModule (fsLit "GHC.Arr")
266 gHC_STABLE = mkBaseModule (fsLit "GHC.Stable")
267 gHC_ADDR = mkBaseModule (fsLit "GHC.Addr")
268 gHC_PTR = mkBaseModule (fsLit "GHC.Ptr")
269 gHC_ERR = mkBaseModule (fsLit "GHC.Err")
270 gHC_REAL = mkBaseModule (fsLit "GHC.Real")
271 gHC_FLOAT = mkBaseModule (fsLit "GHC.Float")
272 gHC_TOP_HANDLER = mkBaseModule (fsLit "GHC.TopHandler")
273 sYSTEM_IO = mkBaseModule (fsLit "System.IO")
274 dYNAMIC = mkBaseModule (fsLit "Data.Dynamic")
275 tYPEABLE = mkBaseModule (fsLit "Data.Typeable")
276 gENERICS = mkSybModule (fsLit "Data.Generics.Basics")
277 dOTNET = mkBaseModule (fsLit "GHC.Dotnet")
278 rEAD_PREC = mkBaseModule (fsLit "Text.ParserCombinators.ReadPrec")
279 lEX = mkBaseModule (fsLit "Text.Read.Lex")
280 gHC_INT = mkBaseModule (fsLit "GHC.Int")
281 gHC_WORD = mkBaseModule (fsLit "GHC.Word")
282 mONAD = mkBaseModule (fsLit "Control.Monad")
283 mONAD_FIX = mkBaseModule (fsLit "Control.Monad.Fix")
284 aRROW = mkBaseModule (fsLit "Control.Arrow")
285 gHC_DESUGAR = mkBaseModule (fsLit "GHC.Desugar")
286 rANDOM = mkBaseModule (fsLit "System.Random")
287 gHC_EXTS = mkBaseModule (fsLit "GHC.Exts")
288 cONTROL_EXCEPTION_BASE = mkBaseModule (fsLit "Control.Exception.Base")
290 mAIN, rOOT_MAIN :: Module
291 mAIN = mkMainModule_ mAIN_NAME
292 rOOT_MAIN = mkMainModule (fsLit ":Main") -- Root module for initialisation
294 -- The ':xxx' makes a module name that the user can never
295 -- use himself. The z-encoding for ':' is "ZC", so the z-encoded
296 -- module name still starts with a capital letter, which keeps
297 -- the z-encoded version consistent.
298 iNTERACTIVE, thFAKE :: Module
299 iNTERACTIVE = mkMainModule (fsLit ":Interactive")
300 thFAKE = mkMainModule (fsLit ":THFake")
302 pRELUDE_NAME, mAIN_NAME :: ModuleName
303 pRELUDE_NAME = mkModuleNameFS (fsLit "Prelude")
304 mAIN_NAME = mkModuleNameFS (fsLit "Main")
306 mkPrimModule :: FastString -> Module
307 mkPrimModule m = mkModule primPackageId (mkModuleNameFS m)
309 mkIntegerModule :: FastString -> Module
310 mkIntegerModule m = mkModule integerPackageId (mkModuleNameFS m)
312 mkBaseModule :: FastString -> Module
313 mkBaseModule m = mkModule basePackageId (mkModuleNameFS m)
315 mkBaseModule_ :: ModuleName -> Module
316 mkBaseModule_ m = mkModule basePackageId m
318 mkSybModule :: FastString -> Module
319 mkSybModule m = mkModule sybPackageId (mkModuleNameFS m)
321 mkMainModule :: FastString -> Module
322 mkMainModule m = mkModule mainPackageId (mkModuleNameFS m)
324 mkMainModule_ :: ModuleName -> Module
325 mkMainModule_ m = mkModule mainPackageId m
328 %************************************************************************
330 \subsection{Constructing the names of tuples
332 %************************************************************************
335 mkTupleModule :: Boxity -> Arity -> Module
336 mkTupleModule Boxed 0 = gHC_UNIT
337 mkTupleModule Boxed _ = gHC_TUPLE
338 mkTupleModule Unboxed _ = gHC_PRIM
342 %************************************************************************
346 %************************************************************************
349 main_RDR_Unqual :: RdrName
350 main_RDR_Unqual = mkUnqual varName (fsLit "main")
351 -- We definitely don't want an Orig RdrName, because
352 -- main might, in principle, be imported into module Main
354 forall_tv_RDR, dot_tv_RDR :: RdrName
355 forall_tv_RDR = mkUnqual tvName (fsLit "forall")
356 dot_tv_RDR = mkUnqual tvName (fsLit ".")
358 eq_RDR, ge_RDR, ne_RDR, le_RDR, lt_RDR, gt_RDR, compare_RDR,
359 ltTag_RDR, eqTag_RDR, gtTag_RDR :: RdrName
360 eq_RDR = nameRdrName eqName
361 ge_RDR = nameRdrName geName
362 ne_RDR = varQual_RDR gHC_CLASSES (fsLit "/=")
363 le_RDR = varQual_RDR gHC_CLASSES (fsLit "<=")
364 lt_RDR = varQual_RDR gHC_CLASSES (fsLit "<")
365 gt_RDR = varQual_RDR gHC_CLASSES (fsLit ">")
366 compare_RDR = varQual_RDR gHC_CLASSES (fsLit "compare")
367 ltTag_RDR = dataQual_RDR gHC_ORDERING (fsLit "LT")
368 eqTag_RDR = dataQual_RDR gHC_ORDERING (fsLit "EQ")
369 gtTag_RDR = dataQual_RDR gHC_ORDERING (fsLit "GT")
371 eqClass_RDR, numClass_RDR, ordClass_RDR, enumClass_RDR, monadClass_RDR
373 eqClass_RDR = nameRdrName eqClassName
374 numClass_RDR = nameRdrName numClassName
375 ordClass_RDR = nameRdrName ordClassName
376 enumClass_RDR = nameRdrName enumClassName
377 monadClass_RDR = nameRdrName monadClassName
379 map_RDR, append_RDR :: RdrName
380 map_RDR = varQual_RDR gHC_BASE (fsLit "map")
381 append_RDR = varQual_RDR gHC_BASE (fsLit "++")
383 foldr_RDR, build_RDR, returnM_RDR, bindM_RDR, failM_RDR :: RdrName
384 foldr_RDR = nameRdrName foldrName
385 build_RDR = nameRdrName buildName
386 returnM_RDR = nameRdrName returnMName
387 bindM_RDR = nameRdrName bindMName
388 failM_RDR = nameRdrName failMName
391 and_RDR = nameRdrName andName
393 left_RDR, right_RDR :: RdrName
394 left_RDR = nameRdrName leftDataConName
395 right_RDR = nameRdrName rightDataConName
397 fromEnum_RDR, toEnum_RDR :: RdrName
398 fromEnum_RDR = varQual_RDR gHC_ENUM (fsLit "fromEnum")
399 toEnum_RDR = varQual_RDR gHC_ENUM (fsLit "toEnum")
401 enumFrom_RDR, enumFromTo_RDR, enumFromThen_RDR, enumFromThenTo_RDR :: RdrName
402 enumFrom_RDR = nameRdrName enumFromName
403 enumFromTo_RDR = nameRdrName enumFromToName
404 enumFromThen_RDR = nameRdrName enumFromThenName
405 enumFromThenTo_RDR = nameRdrName enumFromThenToName
407 ratioDataCon_RDR, plusInteger_RDR, timesInteger_RDR :: RdrName
408 ratioDataCon_RDR = nameRdrName ratioDataConName
409 plusInteger_RDR = nameRdrName plusIntegerName
410 timesInteger_RDR = nameRdrName timesIntegerName
412 ioDataCon_RDR :: RdrName
413 ioDataCon_RDR = nameRdrName ioDataConName
415 eqString_RDR, unpackCString_RDR, unpackCStringFoldr_RDR,
416 unpackCStringUtf8_RDR :: RdrName
417 eqString_RDR = nameRdrName eqStringName
418 unpackCString_RDR = nameRdrName unpackCStringName
419 unpackCStringFoldr_RDR = nameRdrName unpackCStringFoldrName
420 unpackCStringUtf8_RDR = nameRdrName unpackCStringUtf8Name
422 newStablePtr_RDR, wordDataCon_RDR :: RdrName
423 newStablePtr_RDR = nameRdrName newStablePtrName
424 wordDataCon_RDR = dataQual_RDR gHC_WORD (fsLit "W#")
426 bindIO_RDR, returnIO_RDR :: RdrName
427 bindIO_RDR = nameRdrName bindIOName
428 returnIO_RDR = nameRdrName returnIOName
430 fromInteger_RDR, fromRational_RDR, minus_RDR, times_RDR, plus_RDR :: RdrName
431 fromInteger_RDR = nameRdrName fromIntegerName
432 fromRational_RDR = nameRdrName fromRationalName
433 minus_RDR = nameRdrName minusName
434 times_RDR = varQual_RDR gHC_NUM (fsLit "*")
435 plus_RDR = varQual_RDR gHC_NUM (fsLit "+")
437 fromString_RDR :: RdrName
438 fromString_RDR = nameRdrName fromStringName
440 compose_RDR :: RdrName
441 compose_RDR = varQual_RDR gHC_BASE (fsLit ".")
443 not_RDR, getTag_RDR, succ_RDR, pred_RDR, minBound_RDR, maxBound_RDR,
444 range_RDR, inRange_RDR, index_RDR,
445 unsafeIndex_RDR, unsafeRangeSize_RDR :: RdrName
446 not_RDR = varQual_RDR gHC_CLASSES (fsLit "not")
447 getTag_RDR = varQual_RDR gHC_BASE (fsLit "getTag")
448 succ_RDR = varQual_RDR gHC_ENUM (fsLit "succ")
449 pred_RDR = varQual_RDR gHC_ENUM (fsLit "pred")
450 minBound_RDR = varQual_RDR gHC_ENUM (fsLit "minBound")
451 maxBound_RDR = varQual_RDR gHC_ENUM (fsLit "maxBound")
452 range_RDR = varQual_RDR gHC_ARR (fsLit "range")
453 inRange_RDR = varQual_RDR gHC_ARR (fsLit "inRange")
454 index_RDR = varQual_RDR gHC_ARR (fsLit "index")
455 unsafeIndex_RDR = varQual_RDR gHC_ARR (fsLit "unsafeIndex")
456 unsafeRangeSize_RDR = varQual_RDR gHC_ARR (fsLit "unsafeRangeSize")
458 readList_RDR, readListDefault_RDR, readListPrec_RDR, readListPrecDefault_RDR,
459 readPrec_RDR, parens_RDR, choose_RDR, lexP_RDR :: RdrName
460 readList_RDR = varQual_RDR gHC_READ (fsLit "readList")
461 readListDefault_RDR = varQual_RDR gHC_READ (fsLit "readListDefault")
462 readListPrec_RDR = varQual_RDR gHC_READ (fsLit "readListPrec")
463 readListPrecDefault_RDR = varQual_RDR gHC_READ (fsLit "readListPrecDefault")
464 readPrec_RDR = varQual_RDR gHC_READ (fsLit "readPrec")
465 parens_RDR = varQual_RDR gHC_READ (fsLit "parens")
466 choose_RDR = varQual_RDR gHC_READ (fsLit "choose")
467 lexP_RDR = varQual_RDR gHC_READ (fsLit "lexP")
469 punc_RDR, ident_RDR, symbol_RDR :: RdrName
470 punc_RDR = dataQual_RDR lEX (fsLit "Punc")
471 ident_RDR = dataQual_RDR lEX (fsLit "Ident")
472 symbol_RDR = dataQual_RDR lEX (fsLit "Symbol")
474 step_RDR, alt_RDR, reset_RDR, prec_RDR :: RdrName
475 step_RDR = varQual_RDR rEAD_PREC (fsLit "step")
476 alt_RDR = varQual_RDR rEAD_PREC (fsLit "+++")
477 reset_RDR = varQual_RDR rEAD_PREC (fsLit "reset")
478 prec_RDR = varQual_RDR rEAD_PREC (fsLit "prec")
480 showList_RDR, showList___RDR, showsPrec_RDR, showString_RDR,
481 showSpace_RDR, showParen_RDR :: RdrName
482 showList_RDR = varQual_RDR gHC_SHOW (fsLit "showList")
483 showList___RDR = varQual_RDR gHC_SHOW (fsLit "showList__")
484 showsPrec_RDR = varQual_RDR gHC_SHOW (fsLit "showsPrec")
485 showString_RDR = varQual_RDR gHC_SHOW (fsLit "showString")
486 showSpace_RDR = varQual_RDR gHC_SHOW (fsLit "showSpace")
487 showParen_RDR = varQual_RDR gHC_SHOW (fsLit "showParen")
489 typeOf_RDR, mkTypeRep_RDR, mkTyConRep_RDR :: RdrName
490 typeOf_RDR = varQual_RDR tYPEABLE (fsLit "typeOf")
491 mkTypeRep_RDR = varQual_RDR tYPEABLE (fsLit "mkTyConApp")
492 mkTyConRep_RDR = varQual_RDR tYPEABLE (fsLit "mkTyCon")
494 undefined_RDR :: RdrName
495 undefined_RDR = varQual_RDR gHC_ERR (fsLit "undefined")
497 crossDataCon_RDR, inlDataCon_RDR, inrDataCon_RDR, genUnitDataCon_RDR :: RdrName
498 crossDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit ":*:")
499 inlDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Inl")
500 inrDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Inr")
501 genUnitDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Unit")
503 ----------------------
504 varQual_RDR, tcQual_RDR, clsQual_RDR, dataQual_RDR
505 :: Module -> FastString -> RdrName
506 varQual_RDR mod str = mkOrig mod (mkOccNameFS varName str)
507 tcQual_RDR mod str = mkOrig mod (mkOccNameFS tcName str)
508 clsQual_RDR mod str = mkOrig mod (mkOccNameFS clsName str)
509 dataQual_RDR mod str = mkOrig mod (mkOccNameFS dataName str)
512 %************************************************************************
514 \subsection{Known-key names}
516 %************************************************************************
518 Many of these Names are not really "built in", but some parts of the
519 compiler (notably the deriving mechanism) need to mention their names,
520 and it's convenient to write them all down in one place.
522 --MetaHaskell Extension add the constrs and the lower case case
523 -- guys as well (perhaps) e.g. see trueDataConName below
527 runMainIOName :: Name
528 runMainIOName = varQual gHC_TOP_HANDLER (fsLit "runMainIO") runMainKey
530 orderingTyConName :: Name
531 orderingTyConName = tcQual gHC_ORDERING (fsLit "Ordering") orderingTyConKey
533 eitherTyConName, leftDataConName, rightDataConName :: Name
534 eitherTyConName = tcQual dATA_EITHER (fsLit "Either") eitherTyConKey
535 leftDataConName = conName dATA_EITHER (fsLit "Left") leftDataConKey
536 rightDataConName = conName dATA_EITHER (fsLit "Right") rightDataConKey
539 crossTyConName, plusTyConName, genUnitTyConName :: Name
540 crossTyConName = tcQual gHC_GENERICS (fsLit ":*:") crossTyConKey
541 plusTyConName = tcQual gHC_GENERICS (fsLit ":+:") plusTyConKey
542 genUnitTyConName = tcQual gHC_GENERICS (fsLit "Unit") genUnitTyConKey
544 -- Base strings Strings
545 unpackCStringName, unpackCStringAppendName, unpackCStringFoldrName,
546 unpackCStringUtf8Name, eqStringName, stringTyConName :: Name
547 unpackCStringName = varQual gHC_BASE (fsLit "unpackCString#") unpackCStringIdKey
548 unpackCStringAppendName = varQual gHC_BASE (fsLit "unpackAppendCString#") unpackCStringAppendIdKey
549 unpackCStringFoldrName = varQual gHC_BASE (fsLit "unpackFoldrCString#") unpackCStringFoldrIdKey
550 unpackCStringUtf8Name = varQual gHC_BASE (fsLit "unpackCStringUtf8#") unpackCStringUtf8IdKey
551 eqStringName = varQual gHC_BASE (fsLit "eqString") eqStringIdKey
552 stringTyConName = tcQual gHC_BASE (fsLit "String") stringTyConKey
554 -- The 'inline' function
556 inlineIdName = varQual gHC_BASE (fsLit "inline") inlineIdKey
558 -- Base classes (Eq, Ord, Functor)
559 eqClassName, eqName, ordClassName, geName, functorClassName :: Name
560 eqClassName = clsQual gHC_CLASSES (fsLit "Eq") eqClassKey
561 eqName = methName gHC_CLASSES (fsLit "==") eqClassOpKey
562 ordClassName = clsQual gHC_CLASSES (fsLit "Ord") ordClassKey
563 geName = methName gHC_CLASSES (fsLit ">=") geClassOpKey
564 functorClassName = clsQual gHC_BASE (fsLit "Functor") functorClassKey
567 monadClassName, thenMName, bindMName, returnMName, failMName :: Name
568 monadClassName = clsQual gHC_BASE (fsLit "Monad") monadClassKey
569 thenMName = methName gHC_BASE (fsLit ">>") thenMClassOpKey
570 bindMName = methName gHC_BASE (fsLit ">>=") bindMClassOpKey
571 returnMName = methName gHC_BASE (fsLit "return") returnMClassOpKey
572 failMName = methName gHC_BASE (fsLit "fail") failMClassOpKey
574 -- Functions for GHC extensions
575 groupWithName :: Name
576 groupWithName = varQual gHC_EXTS (fsLit "groupWith") groupWithIdKey
578 -- Random PrelBase functions
579 fromStringName, otherwiseIdName, foldrName, buildName, augmentName,
580 mapName, appendName, andName, orName, assertName,
581 breakpointName, breakpointCondName, breakpointAutoName,
582 opaqueTyConName :: Name
583 fromStringName = methName dATA_STRING (fsLit "fromString") fromStringClassOpKey
584 otherwiseIdName = varQual gHC_BASE (fsLit "otherwise") otherwiseIdKey
585 foldrName = varQual gHC_BASE (fsLit "foldr") foldrIdKey
586 buildName = varQual gHC_BASE (fsLit "build") buildIdKey
587 augmentName = varQual gHC_BASE (fsLit "augment") augmentIdKey
588 mapName = varQual gHC_BASE (fsLit "map") mapIdKey
589 appendName = varQual gHC_BASE (fsLit "++") appendIdKey
590 andName = varQual gHC_CLASSES (fsLit "&&") andIdKey
591 orName = varQual gHC_CLASSES (fsLit "||") orIdKey
592 assertName = varQual gHC_BASE (fsLit "assert") assertIdKey
593 breakpointName = varQual gHC_BASE (fsLit "breakpoint") breakpointIdKey
594 breakpointCondName= varQual gHC_BASE (fsLit "breakpointCond") breakpointCondIdKey
595 breakpointAutoName= varQual gHC_BASE (fsLit "breakpointAuto") breakpointAutoIdKey
596 opaqueTyConName = tcQual gHC_BASE (fsLit "Opaque") opaqueTyConKey
598 breakpointJumpName :: Name
602 (mkOccNameFS varName (fsLit "breakpointJump"))
604 breakpointCondJumpName :: Name
605 breakpointCondJumpName
607 breakpointCondJumpIdKey
608 (mkOccNameFS varName (fsLit "breakpointCondJump"))
610 breakpointAutoJumpName :: Name
611 breakpointAutoJumpName
613 breakpointAutoJumpIdKey
614 (mkOccNameFS varName (fsLit "breakpointAutoJump"))
618 fstName, sndName :: Name
619 fstName = varQual dATA_TUPLE (fsLit "fst") fstIdKey
620 sndName = varQual dATA_TUPLE (fsLit "snd") sndIdKey
623 numClassName, fromIntegerName, minusName, negateName, plusIntegerName,
624 timesIntegerName, integerTyConName, smallIntegerName :: Name
625 numClassName = clsQual gHC_NUM (fsLit "Num") numClassKey
626 fromIntegerName = methName gHC_NUM (fsLit "fromInteger") fromIntegerClassOpKey
627 minusName = methName gHC_NUM (fsLit "-") minusClassOpKey
628 negateName = methName gHC_NUM (fsLit "negate") negateClassOpKey
629 plusIntegerName = varQual gHC_INTEGER (fsLit "plusInteger") plusIntegerIdKey
630 timesIntegerName = varQual gHC_INTEGER (fsLit "timesInteger") timesIntegerIdKey
631 integerTyConName = tcQual gHC_INTEGER_INTERNALS (fsLit "Integer") integerTyConKey
632 smallIntegerName = varQual gHC_INTEGER (fsLit "smallInteger") smallIntegerIdKey
634 -- PrelReal types and classes
635 rationalTyConName, ratioTyConName, ratioDataConName, realClassName,
636 integralClassName, realFracClassName, fractionalClassName,
637 fromRationalName :: Name
638 rationalTyConName = tcQual gHC_REAL (fsLit "Rational") rationalTyConKey
639 ratioTyConName = tcQual gHC_REAL (fsLit "Ratio") ratioTyConKey
640 ratioDataConName = conName gHC_REAL (fsLit ":%") ratioDataConKey
641 realClassName = clsQual gHC_REAL (fsLit "Real") realClassKey
642 integralClassName = clsQual gHC_REAL (fsLit "Integral") integralClassKey
643 realFracClassName = clsQual gHC_REAL (fsLit "RealFrac") realFracClassKey
644 fractionalClassName = clsQual gHC_REAL (fsLit "Fractional") fractionalClassKey
645 fromRationalName = methName gHC_REAL (fsLit "fromRational") fromRationalClassOpKey
648 floatingClassName, realFloatClassName :: Name
649 floatingClassName = clsQual gHC_FLOAT (fsLit "Floating") floatingClassKey
650 realFloatClassName = clsQual gHC_FLOAT (fsLit "RealFloat") realFloatClassKey
654 ixClassName = clsQual gHC_ARR (fsLit "Ix") ixClassKey
657 typeableClassName, typeable1ClassName, typeable2ClassName,
658 typeable3ClassName, typeable4ClassName, typeable5ClassName,
659 typeable6ClassName, typeable7ClassName :: Name
660 typeableClassName = clsQual tYPEABLE (fsLit "Typeable") typeableClassKey
661 typeable1ClassName = clsQual tYPEABLE (fsLit "Typeable1") typeable1ClassKey
662 typeable2ClassName = clsQual tYPEABLE (fsLit "Typeable2") typeable2ClassKey
663 typeable3ClassName = clsQual tYPEABLE (fsLit "Typeable3") typeable3ClassKey
664 typeable4ClassName = clsQual tYPEABLE (fsLit "Typeable4") typeable4ClassKey
665 typeable5ClassName = clsQual tYPEABLE (fsLit "Typeable5") typeable5ClassKey
666 typeable6ClassName = clsQual tYPEABLE (fsLit "Typeable6") typeable6ClassKey
667 typeable7ClassName = clsQual tYPEABLE (fsLit "Typeable7") typeable7ClassKey
669 typeableClassNames :: [Name]
670 typeableClassNames = [ typeableClassName, typeable1ClassName, typeable2ClassName
671 , typeable3ClassName, typeable4ClassName, typeable5ClassName
672 , typeable6ClassName, typeable7ClassName ]
675 dataClassName :: Name
676 dataClassName = clsQual gENERICS (fsLit "Data") dataClassKey
679 assertErrorName :: Name
680 assertErrorName = varQual gHC_IO_BASE (fsLit "assertError") assertErrorIdKey
682 -- Enum module (Enum, Bounded)
683 enumClassName, enumFromName, enumFromToName, enumFromThenName,
684 enumFromThenToName, boundedClassName :: Name
685 enumClassName = clsQual gHC_ENUM (fsLit "Enum") enumClassKey
686 enumFromName = methName gHC_ENUM (fsLit "enumFrom") enumFromClassOpKey
687 enumFromToName = methName gHC_ENUM (fsLit "enumFromTo") enumFromToClassOpKey
688 enumFromThenName = methName gHC_ENUM (fsLit "enumFromThen") enumFromThenClassOpKey
689 enumFromThenToName = methName gHC_ENUM (fsLit "enumFromThenTo") enumFromThenToClassOpKey
690 boundedClassName = clsQual gHC_ENUM (fsLit "Bounded") boundedClassKey
693 concatName, filterName, zipName :: Name
694 concatName = varQual gHC_LIST (fsLit "concat") concatIdKey
695 filterName = varQual gHC_LIST (fsLit "filter") filterIdKey
696 zipName = varQual gHC_LIST (fsLit "zip") zipIdKey
699 showClassName :: Name
700 showClassName = clsQual gHC_SHOW (fsLit "Show") showClassKey
703 readClassName :: Name
704 readClassName = clsQual gHC_READ (fsLit "Read") readClassKey
706 -- parallel array types and functions
707 enumFromToPName, enumFromThenToPName, nullPName, lengthPName,
708 singletonPName, replicatePName, mapPName, filterPName,
709 zipPName, crossMapPName, indexPName, toPName,
710 emptyPName, appPName :: Name
711 enumFromToPName = varQual gHC_PARR (fsLit "enumFromToP") enumFromToPIdKey
712 enumFromThenToPName= varQual gHC_PARR (fsLit "enumFromThenToP") enumFromThenToPIdKey
713 nullPName = varQual gHC_PARR (fsLit "nullP") nullPIdKey
714 lengthPName = varQual gHC_PARR (fsLit "lengthP") lengthPIdKey
715 singletonPName = varQual gHC_PARR (fsLit "singletonP") singletonPIdKey
716 replicatePName = varQual gHC_PARR (fsLit "replicateP") replicatePIdKey
717 mapPName = varQual gHC_PARR (fsLit "mapP") mapPIdKey
718 filterPName = varQual gHC_PARR (fsLit "filterP") filterPIdKey
719 zipPName = varQual gHC_PARR (fsLit "zipP") zipPIdKey
720 crossMapPName = varQual gHC_PARR (fsLit "crossMapP") crossMapPIdKey
721 indexPName = varQual gHC_PARR (fsLit "!:") indexPIdKey
722 toPName = varQual gHC_PARR (fsLit "toP") toPIdKey
723 emptyPName = varQual gHC_PARR (fsLit "emptyP") emptyPIdKey
724 appPName = varQual gHC_PARR (fsLit "+:+") appPIdKey
727 ioTyConName, ioDataConName, thenIOName, bindIOName, returnIOName,
729 ioTyConName = tcQual gHC_IO_BASE (fsLit "IO") ioTyConKey
730 ioDataConName = conName gHC_IO_BASE (fsLit "IO") ioDataConKey
731 thenIOName = varQual gHC_IO_BASE (fsLit "thenIO") thenIOIdKey
732 bindIOName = varQual gHC_IO_BASE (fsLit "bindIO") bindIOIdKey
733 returnIOName = varQual gHC_IO_BASE (fsLit "returnIO") returnIOIdKey
734 failIOName = varQual gHC_IO_BASE (fsLit "failIO") failIOIdKey
738 printName = varQual sYSTEM_IO (fsLit "print") printIdKey
740 -- Int, Word, and Addr things
741 int8TyConName, int16TyConName, int32TyConName, int64TyConName :: Name
742 int8TyConName = tcQual gHC_INT (fsLit "Int8") int8TyConKey
743 int16TyConName = tcQual gHC_INT (fsLit "Int16") int16TyConKey
744 int32TyConName = tcQual gHC_INT (fsLit "Int32") int32TyConKey
745 int64TyConName = tcQual gHC_INT (fsLit "Int64") int64TyConKey
748 word8TyConName, word16TyConName, word32TyConName, word64TyConName,
749 wordTyConName, wordDataConName :: Name
750 word8TyConName = tcQual gHC_WORD (fsLit "Word8") word8TyConKey
751 word16TyConName = tcQual gHC_WORD (fsLit "Word16") word16TyConKey
752 word32TyConName = tcQual gHC_WORD (fsLit "Word32") word32TyConKey
753 word64TyConName = tcQual gHC_WORD (fsLit "Word64") word64TyConKey
754 wordTyConName = tcQual gHC_WORD (fsLit "Word") wordTyConKey
755 wordDataConName = conName gHC_WORD (fsLit "W#") wordDataConKey
758 ptrTyConName, funPtrTyConName :: Name
759 ptrTyConName = tcQual gHC_PTR (fsLit "Ptr") ptrTyConKey
760 funPtrTyConName = tcQual gHC_PTR (fsLit "FunPtr") funPtrTyConKey
762 -- Foreign objects and weak pointers
763 stablePtrTyConName, newStablePtrName :: Name
764 stablePtrTyConName = tcQual gHC_STABLE (fsLit "StablePtr") stablePtrTyConKey
765 newStablePtrName = varQual gHC_STABLE (fsLit "newStablePtr") newStablePtrIdKey
769 runSTRepName = varQual gHC_ST (fsLit "runSTRep") runSTRepIdKey
771 -- Recursive-do notation
772 monadFixClassName, mfixName :: Name
773 monadFixClassName = clsQual mONAD_FIX (fsLit "MonadFix") monadFixClassKey
774 mfixName = methName mONAD_FIX (fsLit "mfix") mfixIdKey
777 arrAName, composeAName, firstAName, appAName, choiceAName, loopAName :: Name
778 arrAName = varQual aRROW (fsLit "arr") arrAIdKey
779 composeAName = varQual gHC_DESUGAR (fsLit ">>>") composeAIdKey
780 firstAName = varQual aRROW (fsLit "first") firstAIdKey
781 appAName = varQual aRROW (fsLit "app") appAIdKey
782 choiceAName = varQual aRROW (fsLit "|||") choiceAIdKey
783 loopAName = varQual aRROW (fsLit "loop") loopAIdKey
785 -- Other classes, needed for type defaulting
786 monadPlusClassName, randomClassName, randomGenClassName,
787 isStringClassName :: Name
788 monadPlusClassName = clsQual mONAD (fsLit "MonadPlus") monadPlusClassKey
789 randomClassName = clsQual rANDOM (fsLit "Random") randomClassKey
790 randomGenClassName = clsQual rANDOM (fsLit "RandomGen") randomGenClassKey
791 isStringClassName = clsQual dATA_STRING (fsLit "IsString") isStringClassKey
794 objectTyConName :: Name
795 objectTyConName = tcQual dOTNET (fsLit "Object") objectTyConKey
796 -- objectTyConName was "wTcQual", but that's gone now, and
797 -- I can't see why it was wired in anyway...
798 unmarshalObjectName, marshalObjectName, marshalStringName,
799 unmarshalStringName, checkDotnetResName :: Name
800 unmarshalObjectName = varQual dOTNET (fsLit "unmarshalObject") unmarshalObjectIdKey
801 marshalObjectName = varQual dOTNET (fsLit "marshalObject") marshalObjectIdKey
802 marshalStringName = varQual dOTNET (fsLit "marshalString") marshalStringIdKey
803 unmarshalStringName = varQual dOTNET (fsLit "unmarshalString") unmarshalStringIdKey
804 checkDotnetResName = varQual dOTNET (fsLit "checkResult") checkDotnetResNameIdKey
807 %************************************************************************
809 \subsection{Local helpers}
811 %************************************************************************
813 All these are original names; hence mkOrig
816 varQual, tcQual, clsQual :: Module -> FastString -> Unique -> Name
817 varQual = mk_known_key_name varName
818 tcQual = mk_known_key_name tcName
819 clsQual = mk_known_key_name clsName
821 mk_known_key_name :: NameSpace -> Module -> FastString -> Unique -> Name
822 mk_known_key_name space modu str unique
823 = mkExternalName unique modu (mkOccNameFS space str) noSrcSpan
825 conName :: Module -> FastString -> Unique -> Name
826 conName modu occ unique
827 = mkExternalName unique modu (mkOccNameFS dataName occ) noSrcSpan
829 methName :: Module -> FastString -> Unique -> Name
830 methName modu occ unique
831 = mkExternalName unique modu (mkVarOccFS occ) noSrcSpan
834 %************************************************************************
836 \subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@}
838 %************************************************************************
839 --MetaHaskell extension hand allocate keys here
842 boundedClassKey, enumClassKey, eqClassKey, floatingClassKey,
843 fractionalClassKey, integralClassKey, monadClassKey, dataClassKey,
844 functorClassKey, numClassKey, ordClassKey, readClassKey, realClassKey,
845 realFloatClassKey, realFracClassKey, showClassKey, ixClassKey :: Unique
846 boundedClassKey = mkPreludeClassUnique 1
847 enumClassKey = mkPreludeClassUnique 2
848 eqClassKey = mkPreludeClassUnique 3
849 floatingClassKey = mkPreludeClassUnique 5
850 fractionalClassKey = mkPreludeClassUnique 6
851 integralClassKey = mkPreludeClassUnique 7
852 monadClassKey = mkPreludeClassUnique 8
853 dataClassKey = mkPreludeClassUnique 9
854 functorClassKey = mkPreludeClassUnique 10
855 numClassKey = mkPreludeClassUnique 11
856 ordClassKey = mkPreludeClassUnique 12
857 readClassKey = mkPreludeClassUnique 13
858 realClassKey = mkPreludeClassUnique 14
859 realFloatClassKey = mkPreludeClassUnique 15
860 realFracClassKey = mkPreludeClassUnique 16
861 showClassKey = mkPreludeClassUnique 17
862 ixClassKey = mkPreludeClassUnique 18
864 typeableClassKey, typeable1ClassKey, typeable2ClassKey, typeable3ClassKey,
865 typeable4ClassKey, typeable5ClassKey, typeable6ClassKey, typeable7ClassKey
867 typeableClassKey = mkPreludeClassUnique 20
868 typeable1ClassKey = mkPreludeClassUnique 21
869 typeable2ClassKey = mkPreludeClassUnique 22
870 typeable3ClassKey = mkPreludeClassUnique 23
871 typeable4ClassKey = mkPreludeClassUnique 24
872 typeable5ClassKey = mkPreludeClassUnique 25
873 typeable6ClassKey = mkPreludeClassUnique 26
874 typeable7ClassKey = mkPreludeClassUnique 27
876 monadFixClassKey :: Unique
877 monadFixClassKey = mkPreludeClassUnique 28
879 monadPlusClassKey, randomClassKey, randomGenClassKey :: Unique
880 monadPlusClassKey = mkPreludeClassUnique 30
881 randomClassKey = mkPreludeClassUnique 31
882 randomGenClassKey = mkPreludeClassUnique 32
884 isStringClassKey :: Unique
885 isStringClassKey = mkPreludeClassUnique 33
888 %************************************************************************
890 \subsubsection[Uniques-prelude-TyCons]{@Uniques@ for wired-in @TyCons@}
892 %************************************************************************
895 addrPrimTyConKey, arrayPrimTyConKey, boolTyConKey, byteArrayPrimTyConKey,
896 charPrimTyConKey, charTyConKey, doublePrimTyConKey, doubleTyConKey,
897 floatPrimTyConKey, floatTyConKey, funTyConKey, intPrimTyConKey,
898 intTyConKey, int8TyConKey, int16TyConKey, int32PrimTyConKey,
899 int32TyConKey, int64PrimTyConKey, int64TyConKey, integerTyConKey,
900 listTyConKey, foreignObjPrimTyConKey, weakPrimTyConKey,
901 mutableArrayPrimTyConKey, mutableByteArrayPrimTyConKey,
902 orderingTyConKey, mVarPrimTyConKey, ratioTyConKey, rationalTyConKey,
903 realWorldTyConKey, stablePtrPrimTyConKey, stablePtrTyConKey :: Unique
904 addrPrimTyConKey = mkPreludeTyConUnique 1
905 arrayPrimTyConKey = mkPreludeTyConUnique 3
906 boolTyConKey = mkPreludeTyConUnique 4
907 byteArrayPrimTyConKey = mkPreludeTyConUnique 5
908 charPrimTyConKey = mkPreludeTyConUnique 7
909 charTyConKey = mkPreludeTyConUnique 8
910 doublePrimTyConKey = mkPreludeTyConUnique 9
911 doubleTyConKey = mkPreludeTyConUnique 10
912 floatPrimTyConKey = mkPreludeTyConUnique 11
913 floatTyConKey = mkPreludeTyConUnique 12
914 funTyConKey = mkPreludeTyConUnique 13
915 intPrimTyConKey = mkPreludeTyConUnique 14
916 intTyConKey = mkPreludeTyConUnique 15
917 int8TyConKey = mkPreludeTyConUnique 16
918 int16TyConKey = mkPreludeTyConUnique 17
919 int32PrimTyConKey = mkPreludeTyConUnique 18
920 int32TyConKey = mkPreludeTyConUnique 19
921 int64PrimTyConKey = mkPreludeTyConUnique 20
922 int64TyConKey = mkPreludeTyConUnique 21
923 integerTyConKey = mkPreludeTyConUnique 22
924 listTyConKey = mkPreludeTyConUnique 23
925 foreignObjPrimTyConKey = mkPreludeTyConUnique 24
926 weakPrimTyConKey = mkPreludeTyConUnique 27
927 mutableArrayPrimTyConKey = mkPreludeTyConUnique 28
928 mutableByteArrayPrimTyConKey = mkPreludeTyConUnique 29
929 orderingTyConKey = mkPreludeTyConUnique 30
930 mVarPrimTyConKey = mkPreludeTyConUnique 31
931 ratioTyConKey = mkPreludeTyConUnique 32
932 rationalTyConKey = mkPreludeTyConUnique 33
933 realWorldTyConKey = mkPreludeTyConUnique 34
934 stablePtrPrimTyConKey = mkPreludeTyConUnique 35
935 stablePtrTyConKey = mkPreludeTyConUnique 36
937 anyPrimTyConKey, anyPrimTyCon1Key :: Unique
938 anyPrimTyConKey = mkPreludeTyConUnique 37
939 anyPrimTyCon1Key = mkPreludeTyConUnique 38
941 statePrimTyConKey, stableNamePrimTyConKey, stableNameTyConKey,
942 mutVarPrimTyConKey, ioTyConKey,
943 wordPrimTyConKey, wordTyConKey, word8TyConKey, word16TyConKey,
944 word32PrimTyConKey, word32TyConKey, word64PrimTyConKey, word64TyConKey,
945 liftedConKey, unliftedConKey, anyBoxConKey, kindConKey, boxityConKey,
946 typeConKey, threadIdPrimTyConKey, bcoPrimTyConKey, ptrTyConKey,
947 funPtrTyConKey, tVarPrimTyConKey :: Unique
948 statePrimTyConKey = mkPreludeTyConUnique 50
949 stableNamePrimTyConKey = mkPreludeTyConUnique 51
950 stableNameTyConKey = mkPreludeTyConUnique 52
951 mutVarPrimTyConKey = mkPreludeTyConUnique 55
952 ioTyConKey = mkPreludeTyConUnique 56
953 wordPrimTyConKey = mkPreludeTyConUnique 58
954 wordTyConKey = mkPreludeTyConUnique 59
955 word8TyConKey = mkPreludeTyConUnique 60
956 word16TyConKey = mkPreludeTyConUnique 61
957 word32PrimTyConKey = mkPreludeTyConUnique 62
958 word32TyConKey = mkPreludeTyConUnique 63
959 word64PrimTyConKey = mkPreludeTyConUnique 64
960 word64TyConKey = mkPreludeTyConUnique 65
961 liftedConKey = mkPreludeTyConUnique 66
962 unliftedConKey = mkPreludeTyConUnique 67
963 anyBoxConKey = mkPreludeTyConUnique 68
964 kindConKey = mkPreludeTyConUnique 69
965 boxityConKey = mkPreludeTyConUnique 70
966 typeConKey = mkPreludeTyConUnique 71
967 threadIdPrimTyConKey = mkPreludeTyConUnique 72
968 bcoPrimTyConKey = mkPreludeTyConUnique 73
969 ptrTyConKey = mkPreludeTyConUnique 74
970 funPtrTyConKey = mkPreludeTyConUnique 75
971 tVarPrimTyConKey = mkPreludeTyConUnique 76
973 -- Generic Type Constructors
974 crossTyConKey, plusTyConKey, genUnitTyConKey :: Unique
975 crossTyConKey = mkPreludeTyConUnique 79
976 plusTyConKey = mkPreludeTyConUnique 80
977 genUnitTyConKey = mkPreludeTyConUnique 81
979 -- Parallel array type constructor
980 parrTyConKey :: Unique
981 parrTyConKey = mkPreludeTyConUnique 82
984 objectTyConKey :: Unique
985 objectTyConKey = mkPreludeTyConUnique 83
987 eitherTyConKey :: Unique
988 eitherTyConKey = mkPreludeTyConUnique 84
990 -- Super Kinds constructors
991 tySuperKindTyConKey, coSuperKindTyConKey :: Unique
992 tySuperKindTyConKey = mkPreludeTyConUnique 85
993 coSuperKindTyConKey = mkPreludeTyConUnique 86
996 liftedTypeKindTyConKey, openTypeKindTyConKey, unliftedTypeKindTyConKey,
997 ubxTupleKindTyConKey, argTypeKindTyConKey :: Unique
998 liftedTypeKindTyConKey = mkPreludeTyConUnique 87
999 openTypeKindTyConKey = mkPreludeTyConUnique 88
1000 unliftedTypeKindTyConKey = mkPreludeTyConUnique 89
1001 ubxTupleKindTyConKey = mkPreludeTyConUnique 90
1002 argTypeKindTyConKey = mkPreludeTyConUnique 91
1004 -- Coercion constructors
1005 symCoercionTyConKey, transCoercionTyConKey, leftCoercionTyConKey,
1006 rightCoercionTyConKey, instCoercionTyConKey, unsafeCoercionTyConKey
1008 symCoercionTyConKey = mkPreludeTyConUnique 93
1009 transCoercionTyConKey = mkPreludeTyConUnique 94
1010 leftCoercionTyConKey = mkPreludeTyConUnique 95
1011 rightCoercionTyConKey = mkPreludeTyConUnique 96
1012 instCoercionTyConKey = mkPreludeTyConUnique 97
1013 unsafeCoercionTyConKey = mkPreludeTyConUnique 98
1015 unknownTyConKey, unknown1TyConKey, unknown2TyConKey, unknown3TyConKey,
1016 opaqueTyConKey :: Unique
1017 unknownTyConKey = mkPreludeTyConUnique 99
1018 unknown1TyConKey = mkPreludeTyConUnique 130
1019 unknown2TyConKey = mkPreludeTyConUnique 131
1020 unknown3TyConKey = mkPreludeTyConUnique 132
1021 opaqueTyConKey = mkPreludeTyConUnique 133
1023 stringTyConKey :: Unique
1024 stringTyConKey = mkPreludeTyConUnique 134
1026 ---------------- Template Haskell -------------------
1027 -- USES TyConUniques 100-129
1028 -----------------------------------------------------
1030 unitTyConKey :: Unique
1031 unitTyConKey = mkTupleTyConUnique Boxed 0
1034 %************************************************************************
1036 \subsubsection[Uniques-prelude-DataCons]{@Uniques@ for wired-in @DataCons@}
1038 %************************************************************************
1041 charDataConKey, consDataConKey, doubleDataConKey, falseDataConKey,
1042 floatDataConKey, intDataConKey, nilDataConKey, ratioDataConKey,
1043 stableNameDataConKey, trueDataConKey, wordDataConKey,
1044 ioDataConKey :: Unique
1045 charDataConKey = mkPreludeDataConUnique 1
1046 consDataConKey = mkPreludeDataConUnique 2
1047 doubleDataConKey = mkPreludeDataConUnique 3
1048 falseDataConKey = mkPreludeDataConUnique 4
1049 floatDataConKey = mkPreludeDataConUnique 5
1050 intDataConKey = mkPreludeDataConUnique 6
1051 nilDataConKey = mkPreludeDataConUnique 11
1052 ratioDataConKey = mkPreludeDataConUnique 12
1053 stableNameDataConKey = mkPreludeDataConUnique 14
1054 trueDataConKey = mkPreludeDataConUnique 15
1055 wordDataConKey = mkPreludeDataConUnique 16
1056 ioDataConKey = mkPreludeDataConUnique 17
1058 -- Generic data constructors
1059 crossDataConKey, inlDataConKey, inrDataConKey, genUnitDataConKey :: Unique
1060 crossDataConKey = mkPreludeDataConUnique 20
1061 inlDataConKey = mkPreludeDataConUnique 21
1062 inrDataConKey = mkPreludeDataConUnique 22
1063 genUnitDataConKey = mkPreludeDataConUnique 23
1065 -- Data constructor for parallel arrays
1066 parrDataConKey :: Unique
1067 parrDataConKey = mkPreludeDataConUnique 24
1069 leftDataConKey, rightDataConKey :: Unique
1070 leftDataConKey = mkPreludeDataConUnique 25
1071 rightDataConKey = mkPreludeDataConUnique 26
1074 %************************************************************************
1076 \subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}
1078 %************************************************************************
1081 absentErrorIdKey, augmentIdKey, appendIdKey, buildIdKey, errorIdKey,
1082 foldlIdKey, foldrIdKey, recSelErrorIdKey,
1083 integerMinusOneIdKey, integerPlusOneIdKey,
1084 integerPlusTwoIdKey, integerZeroIdKey,
1085 int2IntegerIdKey, seqIdKey, irrefutPatErrorIdKey, eqStringIdKey,
1086 noMethodBindingErrorIdKey, nonExhaustiveGuardsErrorIdKey,
1087 runtimeErrorIdKey, parErrorIdKey, parIdKey, patErrorIdKey,
1088 realWorldPrimIdKey, recConErrorIdKey, recUpdErrorIdKey,
1090 unpackCStringUtf8IdKey, unpackCStringAppendIdKey,
1091 unpackCStringFoldrIdKey, unpackCStringIdKey :: Unique
1092 absentErrorIdKey = mkPreludeMiscIdUnique 1
1093 augmentIdKey = mkPreludeMiscIdUnique 3
1094 appendIdKey = mkPreludeMiscIdUnique 4
1095 buildIdKey = mkPreludeMiscIdUnique 5
1096 errorIdKey = mkPreludeMiscIdUnique 6
1097 foldlIdKey = mkPreludeMiscIdUnique 7
1098 foldrIdKey = mkPreludeMiscIdUnique 8
1099 recSelErrorIdKey = mkPreludeMiscIdUnique 9
1100 integerMinusOneIdKey = mkPreludeMiscIdUnique 10
1101 integerPlusOneIdKey = mkPreludeMiscIdUnique 11
1102 integerPlusTwoIdKey = mkPreludeMiscIdUnique 12
1103 integerZeroIdKey = mkPreludeMiscIdUnique 13
1104 int2IntegerIdKey = mkPreludeMiscIdUnique 14
1105 seqIdKey = mkPreludeMiscIdUnique 15
1106 irrefutPatErrorIdKey = mkPreludeMiscIdUnique 16
1107 eqStringIdKey = mkPreludeMiscIdUnique 17
1108 noMethodBindingErrorIdKey = mkPreludeMiscIdUnique 18
1109 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 19
1110 runtimeErrorIdKey = mkPreludeMiscIdUnique 20
1111 parErrorIdKey = mkPreludeMiscIdUnique 21
1112 parIdKey = mkPreludeMiscIdUnique 22
1113 patErrorIdKey = mkPreludeMiscIdUnique 23
1114 realWorldPrimIdKey = mkPreludeMiscIdUnique 24
1115 recConErrorIdKey = mkPreludeMiscIdUnique 25
1116 recUpdErrorIdKey = mkPreludeMiscIdUnique 26
1117 traceIdKey = mkPreludeMiscIdUnique 27
1118 unpackCStringUtf8IdKey = mkPreludeMiscIdUnique 28
1119 unpackCStringAppendIdKey = mkPreludeMiscIdUnique 29
1120 unpackCStringFoldrIdKey = mkPreludeMiscIdUnique 30
1121 unpackCStringIdKey = mkPreludeMiscIdUnique 31
1123 unsafeCoerceIdKey, concatIdKey, filterIdKey, zipIdKey, bindIOIdKey,
1124 returnIOIdKey, deRefStablePtrIdKey, newStablePtrIdKey,
1125 smallIntegerIdKey, plusIntegerIdKey, timesIntegerIdKey,
1126 printIdKey, failIOIdKey, nullAddrIdKey, voidArgIdKey,
1127 fstIdKey, sndIdKey, otherwiseIdKey, assertIdKey, runSTRepIdKey :: Unique
1128 unsafeCoerceIdKey = mkPreludeMiscIdUnique 32
1129 concatIdKey = mkPreludeMiscIdUnique 33
1130 filterIdKey = mkPreludeMiscIdUnique 34
1131 zipIdKey = mkPreludeMiscIdUnique 35
1132 bindIOIdKey = mkPreludeMiscIdUnique 36
1133 returnIOIdKey = mkPreludeMiscIdUnique 37
1134 deRefStablePtrIdKey = mkPreludeMiscIdUnique 38
1135 newStablePtrIdKey = mkPreludeMiscIdUnique 39
1136 smallIntegerIdKey = mkPreludeMiscIdUnique 40
1137 plusIntegerIdKey = mkPreludeMiscIdUnique 41
1138 timesIntegerIdKey = mkPreludeMiscIdUnique 42
1139 printIdKey = mkPreludeMiscIdUnique 43
1140 failIOIdKey = mkPreludeMiscIdUnique 44
1141 nullAddrIdKey = mkPreludeMiscIdUnique 46
1142 voidArgIdKey = mkPreludeMiscIdUnique 47
1143 fstIdKey = mkPreludeMiscIdUnique 49
1144 sndIdKey = mkPreludeMiscIdUnique 50
1145 otherwiseIdKey = mkPreludeMiscIdUnique 51
1146 assertIdKey = mkPreludeMiscIdUnique 53
1147 runSTRepIdKey = mkPreludeMiscIdUnique 54
1149 rootMainKey, runMainKey :: Unique
1150 rootMainKey = mkPreludeMiscIdUnique 55
1151 runMainKey = mkPreludeMiscIdUnique 56
1153 andIdKey, orIdKey, thenIOIdKey, lazyIdKey, assertErrorIdKey :: Unique
1154 andIdKey = mkPreludeMiscIdUnique 57
1155 orIdKey = mkPreludeMiscIdUnique 58
1156 thenIOIdKey = mkPreludeMiscIdUnique 59
1157 lazyIdKey = mkPreludeMiscIdUnique 60
1158 assertErrorIdKey = mkPreludeMiscIdUnique 61
1160 breakpointIdKey, breakpointCondIdKey, breakpointAutoIdKey,
1161 breakpointJumpIdKey, breakpointCondJumpIdKey,
1162 breakpointAutoJumpIdKey :: Unique
1163 breakpointIdKey = mkPreludeMiscIdUnique 62
1164 breakpointCondIdKey = mkPreludeMiscIdUnique 63
1165 breakpointAutoIdKey = mkPreludeMiscIdUnique 64
1166 breakpointJumpIdKey = mkPreludeMiscIdUnique 65
1167 breakpointCondJumpIdKey = mkPreludeMiscIdUnique 66
1168 breakpointAutoJumpIdKey = mkPreludeMiscIdUnique 67
1170 inlineIdKey :: Unique
1171 inlineIdKey = mkPreludeMiscIdUnique 68
1173 mapIdKey, groupWithIdKey :: Unique
1174 mapIdKey = mkPreludeMiscIdUnique 69
1175 groupWithIdKey = mkPreludeMiscIdUnique 70
1177 -- Parallel array functions
1178 singletonPIdKey, nullPIdKey, lengthPIdKey, replicatePIdKey, mapPIdKey,
1179 filterPIdKey, zipPIdKey, crossMapPIdKey, indexPIdKey, toPIdKey,
1180 enumFromToPIdKey, enumFromThenToPIdKey, emptyPIdKey, appPIdKey :: Unique
1181 singletonPIdKey = mkPreludeMiscIdUnique 79
1182 nullPIdKey = mkPreludeMiscIdUnique 80
1183 lengthPIdKey = mkPreludeMiscIdUnique 81
1184 replicatePIdKey = mkPreludeMiscIdUnique 82
1185 mapPIdKey = mkPreludeMiscIdUnique 83
1186 filterPIdKey = mkPreludeMiscIdUnique 84
1187 zipPIdKey = mkPreludeMiscIdUnique 85
1188 crossMapPIdKey = mkPreludeMiscIdUnique 86
1189 indexPIdKey = mkPreludeMiscIdUnique 87
1190 toPIdKey = mkPreludeMiscIdUnique 88
1191 enumFromToPIdKey = mkPreludeMiscIdUnique 89
1192 enumFromThenToPIdKey = mkPreludeMiscIdUnique 90
1193 emptyPIdKey = mkPreludeMiscIdUnique 91
1194 appPIdKey = mkPreludeMiscIdUnique 92
1197 unmarshalObjectIdKey, marshalObjectIdKey, marshalStringIdKey,
1198 unmarshalStringIdKey, checkDotnetResNameIdKey :: Unique
1199 unmarshalObjectIdKey = mkPreludeMiscIdUnique 94
1200 marshalObjectIdKey = mkPreludeMiscIdUnique 95
1201 marshalStringIdKey = mkPreludeMiscIdUnique 96
1202 unmarshalStringIdKey = mkPreludeMiscIdUnique 97
1203 checkDotnetResNameIdKey = mkPreludeMiscIdUnique 98
1207 Certain class operations from Prelude classes. They get their own
1208 uniques so we can look them up easily when we want to conjure them up
1209 during type checking.
1212 -- Just a place holder for unbound variables produced by the renamer:
1213 unboundKey :: Unique
1214 unboundKey = mkPreludeMiscIdUnique 101
1216 fromIntegerClassOpKey, minusClassOpKey, fromRationalClassOpKey,
1217 enumFromClassOpKey, enumFromThenClassOpKey, enumFromToClassOpKey,
1218 enumFromThenToClassOpKey, eqClassOpKey, geClassOpKey, negateClassOpKey,
1219 failMClassOpKey, bindMClassOpKey, thenMClassOpKey, returnMClassOpKey
1221 fromIntegerClassOpKey = mkPreludeMiscIdUnique 102
1222 minusClassOpKey = mkPreludeMiscIdUnique 103
1223 fromRationalClassOpKey = mkPreludeMiscIdUnique 104
1224 enumFromClassOpKey = mkPreludeMiscIdUnique 105
1225 enumFromThenClassOpKey = mkPreludeMiscIdUnique 106
1226 enumFromToClassOpKey = mkPreludeMiscIdUnique 107
1227 enumFromThenToClassOpKey = mkPreludeMiscIdUnique 108
1228 eqClassOpKey = mkPreludeMiscIdUnique 109
1229 geClassOpKey = mkPreludeMiscIdUnique 110
1230 negateClassOpKey = mkPreludeMiscIdUnique 111
1231 failMClassOpKey = mkPreludeMiscIdUnique 112
1232 bindMClassOpKey = mkPreludeMiscIdUnique 113 -- (>>=)
1233 thenMClassOpKey = mkPreludeMiscIdUnique 114 -- (>>)
1234 returnMClassOpKey = mkPreludeMiscIdUnique 117
1236 -- Recursive do notation
1238 mfixIdKey = mkPreludeMiscIdUnique 118
1241 arrAIdKey, composeAIdKey, firstAIdKey, appAIdKey, choiceAIdKey,
1242 loopAIdKey :: Unique
1243 arrAIdKey = mkPreludeMiscIdUnique 119
1244 composeAIdKey = mkPreludeMiscIdUnique 120 -- >>>
1245 firstAIdKey = mkPreludeMiscIdUnique 121
1246 appAIdKey = mkPreludeMiscIdUnique 122
1247 choiceAIdKey = mkPreludeMiscIdUnique 123 -- |||
1248 loopAIdKey = mkPreludeMiscIdUnique 124
1250 fromStringClassOpKey :: Unique
1251 fromStringClassOpKey = mkPreludeMiscIdUnique 125
1253 ---------------- Template Haskell -------------------
1254 -- USES IdUniques 200-399
1255 -----------------------------------------------------
1259 %************************************************************************
1261 \subsection{Standard groups of types}
1263 %************************************************************************
1266 numericTyKeys :: [Unique]
1277 %************************************************************************
1279 \subsection[Class-std-groups]{Standard groups of Prelude classes}
1281 %************************************************************************
1283 NOTE: @Eq@ and @Text@ do need to appear in @standardClasses@
1284 even though every numeric class has these two as a superclass,
1285 because the list of ambiguous dictionaries hasn't been simplified.
1288 numericClassKeys :: [Unique]
1294 ++ fractionalClassKeys
1296 fractionalClassKeys :: [Unique]
1297 fractionalClassKeys =
1298 [ fractionalClassKey
1304 -- the strictness analyser needs to know about numeric types
1305 -- (see SaAbsInt.lhs)
1306 needsDataDeclCtxtClassKeys :: [Unique]
1307 needsDataDeclCtxtClassKeys = -- see comments in TcDeriv
1311 -- The "standard classes" are used in defaulting (Haskell 98 report 4.3.4),
1312 -- and are: "classes defined in the Prelude or a standard library"
1313 standardClassKeys :: [Unique]
1314 standardClassKeys = derivableClassKeys ++ numericClassKeys
1315 ++ [randomClassKey, randomGenClassKey,
1317 monadClassKey, monadPlusClassKey,
1322 @derivableClassKeys@ is also used in checking \tr{deriving} constructs
1326 derivableClassKeys :: [Unique]
1328 = [ eqClassKey, ordClassKey, enumClassKey, ixClassKey,
1329 boundedClassKey, showClassKey, readClassKey ]