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_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_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_LIST = mkBaseModule (fsLit "GHC.List")
255 gHC_PARR = mkBaseModule (fsLit "GHC.PArr")
256 gHC_TUPLE = mkPrimModule (fsLit "GHC.Tuple")
257 dATA_TUPLE = mkBaseModule (fsLit "Data.Tuple")
258 dATA_EITHER = mkBaseModule (fsLit "Data.Either")
259 dATA_STRING = mkBaseModule (fsLit "Data.String")
260 gHC_PACK = mkBaseModule (fsLit "GHC.Pack")
261 gHC_CONC = mkBaseModule (fsLit "GHC.Conc")
262 gHC_IO_BASE = mkBaseModule (fsLit "GHC.IOBase")
263 gHC_ST = mkBaseModule (fsLit "GHC.ST")
264 gHC_ARR = mkBaseModule (fsLit "GHC.Arr")
265 gHC_STABLE = mkBaseModule (fsLit "GHC.Stable")
266 gHC_ADDR = mkBaseModule (fsLit "GHC.Addr")
267 gHC_PTR = mkBaseModule (fsLit "GHC.Ptr")
268 gHC_ERR = mkBaseModule (fsLit "GHC.Err")
269 gHC_REAL = mkBaseModule (fsLit "GHC.Real")
270 gHC_FLOAT = mkBaseModule (fsLit "GHC.Float")
271 gHC_TOP_HANDLER = mkBaseModule (fsLit "GHC.TopHandler")
272 sYSTEM_IO = mkBaseModule (fsLit "System.IO")
273 dYNAMIC = mkBaseModule (fsLit "Data.Dynamic")
274 tYPEABLE = mkBaseModule (fsLit "Data.Typeable")
275 gENERICS = mkSybModule (fsLit "Data.Generics.Basics")
276 dOTNET = mkBaseModule (fsLit "GHC.Dotnet")
277 rEAD_PREC = mkBaseModule (fsLit "Text.ParserCombinators.ReadPrec")
278 lEX = mkBaseModule (fsLit "Text.Read.Lex")
279 gHC_INT = mkBaseModule (fsLit "GHC.Int")
280 gHC_WORD = mkBaseModule (fsLit "GHC.Word")
281 mONAD = mkBaseModule (fsLit "Control.Monad")
282 mONAD_FIX = mkBaseModule (fsLit "Control.Monad.Fix")
283 aRROW = mkBaseModule (fsLit "Control.Arrow")
284 gHC_DESUGAR = mkBaseModule (fsLit "GHC.Desugar")
285 rANDOM = mkBaseModule (fsLit "System.Random")
286 gHC_EXTS = mkBaseModule (fsLit "GHC.Exts")
287 cONTROL_EXCEPTION_BASE = mkBaseModule (fsLit "Control.Exception.Base")
289 mAIN, rOOT_MAIN :: Module
290 mAIN = mkMainModule_ mAIN_NAME
291 rOOT_MAIN = mkMainModule (fsLit ":Main") -- Root module for initialisation
293 -- The ':xxx' makes a module name that the user can never
294 -- use himself. The z-encoding for ':' is "ZC", so the z-encoded
295 -- module name still starts with a capital letter, which keeps
296 -- the z-encoded version consistent.
297 iNTERACTIVE, thFAKE :: Module
298 iNTERACTIVE = mkMainModule (fsLit ":Interactive")
299 thFAKE = mkMainModule (fsLit ":THFake")
301 pRELUDE_NAME, mAIN_NAME :: ModuleName
302 pRELUDE_NAME = mkModuleNameFS (fsLit "Prelude")
303 mAIN_NAME = mkModuleNameFS (fsLit "Main")
305 mkPrimModule :: FastString -> Module
306 mkPrimModule m = mkModule primPackageId (mkModuleNameFS m)
308 mkIntegerModule :: FastString -> Module
309 mkIntegerModule m = mkModule integerPackageId (mkModuleNameFS m)
311 mkBaseModule :: FastString -> Module
312 mkBaseModule m = mkModule basePackageId (mkModuleNameFS m)
314 mkBaseModule_ :: ModuleName -> Module
315 mkBaseModule_ m = mkModule basePackageId m
317 mkSybModule :: FastString -> Module
318 mkSybModule m = mkModule sybPackageId (mkModuleNameFS m)
320 mkMainModule :: FastString -> Module
321 mkMainModule m = mkModule mainPackageId (mkModuleNameFS m)
323 mkMainModule_ :: ModuleName -> Module
324 mkMainModule_ m = mkModule mainPackageId m
327 %************************************************************************
329 \subsection{Constructing the names of tuples
331 %************************************************************************
334 mkTupleModule :: Boxity -> Arity -> Module
335 mkTupleModule Boxed 0 = gHC_UNIT
336 mkTupleModule Boxed _ = gHC_TUPLE
337 mkTupleModule Unboxed _ = gHC_PRIM
341 %************************************************************************
345 %************************************************************************
348 main_RDR_Unqual :: RdrName
349 main_RDR_Unqual = mkUnqual varName (fsLit "main")
350 -- We definitely don't want an Orig RdrName, because
351 -- main might, in principle, be imported into module Main
353 forall_tv_RDR, dot_tv_RDR :: RdrName
354 forall_tv_RDR = mkUnqual tvName (fsLit "forall")
355 dot_tv_RDR = mkUnqual tvName (fsLit ".")
357 eq_RDR, ge_RDR, ne_RDR, le_RDR, lt_RDR, gt_RDR, compare_RDR,
358 ltTag_RDR, eqTag_RDR, gtTag_RDR :: RdrName
359 eq_RDR = nameRdrName eqName
360 ge_RDR = nameRdrName geName
361 ne_RDR = varQual_RDR gHC_CLASSES (fsLit "/=")
362 le_RDR = varQual_RDR gHC_CLASSES (fsLit "<=")
363 lt_RDR = varQual_RDR gHC_CLASSES (fsLit "<")
364 gt_RDR = varQual_RDR gHC_CLASSES (fsLit ">")
365 compare_RDR = varQual_RDR gHC_CLASSES (fsLit "compare")
366 ltTag_RDR = dataQual_RDR gHC_ORDERING (fsLit "LT")
367 eqTag_RDR = dataQual_RDR gHC_ORDERING (fsLit "EQ")
368 gtTag_RDR = dataQual_RDR gHC_ORDERING (fsLit "GT")
370 eqClass_RDR, numClass_RDR, ordClass_RDR, enumClass_RDR, monadClass_RDR
372 eqClass_RDR = nameRdrName eqClassName
373 numClass_RDR = nameRdrName numClassName
374 ordClass_RDR = nameRdrName ordClassName
375 enumClass_RDR = nameRdrName enumClassName
376 monadClass_RDR = nameRdrName monadClassName
378 map_RDR, append_RDR :: RdrName
379 map_RDR = varQual_RDR gHC_BASE (fsLit "map")
380 append_RDR = varQual_RDR gHC_BASE (fsLit "++")
382 foldr_RDR, build_RDR, returnM_RDR, bindM_RDR, failM_RDR :: RdrName
383 foldr_RDR = nameRdrName foldrName
384 build_RDR = nameRdrName buildName
385 returnM_RDR = nameRdrName returnMName
386 bindM_RDR = nameRdrName bindMName
387 failM_RDR = nameRdrName failMName
390 and_RDR = nameRdrName andName
392 left_RDR, right_RDR :: RdrName
393 left_RDR = nameRdrName leftDataConName
394 right_RDR = nameRdrName rightDataConName
396 fromEnum_RDR, toEnum_RDR :: RdrName
397 fromEnum_RDR = varQual_RDR gHC_ENUM (fsLit "fromEnum")
398 toEnum_RDR = varQual_RDR gHC_ENUM (fsLit "toEnum")
400 enumFrom_RDR, enumFromTo_RDR, enumFromThen_RDR, enumFromThenTo_RDR :: RdrName
401 enumFrom_RDR = nameRdrName enumFromName
402 enumFromTo_RDR = nameRdrName enumFromToName
403 enumFromThen_RDR = nameRdrName enumFromThenName
404 enumFromThenTo_RDR = nameRdrName enumFromThenToName
406 ratioDataCon_RDR, plusInteger_RDR, timesInteger_RDR :: RdrName
407 ratioDataCon_RDR = nameRdrName ratioDataConName
408 plusInteger_RDR = nameRdrName plusIntegerName
409 timesInteger_RDR = nameRdrName timesIntegerName
411 ioDataCon_RDR :: RdrName
412 ioDataCon_RDR = nameRdrName ioDataConName
414 eqString_RDR, unpackCString_RDR, unpackCStringFoldr_RDR,
415 unpackCStringUtf8_RDR :: RdrName
416 eqString_RDR = nameRdrName eqStringName
417 unpackCString_RDR = nameRdrName unpackCStringName
418 unpackCStringFoldr_RDR = nameRdrName unpackCStringFoldrName
419 unpackCStringUtf8_RDR = nameRdrName unpackCStringUtf8Name
421 newStablePtr_RDR, wordDataCon_RDR :: RdrName
422 newStablePtr_RDR = nameRdrName newStablePtrName
423 wordDataCon_RDR = dataQual_RDR gHC_WORD (fsLit "W#")
425 bindIO_RDR, returnIO_RDR :: RdrName
426 bindIO_RDR = nameRdrName bindIOName
427 returnIO_RDR = nameRdrName returnIOName
429 fromInteger_RDR, fromRational_RDR, minus_RDR, times_RDR, plus_RDR :: RdrName
430 fromInteger_RDR = nameRdrName fromIntegerName
431 fromRational_RDR = nameRdrName fromRationalName
432 minus_RDR = nameRdrName minusName
433 times_RDR = varQual_RDR gHC_NUM (fsLit "*")
434 plus_RDR = varQual_RDR gHC_NUM (fsLit "+")
436 fromString_RDR :: RdrName
437 fromString_RDR = nameRdrName fromStringName
439 compose_RDR :: RdrName
440 compose_RDR = varQual_RDR gHC_BASE (fsLit ".")
442 not_RDR, getTag_RDR, succ_RDR, pred_RDR, minBound_RDR, maxBound_RDR,
443 range_RDR, inRange_RDR, index_RDR,
444 unsafeIndex_RDR, unsafeRangeSize_RDR :: RdrName
445 not_RDR = varQual_RDR gHC_CLASSES (fsLit "not")
446 getTag_RDR = varQual_RDR gHC_BASE (fsLit "getTag")
447 succ_RDR = varQual_RDR gHC_ENUM (fsLit "succ")
448 pred_RDR = varQual_RDR gHC_ENUM (fsLit "pred")
449 minBound_RDR = varQual_RDR gHC_ENUM (fsLit "minBound")
450 maxBound_RDR = varQual_RDR gHC_ENUM (fsLit "maxBound")
451 range_RDR = varQual_RDR gHC_ARR (fsLit "range")
452 inRange_RDR = varQual_RDR gHC_ARR (fsLit "inRange")
453 index_RDR = varQual_RDR gHC_ARR (fsLit "index")
454 unsafeIndex_RDR = varQual_RDR gHC_ARR (fsLit "unsafeIndex")
455 unsafeRangeSize_RDR = varQual_RDR gHC_ARR (fsLit "unsafeRangeSize")
457 readList_RDR, readListDefault_RDR, readListPrec_RDR, readListPrecDefault_RDR,
458 readPrec_RDR, parens_RDR, choose_RDR, lexP_RDR :: RdrName
459 readList_RDR = varQual_RDR gHC_READ (fsLit "readList")
460 readListDefault_RDR = varQual_RDR gHC_READ (fsLit "readListDefault")
461 readListPrec_RDR = varQual_RDR gHC_READ (fsLit "readListPrec")
462 readListPrecDefault_RDR = varQual_RDR gHC_READ (fsLit "readListPrecDefault")
463 readPrec_RDR = varQual_RDR gHC_READ (fsLit "readPrec")
464 parens_RDR = varQual_RDR gHC_READ (fsLit "parens")
465 choose_RDR = varQual_RDR gHC_READ (fsLit "choose")
466 lexP_RDR = varQual_RDR gHC_READ (fsLit "lexP")
468 punc_RDR, ident_RDR, symbol_RDR :: RdrName
469 punc_RDR = dataQual_RDR lEX (fsLit "Punc")
470 ident_RDR = dataQual_RDR lEX (fsLit "Ident")
471 symbol_RDR = dataQual_RDR lEX (fsLit "Symbol")
473 step_RDR, alt_RDR, reset_RDR, prec_RDR :: RdrName
474 step_RDR = varQual_RDR rEAD_PREC (fsLit "step")
475 alt_RDR = varQual_RDR rEAD_PREC (fsLit "+++")
476 reset_RDR = varQual_RDR rEAD_PREC (fsLit "reset")
477 prec_RDR = varQual_RDR rEAD_PREC (fsLit "prec")
479 showList_RDR, showList___RDR, showsPrec_RDR, showString_RDR,
480 showSpace_RDR, showParen_RDR :: RdrName
481 showList_RDR = varQual_RDR gHC_SHOW (fsLit "showList")
482 showList___RDR = varQual_RDR gHC_SHOW (fsLit "showList__")
483 showsPrec_RDR = varQual_RDR gHC_SHOW (fsLit "showsPrec")
484 showString_RDR = varQual_RDR gHC_SHOW (fsLit "showString")
485 showSpace_RDR = varQual_RDR gHC_SHOW (fsLit "showSpace")
486 showParen_RDR = varQual_RDR gHC_SHOW (fsLit "showParen")
488 typeOf_RDR, mkTypeRep_RDR, mkTyConRep_RDR :: RdrName
489 typeOf_RDR = varQual_RDR tYPEABLE (fsLit "typeOf")
490 mkTypeRep_RDR = varQual_RDR tYPEABLE (fsLit "mkTyConApp")
491 mkTyConRep_RDR = varQual_RDR tYPEABLE (fsLit "mkTyCon")
493 undefined_RDR :: RdrName
494 undefined_RDR = varQual_RDR gHC_ERR (fsLit "undefined")
496 crossDataCon_RDR, inlDataCon_RDR, inrDataCon_RDR, genUnitDataCon_RDR :: RdrName
497 crossDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit ":*:")
498 inlDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Inl")
499 inrDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Inr")
500 genUnitDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Unit")
502 ----------------------
503 varQual_RDR, tcQual_RDR, clsQual_RDR, dataQual_RDR
504 :: Module -> FastString -> RdrName
505 varQual_RDR mod str = mkOrig mod (mkOccNameFS varName str)
506 tcQual_RDR mod str = mkOrig mod (mkOccNameFS tcName str)
507 clsQual_RDR mod str = mkOrig mod (mkOccNameFS clsName str)
508 dataQual_RDR mod str = mkOrig mod (mkOccNameFS dataName str)
511 %************************************************************************
513 \subsection{Known-key names}
515 %************************************************************************
517 Many of these Names are not really "built in", but some parts of the
518 compiler (notably the deriving mechanism) need to mention their names,
519 and it's convenient to write them all down in one place.
521 --MetaHaskell Extension add the constrs and the lower case case
522 -- guys as well (perhaps) e.g. see trueDataConName below
526 runMainIOName :: Name
527 runMainIOName = varQual gHC_TOP_HANDLER (fsLit "runMainIO") runMainKey
529 orderingTyConName :: Name
530 orderingTyConName = tcQual gHC_ORDERING (fsLit "Ordering") orderingTyConKey
532 eitherTyConName, leftDataConName, rightDataConName :: Name
533 eitherTyConName = tcQual dATA_EITHER (fsLit "Either") eitherTyConKey
534 leftDataConName = conName dATA_EITHER (fsLit "Left") leftDataConKey
535 rightDataConName = conName dATA_EITHER (fsLit "Right") rightDataConKey
538 crossTyConName, plusTyConName, genUnitTyConName :: Name
539 crossTyConName = tcQual gHC_GENERICS (fsLit ":*:") crossTyConKey
540 plusTyConName = tcQual gHC_GENERICS (fsLit ":+:") plusTyConKey
541 genUnitTyConName = tcQual gHC_GENERICS (fsLit "Unit") genUnitTyConKey
543 -- Base strings Strings
544 unpackCStringName, unpackCStringAppendName, unpackCStringFoldrName,
545 unpackCStringUtf8Name, eqStringName, stringTyConName :: Name
546 unpackCStringName = varQual gHC_BASE (fsLit "unpackCString#") unpackCStringIdKey
547 unpackCStringAppendName = varQual gHC_BASE (fsLit "unpackAppendCString#") unpackCStringAppendIdKey
548 unpackCStringFoldrName = varQual gHC_BASE (fsLit "unpackFoldrCString#") unpackCStringFoldrIdKey
549 unpackCStringUtf8Name = varQual gHC_BASE (fsLit "unpackCStringUtf8#") unpackCStringUtf8IdKey
550 eqStringName = varQual gHC_BASE (fsLit "eqString") eqStringIdKey
551 stringTyConName = tcQual gHC_BASE (fsLit "String") stringTyConKey
553 -- The 'inline' function
555 inlineIdName = varQual gHC_BASE (fsLit "inline") inlineIdKey
557 -- Base classes (Eq, Ord, Functor)
558 eqClassName, eqName, ordClassName, geName, functorClassName :: Name
559 eqClassName = clsQual gHC_CLASSES (fsLit "Eq") eqClassKey
560 eqName = methName gHC_CLASSES (fsLit "==") eqClassOpKey
561 ordClassName = clsQual gHC_CLASSES (fsLit "Ord") ordClassKey
562 geName = methName gHC_CLASSES (fsLit ">=") geClassOpKey
563 functorClassName = clsQual gHC_BASE (fsLit "Functor") functorClassKey
566 monadClassName, thenMName, bindMName, returnMName, failMName :: Name
567 monadClassName = clsQual gHC_BASE (fsLit "Monad") monadClassKey
568 thenMName = methName gHC_BASE (fsLit ">>") thenMClassOpKey
569 bindMName = methName gHC_BASE (fsLit ">>=") bindMClassOpKey
570 returnMName = methName gHC_BASE (fsLit "return") returnMClassOpKey
571 failMName = methName gHC_BASE (fsLit "fail") failMClassOpKey
573 -- Functions for GHC extensions
574 groupWithName :: Name
575 groupWithName = varQual gHC_EXTS (fsLit "groupWith") groupWithIdKey
577 -- Random PrelBase functions
578 fromStringName, otherwiseIdName, foldrName, buildName, augmentName,
579 mapName, appendName, andName, orName, assertName,
580 breakpointName, breakpointCondName, breakpointAutoName,
581 opaqueTyConName :: Name
582 fromStringName = methName dATA_STRING (fsLit "fromString") fromStringClassOpKey
583 otherwiseIdName = varQual gHC_BASE (fsLit "otherwise") otherwiseIdKey
584 foldrName = varQual gHC_BASE (fsLit "foldr") foldrIdKey
585 buildName = varQual gHC_BASE (fsLit "build") buildIdKey
586 augmentName = varQual gHC_BASE (fsLit "augment") augmentIdKey
587 mapName = varQual gHC_BASE (fsLit "map") mapIdKey
588 appendName = varQual gHC_BASE (fsLit "++") appendIdKey
589 andName = varQual gHC_CLASSES (fsLit "&&") andIdKey
590 orName = varQual gHC_CLASSES (fsLit "||") orIdKey
591 assertName = varQual gHC_BASE (fsLit "assert") assertIdKey
592 breakpointName = varQual gHC_BASE (fsLit "breakpoint") breakpointIdKey
593 breakpointCondName= varQual gHC_BASE (fsLit "breakpointCond") breakpointCondIdKey
594 breakpointAutoName= varQual gHC_BASE (fsLit "breakpointAuto") breakpointAutoIdKey
595 opaqueTyConName = tcQual gHC_BASE (fsLit "Opaque") opaqueTyConKey
597 breakpointJumpName :: Name
601 (mkOccNameFS varName (fsLit "breakpointJump"))
603 breakpointCondJumpName :: Name
604 breakpointCondJumpName
606 breakpointCondJumpIdKey
607 (mkOccNameFS varName (fsLit "breakpointCondJump"))
609 breakpointAutoJumpName :: Name
610 breakpointAutoJumpName
612 breakpointAutoJumpIdKey
613 (mkOccNameFS varName (fsLit "breakpointAutoJump"))
617 fstName, sndName :: Name
618 fstName = varQual dATA_TUPLE (fsLit "fst") fstIdKey
619 sndName = varQual dATA_TUPLE (fsLit "snd") sndIdKey
622 numClassName, fromIntegerName, minusName, negateName, plusIntegerName,
623 timesIntegerName, integerTyConName, smallIntegerName :: Name
624 numClassName = clsQual gHC_NUM (fsLit "Num") numClassKey
625 fromIntegerName = methName gHC_NUM (fsLit "fromInteger") fromIntegerClassOpKey
626 minusName = methName gHC_NUM (fsLit "-") minusClassOpKey
627 negateName = methName gHC_NUM (fsLit "negate") negateClassOpKey
628 plusIntegerName = varQual gHC_INTEGER (fsLit "plusInteger") plusIntegerIdKey
629 timesIntegerName = varQual gHC_INTEGER (fsLit "timesInteger") timesIntegerIdKey
630 integerTyConName = tcQual gHC_INTEGER (fsLit "Integer") integerTyConKey
631 smallIntegerName = varQual gHC_INTEGER (fsLit "smallInteger") smallIntegerIdKey
633 -- PrelReal types and classes
634 rationalTyConName, ratioTyConName, ratioDataConName, realClassName,
635 integralClassName, realFracClassName, fractionalClassName,
636 fromRationalName :: Name
637 rationalTyConName = tcQual gHC_REAL (fsLit "Rational") rationalTyConKey
638 ratioTyConName = tcQual gHC_REAL (fsLit "Ratio") ratioTyConKey
639 ratioDataConName = conName gHC_REAL (fsLit ":%") ratioDataConKey
640 realClassName = clsQual gHC_REAL (fsLit "Real") realClassKey
641 integralClassName = clsQual gHC_REAL (fsLit "Integral") integralClassKey
642 realFracClassName = clsQual gHC_REAL (fsLit "RealFrac") realFracClassKey
643 fractionalClassName = clsQual gHC_REAL (fsLit "Fractional") fractionalClassKey
644 fromRationalName = methName gHC_REAL (fsLit "fromRational") fromRationalClassOpKey
647 floatingClassName, realFloatClassName :: Name
648 floatingClassName = clsQual gHC_FLOAT (fsLit "Floating") floatingClassKey
649 realFloatClassName = clsQual gHC_FLOAT (fsLit "RealFloat") realFloatClassKey
653 ixClassName = clsQual gHC_ARR (fsLit "Ix") ixClassKey
656 typeableClassName, typeable1ClassName, typeable2ClassName,
657 typeable3ClassName, typeable4ClassName, typeable5ClassName,
658 typeable6ClassName, typeable7ClassName :: Name
659 typeableClassName = clsQual tYPEABLE (fsLit "Typeable") typeableClassKey
660 typeable1ClassName = clsQual tYPEABLE (fsLit "Typeable1") typeable1ClassKey
661 typeable2ClassName = clsQual tYPEABLE (fsLit "Typeable2") typeable2ClassKey
662 typeable3ClassName = clsQual tYPEABLE (fsLit "Typeable3") typeable3ClassKey
663 typeable4ClassName = clsQual tYPEABLE (fsLit "Typeable4") typeable4ClassKey
664 typeable5ClassName = clsQual tYPEABLE (fsLit "Typeable5") typeable5ClassKey
665 typeable6ClassName = clsQual tYPEABLE (fsLit "Typeable6") typeable6ClassKey
666 typeable7ClassName = clsQual tYPEABLE (fsLit "Typeable7") typeable7ClassKey
668 typeableClassNames :: [Name]
669 typeableClassNames = [ typeableClassName, typeable1ClassName, typeable2ClassName
670 , typeable3ClassName, typeable4ClassName, typeable5ClassName
671 , typeable6ClassName, typeable7ClassName ]
674 dataClassName :: Name
675 dataClassName = clsQual gENERICS (fsLit "Data") dataClassKey
678 assertErrorName :: Name
679 assertErrorName = varQual gHC_IO_BASE (fsLit "assertError") assertErrorIdKey
681 -- Enum module (Enum, Bounded)
682 enumClassName, enumFromName, enumFromToName, enumFromThenName,
683 enumFromThenToName, boundedClassName :: Name
684 enumClassName = clsQual gHC_ENUM (fsLit "Enum") enumClassKey
685 enumFromName = methName gHC_ENUM (fsLit "enumFrom") enumFromClassOpKey
686 enumFromToName = methName gHC_ENUM (fsLit "enumFromTo") enumFromToClassOpKey
687 enumFromThenName = methName gHC_ENUM (fsLit "enumFromThen") enumFromThenClassOpKey
688 enumFromThenToName = methName gHC_ENUM (fsLit "enumFromThenTo") enumFromThenToClassOpKey
689 boundedClassName = clsQual gHC_ENUM (fsLit "Bounded") boundedClassKey
692 concatName, filterName, zipName :: Name
693 concatName = varQual gHC_LIST (fsLit "concat") concatIdKey
694 filterName = varQual gHC_LIST (fsLit "filter") filterIdKey
695 zipName = varQual gHC_LIST (fsLit "zip") zipIdKey
698 showClassName :: Name
699 showClassName = clsQual gHC_SHOW (fsLit "Show") showClassKey
702 readClassName :: Name
703 readClassName = clsQual gHC_READ (fsLit "Read") readClassKey
705 -- parallel array types and functions
706 enumFromToPName, enumFromThenToPName, nullPName, lengthPName,
707 singletonPName, replicatePName, mapPName, filterPName,
708 zipPName, crossMapPName, indexPName, toPName, bpermutePName,
709 bpermuteDftPName, indexOfPName :: Name
710 enumFromToPName = varQual gHC_PARR (fsLit "enumFromToP") enumFromToPIdKey
711 enumFromThenToPName= varQual gHC_PARR (fsLit "enumFromThenToP") enumFromThenToPIdKey
712 nullPName = varQual gHC_PARR (fsLit "nullP") nullPIdKey
713 lengthPName = varQual gHC_PARR (fsLit "lengthP") lengthPIdKey
714 singletonPName = varQual gHC_PARR (fsLit "singletonP") singletonPIdKey
715 replicatePName = varQual gHC_PARR (fsLit "replicateP") replicatePIdKey
716 mapPName = varQual gHC_PARR (fsLit "mapP") mapPIdKey
717 filterPName = varQual gHC_PARR (fsLit "filterP") filterPIdKey
718 zipPName = varQual gHC_PARR (fsLit "zipP") zipPIdKey
719 crossMapPName = varQual gHC_PARR (fsLit "crossMapP") crossMapPIdKey
720 indexPName = varQual gHC_PARR (fsLit "!:") indexPIdKey
721 toPName = varQual gHC_PARR (fsLit "toP") toPIdKey
722 bpermutePName = varQual gHC_PARR (fsLit "bpermuteP") bpermutePIdKey
723 bpermuteDftPName = varQual gHC_PARR (fsLit "bpermuteDftP") bpermuteDftPIdKey
724 indexOfPName = varQual gHC_PARR (fsLit "indexOfP") indexOfPIdKey
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,
1181 bpermutePIdKey, bpermuteDftPIdKey, indexOfPIdKey :: Unique
1182 singletonPIdKey = mkPreludeMiscIdUnique 79
1183 nullPIdKey = mkPreludeMiscIdUnique 80
1184 lengthPIdKey = mkPreludeMiscIdUnique 81
1185 replicatePIdKey = mkPreludeMiscIdUnique 82
1186 mapPIdKey = mkPreludeMiscIdUnique 83
1187 filterPIdKey = mkPreludeMiscIdUnique 84
1188 zipPIdKey = mkPreludeMiscIdUnique 85
1189 crossMapPIdKey = mkPreludeMiscIdUnique 86
1190 indexPIdKey = mkPreludeMiscIdUnique 87
1191 toPIdKey = mkPreludeMiscIdUnique 88
1192 enumFromToPIdKey = mkPreludeMiscIdUnique 89
1193 enumFromThenToPIdKey = mkPreludeMiscIdUnique 90
1194 bpermutePIdKey = mkPreludeMiscIdUnique 91
1195 bpermuteDftPIdKey = mkPreludeMiscIdUnique 92
1196 indexOfPIdKey = mkPreludeMiscIdUnique 93
1199 unmarshalObjectIdKey, marshalObjectIdKey, marshalStringIdKey,
1200 unmarshalStringIdKey, checkDotnetResNameIdKey :: Unique
1201 unmarshalObjectIdKey = mkPreludeMiscIdUnique 94
1202 marshalObjectIdKey = mkPreludeMiscIdUnique 95
1203 marshalStringIdKey = mkPreludeMiscIdUnique 96
1204 unmarshalStringIdKey = mkPreludeMiscIdUnique 97
1205 checkDotnetResNameIdKey = mkPreludeMiscIdUnique 98
1209 Certain class operations from Prelude classes. They get their own
1210 uniques so we can look them up easily when we want to conjure them up
1211 during type checking.
1214 -- Just a place holder for unbound variables produced by the renamer:
1215 unboundKey :: Unique
1216 unboundKey = mkPreludeMiscIdUnique 101
1218 fromIntegerClassOpKey, minusClassOpKey, fromRationalClassOpKey,
1219 enumFromClassOpKey, enumFromThenClassOpKey, enumFromToClassOpKey,
1220 enumFromThenToClassOpKey, eqClassOpKey, geClassOpKey, negateClassOpKey,
1221 failMClassOpKey, bindMClassOpKey, thenMClassOpKey, returnMClassOpKey
1223 fromIntegerClassOpKey = mkPreludeMiscIdUnique 102
1224 minusClassOpKey = mkPreludeMiscIdUnique 103
1225 fromRationalClassOpKey = mkPreludeMiscIdUnique 104
1226 enumFromClassOpKey = mkPreludeMiscIdUnique 105
1227 enumFromThenClassOpKey = mkPreludeMiscIdUnique 106
1228 enumFromToClassOpKey = mkPreludeMiscIdUnique 107
1229 enumFromThenToClassOpKey = mkPreludeMiscIdUnique 108
1230 eqClassOpKey = mkPreludeMiscIdUnique 109
1231 geClassOpKey = mkPreludeMiscIdUnique 110
1232 negateClassOpKey = mkPreludeMiscIdUnique 111
1233 failMClassOpKey = mkPreludeMiscIdUnique 112
1234 bindMClassOpKey = mkPreludeMiscIdUnique 113 -- (>>=)
1235 thenMClassOpKey = mkPreludeMiscIdUnique 114 -- (>>)
1236 returnMClassOpKey = mkPreludeMiscIdUnique 117
1238 -- Recursive do notation
1240 mfixIdKey = mkPreludeMiscIdUnique 118
1243 arrAIdKey, composeAIdKey, firstAIdKey, appAIdKey, choiceAIdKey,
1244 loopAIdKey :: Unique
1245 arrAIdKey = mkPreludeMiscIdUnique 119
1246 composeAIdKey = mkPreludeMiscIdUnique 120 -- >>>
1247 firstAIdKey = mkPreludeMiscIdUnique 121
1248 appAIdKey = mkPreludeMiscIdUnique 122
1249 choiceAIdKey = mkPreludeMiscIdUnique 123 -- |||
1250 loopAIdKey = mkPreludeMiscIdUnique 124
1252 fromStringClassOpKey :: Unique
1253 fromStringClassOpKey = mkPreludeMiscIdUnique 125
1255 ---------------- Template Haskell -------------------
1256 -- USES IdUniques 200-399
1257 -----------------------------------------------------
1261 %************************************************************************
1263 \subsection{Standard groups of types}
1265 %************************************************************************
1268 numericTyKeys :: [Unique]
1279 %************************************************************************
1281 \subsection[Class-std-groups]{Standard groups of Prelude classes}
1283 %************************************************************************
1285 NOTE: @Eq@ and @Text@ do need to appear in @standardClasses@
1286 even though every numeric class has these two as a superclass,
1287 because the list of ambiguous dictionaries hasn't been simplified.
1290 numericClassKeys :: [Unique]
1296 ++ fractionalClassKeys
1298 fractionalClassKeys :: [Unique]
1299 fractionalClassKeys =
1300 [ fractionalClassKey
1306 -- the strictness analyser needs to know about numeric types
1307 -- (see SaAbsInt.lhs)
1308 needsDataDeclCtxtClassKeys :: [Unique]
1309 needsDataDeclCtxtClassKeys = -- see comments in TcDeriv
1313 -- The "standard classes" are used in defaulting (Haskell 98 report 4.3.4),
1314 -- and are: "classes defined in the Prelude or a standard library"
1315 standardClassKeys :: [Unique]
1316 standardClassKeys = derivableClassKeys ++ numericClassKeys
1317 ++ [randomClassKey, randomGenClassKey,
1319 monadClassKey, monadPlusClassKey,
1324 @derivableClassKeys@ is also used in checking \tr{deriving} constructs
1328 derivableClassKeys :: [Unique]
1330 = [ eqClassKey, ordClassKey, enumClassKey, ixClassKey,
1331 boundedClassKey, showClassKey, readClassKey ]