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 = mkBaseModule (fsLit "Data.Data")
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 :: Module
299 iNTERACTIVE = mkMainModule (fsLit ":Interactive")
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_INTERNALS (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,
709 emptyPName, appPName :: 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 emptyPName = varQual gHC_PARR (fsLit "emptyP") emptyPIdKey
723 appPName = varQual gHC_PARR (fsLit "+:+") appPIdKey
726 ioTyConName, ioDataConName, thenIOName, bindIOName, returnIOName,
728 ioTyConName = tcQual gHC_IO_BASE (fsLit "IO") ioTyConKey
729 ioDataConName = conName gHC_IO_BASE (fsLit "IO") ioDataConKey
730 thenIOName = varQual gHC_IO_BASE (fsLit "thenIO") thenIOIdKey
731 bindIOName = varQual gHC_IO_BASE (fsLit "bindIO") bindIOIdKey
732 returnIOName = varQual gHC_IO_BASE (fsLit "returnIO") returnIOIdKey
733 failIOName = varQual gHC_IO_BASE (fsLit "failIO") failIOIdKey
737 printName = varQual sYSTEM_IO (fsLit "print") printIdKey
739 -- Int, Word, and Addr things
740 int8TyConName, int16TyConName, int32TyConName, int64TyConName :: Name
741 int8TyConName = tcQual gHC_INT (fsLit "Int8") int8TyConKey
742 int16TyConName = tcQual gHC_INT (fsLit "Int16") int16TyConKey
743 int32TyConName = tcQual gHC_INT (fsLit "Int32") int32TyConKey
744 int64TyConName = tcQual gHC_INT (fsLit "Int64") int64TyConKey
747 word8TyConName, word16TyConName, word32TyConName, word64TyConName,
748 wordTyConName, wordDataConName :: Name
749 word8TyConName = tcQual gHC_WORD (fsLit "Word8") word8TyConKey
750 word16TyConName = tcQual gHC_WORD (fsLit "Word16") word16TyConKey
751 word32TyConName = tcQual gHC_WORD (fsLit "Word32") word32TyConKey
752 word64TyConName = tcQual gHC_WORD (fsLit "Word64") word64TyConKey
753 wordTyConName = tcQual gHC_WORD (fsLit "Word") wordTyConKey
754 wordDataConName = conName gHC_WORD (fsLit "W#") wordDataConKey
757 ptrTyConName, funPtrTyConName :: Name
758 ptrTyConName = tcQual gHC_PTR (fsLit "Ptr") ptrTyConKey
759 funPtrTyConName = tcQual gHC_PTR (fsLit "FunPtr") funPtrTyConKey
761 -- Foreign objects and weak pointers
762 stablePtrTyConName, newStablePtrName :: Name
763 stablePtrTyConName = tcQual gHC_STABLE (fsLit "StablePtr") stablePtrTyConKey
764 newStablePtrName = varQual gHC_STABLE (fsLit "newStablePtr") newStablePtrIdKey
768 runSTRepName = varQual gHC_ST (fsLit "runSTRep") runSTRepIdKey
770 -- Recursive-do notation
771 monadFixClassName, mfixName :: Name
772 monadFixClassName = clsQual mONAD_FIX (fsLit "MonadFix") monadFixClassKey
773 mfixName = methName mONAD_FIX (fsLit "mfix") mfixIdKey
776 arrAName, composeAName, firstAName, appAName, choiceAName, loopAName :: Name
777 arrAName = varQual aRROW (fsLit "arr") arrAIdKey
778 composeAName = varQual gHC_DESUGAR (fsLit ">>>") composeAIdKey
779 firstAName = varQual aRROW (fsLit "first") firstAIdKey
780 appAName = varQual aRROW (fsLit "app") appAIdKey
781 choiceAName = varQual aRROW (fsLit "|||") choiceAIdKey
782 loopAName = varQual aRROW (fsLit "loop") loopAIdKey
784 -- Other classes, needed for type defaulting
785 monadPlusClassName, randomClassName, randomGenClassName,
786 isStringClassName :: Name
787 monadPlusClassName = clsQual mONAD (fsLit "MonadPlus") monadPlusClassKey
788 randomClassName = clsQual rANDOM (fsLit "Random") randomClassKey
789 randomGenClassName = clsQual rANDOM (fsLit "RandomGen") randomGenClassKey
790 isStringClassName = clsQual dATA_STRING (fsLit "IsString") isStringClassKey
793 objectTyConName :: Name
794 objectTyConName = tcQual dOTNET (fsLit "Object") objectTyConKey
795 -- objectTyConName was "wTcQual", but that's gone now, and
796 -- I can't see why it was wired in anyway...
797 unmarshalObjectName, marshalObjectName, marshalStringName,
798 unmarshalStringName, checkDotnetResName :: Name
799 unmarshalObjectName = varQual dOTNET (fsLit "unmarshalObject") unmarshalObjectIdKey
800 marshalObjectName = varQual dOTNET (fsLit "marshalObject") marshalObjectIdKey
801 marshalStringName = varQual dOTNET (fsLit "marshalString") marshalStringIdKey
802 unmarshalStringName = varQual dOTNET (fsLit "unmarshalString") unmarshalStringIdKey
803 checkDotnetResName = varQual dOTNET (fsLit "checkResult") checkDotnetResNameIdKey
806 %************************************************************************
808 \subsection{Local helpers}
810 %************************************************************************
812 All these are original names; hence mkOrig
815 varQual, tcQual, clsQual :: Module -> FastString -> Unique -> Name
816 varQual = mk_known_key_name varName
817 tcQual = mk_known_key_name tcName
818 clsQual = mk_known_key_name clsName
820 mk_known_key_name :: NameSpace -> Module -> FastString -> Unique -> Name
821 mk_known_key_name space modu str unique
822 = mkExternalName unique modu (mkOccNameFS space str) noSrcSpan
824 conName :: Module -> FastString -> Unique -> Name
825 conName modu occ unique
826 = mkExternalName unique modu (mkOccNameFS dataName occ) noSrcSpan
828 methName :: Module -> FastString -> Unique -> Name
829 methName modu occ unique
830 = mkExternalName unique modu (mkVarOccFS occ) noSrcSpan
833 %************************************************************************
835 \subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@}
837 %************************************************************************
838 --MetaHaskell extension hand allocate keys here
841 boundedClassKey, enumClassKey, eqClassKey, floatingClassKey,
842 fractionalClassKey, integralClassKey, monadClassKey, dataClassKey,
843 functorClassKey, numClassKey, ordClassKey, readClassKey, realClassKey,
844 realFloatClassKey, realFracClassKey, showClassKey, ixClassKey :: Unique
845 boundedClassKey = mkPreludeClassUnique 1
846 enumClassKey = mkPreludeClassUnique 2
847 eqClassKey = mkPreludeClassUnique 3
848 floatingClassKey = mkPreludeClassUnique 5
849 fractionalClassKey = mkPreludeClassUnique 6
850 integralClassKey = mkPreludeClassUnique 7
851 monadClassKey = mkPreludeClassUnique 8
852 dataClassKey = mkPreludeClassUnique 9
853 functorClassKey = mkPreludeClassUnique 10
854 numClassKey = mkPreludeClassUnique 11
855 ordClassKey = mkPreludeClassUnique 12
856 readClassKey = mkPreludeClassUnique 13
857 realClassKey = mkPreludeClassUnique 14
858 realFloatClassKey = mkPreludeClassUnique 15
859 realFracClassKey = mkPreludeClassUnique 16
860 showClassKey = mkPreludeClassUnique 17
861 ixClassKey = mkPreludeClassUnique 18
863 typeableClassKey, typeable1ClassKey, typeable2ClassKey, typeable3ClassKey,
864 typeable4ClassKey, typeable5ClassKey, typeable6ClassKey, typeable7ClassKey
866 typeableClassKey = mkPreludeClassUnique 20
867 typeable1ClassKey = mkPreludeClassUnique 21
868 typeable2ClassKey = mkPreludeClassUnique 22
869 typeable3ClassKey = mkPreludeClassUnique 23
870 typeable4ClassKey = mkPreludeClassUnique 24
871 typeable5ClassKey = mkPreludeClassUnique 25
872 typeable6ClassKey = mkPreludeClassUnique 26
873 typeable7ClassKey = mkPreludeClassUnique 27
875 monadFixClassKey :: Unique
876 monadFixClassKey = mkPreludeClassUnique 28
878 monadPlusClassKey, randomClassKey, randomGenClassKey :: Unique
879 monadPlusClassKey = mkPreludeClassUnique 30
880 randomClassKey = mkPreludeClassUnique 31
881 randomGenClassKey = mkPreludeClassUnique 32
883 isStringClassKey :: Unique
884 isStringClassKey = mkPreludeClassUnique 33
887 %************************************************************************
889 \subsubsection[Uniques-prelude-TyCons]{@Uniques@ for wired-in @TyCons@}
891 %************************************************************************
894 addrPrimTyConKey, arrayPrimTyConKey, boolTyConKey, byteArrayPrimTyConKey,
895 charPrimTyConKey, charTyConKey, doublePrimTyConKey, doubleTyConKey,
896 floatPrimTyConKey, floatTyConKey, funTyConKey, intPrimTyConKey,
897 intTyConKey, int8TyConKey, int16TyConKey, int32PrimTyConKey,
898 int32TyConKey, int64PrimTyConKey, int64TyConKey, integerTyConKey,
899 listTyConKey, foreignObjPrimTyConKey, weakPrimTyConKey,
900 mutableArrayPrimTyConKey, mutableByteArrayPrimTyConKey,
901 orderingTyConKey, mVarPrimTyConKey, ratioTyConKey, rationalTyConKey,
902 realWorldTyConKey, stablePtrPrimTyConKey, stablePtrTyConKey :: Unique
903 addrPrimTyConKey = mkPreludeTyConUnique 1
904 arrayPrimTyConKey = mkPreludeTyConUnique 3
905 boolTyConKey = mkPreludeTyConUnique 4
906 byteArrayPrimTyConKey = mkPreludeTyConUnique 5
907 charPrimTyConKey = mkPreludeTyConUnique 7
908 charTyConKey = mkPreludeTyConUnique 8
909 doublePrimTyConKey = mkPreludeTyConUnique 9
910 doubleTyConKey = mkPreludeTyConUnique 10
911 floatPrimTyConKey = mkPreludeTyConUnique 11
912 floatTyConKey = mkPreludeTyConUnique 12
913 funTyConKey = mkPreludeTyConUnique 13
914 intPrimTyConKey = mkPreludeTyConUnique 14
915 intTyConKey = mkPreludeTyConUnique 15
916 int8TyConKey = mkPreludeTyConUnique 16
917 int16TyConKey = mkPreludeTyConUnique 17
918 int32PrimTyConKey = mkPreludeTyConUnique 18
919 int32TyConKey = mkPreludeTyConUnique 19
920 int64PrimTyConKey = mkPreludeTyConUnique 20
921 int64TyConKey = mkPreludeTyConUnique 21
922 integerTyConKey = mkPreludeTyConUnique 22
923 listTyConKey = mkPreludeTyConUnique 23
924 foreignObjPrimTyConKey = mkPreludeTyConUnique 24
925 weakPrimTyConKey = mkPreludeTyConUnique 27
926 mutableArrayPrimTyConKey = mkPreludeTyConUnique 28
927 mutableByteArrayPrimTyConKey = mkPreludeTyConUnique 29
928 orderingTyConKey = mkPreludeTyConUnique 30
929 mVarPrimTyConKey = mkPreludeTyConUnique 31
930 ratioTyConKey = mkPreludeTyConUnique 32
931 rationalTyConKey = mkPreludeTyConUnique 33
932 realWorldTyConKey = mkPreludeTyConUnique 34
933 stablePtrPrimTyConKey = mkPreludeTyConUnique 35
934 stablePtrTyConKey = mkPreludeTyConUnique 36
936 anyPrimTyConKey, anyPrimTyCon1Key :: Unique
937 anyPrimTyConKey = mkPreludeTyConUnique 37
938 anyPrimTyCon1Key = mkPreludeTyConUnique 38
940 statePrimTyConKey, stableNamePrimTyConKey, stableNameTyConKey,
941 mutVarPrimTyConKey, ioTyConKey,
942 wordPrimTyConKey, wordTyConKey, word8TyConKey, word16TyConKey,
943 word32PrimTyConKey, word32TyConKey, word64PrimTyConKey, word64TyConKey,
944 liftedConKey, unliftedConKey, anyBoxConKey, kindConKey, boxityConKey,
945 typeConKey, threadIdPrimTyConKey, bcoPrimTyConKey, ptrTyConKey,
946 funPtrTyConKey, tVarPrimTyConKey :: Unique
947 statePrimTyConKey = mkPreludeTyConUnique 50
948 stableNamePrimTyConKey = mkPreludeTyConUnique 51
949 stableNameTyConKey = mkPreludeTyConUnique 52
950 mutVarPrimTyConKey = mkPreludeTyConUnique 55
951 ioTyConKey = mkPreludeTyConUnique 56
952 wordPrimTyConKey = mkPreludeTyConUnique 58
953 wordTyConKey = mkPreludeTyConUnique 59
954 word8TyConKey = mkPreludeTyConUnique 60
955 word16TyConKey = mkPreludeTyConUnique 61
956 word32PrimTyConKey = mkPreludeTyConUnique 62
957 word32TyConKey = mkPreludeTyConUnique 63
958 word64PrimTyConKey = mkPreludeTyConUnique 64
959 word64TyConKey = mkPreludeTyConUnique 65
960 liftedConKey = mkPreludeTyConUnique 66
961 unliftedConKey = mkPreludeTyConUnique 67
962 anyBoxConKey = mkPreludeTyConUnique 68
963 kindConKey = mkPreludeTyConUnique 69
964 boxityConKey = mkPreludeTyConUnique 70
965 typeConKey = mkPreludeTyConUnique 71
966 threadIdPrimTyConKey = mkPreludeTyConUnique 72
967 bcoPrimTyConKey = mkPreludeTyConUnique 73
968 ptrTyConKey = mkPreludeTyConUnique 74
969 funPtrTyConKey = mkPreludeTyConUnique 75
970 tVarPrimTyConKey = mkPreludeTyConUnique 76
972 -- Generic Type Constructors
973 crossTyConKey, plusTyConKey, genUnitTyConKey :: Unique
974 crossTyConKey = mkPreludeTyConUnique 79
975 plusTyConKey = mkPreludeTyConUnique 80
976 genUnitTyConKey = mkPreludeTyConUnique 81
978 -- Parallel array type constructor
979 parrTyConKey :: Unique
980 parrTyConKey = mkPreludeTyConUnique 82
983 objectTyConKey :: Unique
984 objectTyConKey = mkPreludeTyConUnique 83
986 eitherTyConKey :: Unique
987 eitherTyConKey = mkPreludeTyConUnique 84
989 -- Super Kinds constructors
990 tySuperKindTyConKey, coSuperKindTyConKey :: Unique
991 tySuperKindTyConKey = mkPreludeTyConUnique 85
992 coSuperKindTyConKey = mkPreludeTyConUnique 86
995 liftedTypeKindTyConKey, openTypeKindTyConKey, unliftedTypeKindTyConKey,
996 ubxTupleKindTyConKey, argTypeKindTyConKey :: Unique
997 liftedTypeKindTyConKey = mkPreludeTyConUnique 87
998 openTypeKindTyConKey = mkPreludeTyConUnique 88
999 unliftedTypeKindTyConKey = mkPreludeTyConUnique 89
1000 ubxTupleKindTyConKey = mkPreludeTyConUnique 90
1001 argTypeKindTyConKey = mkPreludeTyConUnique 91
1003 -- Coercion constructors
1004 symCoercionTyConKey, transCoercionTyConKey, leftCoercionTyConKey,
1005 rightCoercionTyConKey, instCoercionTyConKey, unsafeCoercionTyConKey
1007 symCoercionTyConKey = mkPreludeTyConUnique 93
1008 transCoercionTyConKey = mkPreludeTyConUnique 94
1009 leftCoercionTyConKey = mkPreludeTyConUnique 95
1010 rightCoercionTyConKey = mkPreludeTyConUnique 96
1011 instCoercionTyConKey = mkPreludeTyConUnique 97
1012 unsafeCoercionTyConKey = mkPreludeTyConUnique 98
1014 unknownTyConKey, unknown1TyConKey, unknown2TyConKey, unknown3TyConKey,
1015 opaqueTyConKey :: Unique
1016 unknownTyConKey = mkPreludeTyConUnique 99
1017 unknown1TyConKey = mkPreludeTyConUnique 130
1018 unknown2TyConKey = mkPreludeTyConUnique 131
1019 unknown3TyConKey = mkPreludeTyConUnique 132
1020 opaqueTyConKey = mkPreludeTyConUnique 133
1022 stringTyConKey :: Unique
1023 stringTyConKey = mkPreludeTyConUnique 134
1025 ---------------- Template Haskell -------------------
1026 -- USES TyConUniques 100-129
1027 -----------------------------------------------------
1029 unitTyConKey :: Unique
1030 unitTyConKey = mkTupleTyConUnique Boxed 0
1033 %************************************************************************
1035 \subsubsection[Uniques-prelude-DataCons]{@Uniques@ for wired-in @DataCons@}
1037 %************************************************************************
1040 charDataConKey, consDataConKey, doubleDataConKey, falseDataConKey,
1041 floatDataConKey, intDataConKey, nilDataConKey, ratioDataConKey,
1042 stableNameDataConKey, trueDataConKey, wordDataConKey,
1043 ioDataConKey :: Unique
1044 charDataConKey = mkPreludeDataConUnique 1
1045 consDataConKey = mkPreludeDataConUnique 2
1046 doubleDataConKey = mkPreludeDataConUnique 3
1047 falseDataConKey = mkPreludeDataConUnique 4
1048 floatDataConKey = mkPreludeDataConUnique 5
1049 intDataConKey = mkPreludeDataConUnique 6
1050 nilDataConKey = mkPreludeDataConUnique 11
1051 ratioDataConKey = mkPreludeDataConUnique 12
1052 stableNameDataConKey = mkPreludeDataConUnique 14
1053 trueDataConKey = mkPreludeDataConUnique 15
1054 wordDataConKey = mkPreludeDataConUnique 16
1055 ioDataConKey = mkPreludeDataConUnique 17
1057 -- Generic data constructors
1058 crossDataConKey, inlDataConKey, inrDataConKey, genUnitDataConKey :: Unique
1059 crossDataConKey = mkPreludeDataConUnique 20
1060 inlDataConKey = mkPreludeDataConUnique 21
1061 inrDataConKey = mkPreludeDataConUnique 22
1062 genUnitDataConKey = mkPreludeDataConUnique 23
1064 -- Data constructor for parallel arrays
1065 parrDataConKey :: Unique
1066 parrDataConKey = mkPreludeDataConUnique 24
1068 leftDataConKey, rightDataConKey :: Unique
1069 leftDataConKey = mkPreludeDataConUnique 25
1070 rightDataConKey = mkPreludeDataConUnique 26
1073 %************************************************************************
1075 \subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}
1077 %************************************************************************
1080 absentErrorIdKey, augmentIdKey, appendIdKey, buildIdKey, errorIdKey,
1081 foldlIdKey, foldrIdKey, recSelErrorIdKey,
1082 integerMinusOneIdKey, integerPlusOneIdKey,
1083 integerPlusTwoIdKey, integerZeroIdKey,
1084 int2IntegerIdKey, seqIdKey, irrefutPatErrorIdKey, eqStringIdKey,
1085 noMethodBindingErrorIdKey, nonExhaustiveGuardsErrorIdKey,
1086 runtimeErrorIdKey, parErrorIdKey, parIdKey, patErrorIdKey,
1087 realWorldPrimIdKey, recConErrorIdKey, recUpdErrorIdKey,
1089 unpackCStringUtf8IdKey, unpackCStringAppendIdKey,
1090 unpackCStringFoldrIdKey, unpackCStringIdKey :: Unique
1091 absentErrorIdKey = mkPreludeMiscIdUnique 1
1092 augmentIdKey = mkPreludeMiscIdUnique 3
1093 appendIdKey = mkPreludeMiscIdUnique 4
1094 buildIdKey = mkPreludeMiscIdUnique 5
1095 errorIdKey = mkPreludeMiscIdUnique 6
1096 foldlIdKey = mkPreludeMiscIdUnique 7
1097 foldrIdKey = mkPreludeMiscIdUnique 8
1098 recSelErrorIdKey = mkPreludeMiscIdUnique 9
1099 integerMinusOneIdKey = mkPreludeMiscIdUnique 10
1100 integerPlusOneIdKey = mkPreludeMiscIdUnique 11
1101 integerPlusTwoIdKey = mkPreludeMiscIdUnique 12
1102 integerZeroIdKey = mkPreludeMiscIdUnique 13
1103 int2IntegerIdKey = mkPreludeMiscIdUnique 14
1104 seqIdKey = mkPreludeMiscIdUnique 15
1105 irrefutPatErrorIdKey = mkPreludeMiscIdUnique 16
1106 eqStringIdKey = mkPreludeMiscIdUnique 17
1107 noMethodBindingErrorIdKey = mkPreludeMiscIdUnique 18
1108 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 19
1109 runtimeErrorIdKey = mkPreludeMiscIdUnique 20
1110 parErrorIdKey = mkPreludeMiscIdUnique 21
1111 parIdKey = mkPreludeMiscIdUnique 22
1112 patErrorIdKey = mkPreludeMiscIdUnique 23
1113 realWorldPrimIdKey = mkPreludeMiscIdUnique 24
1114 recConErrorIdKey = mkPreludeMiscIdUnique 25
1115 recUpdErrorIdKey = mkPreludeMiscIdUnique 26
1116 traceIdKey = mkPreludeMiscIdUnique 27
1117 unpackCStringUtf8IdKey = mkPreludeMiscIdUnique 28
1118 unpackCStringAppendIdKey = mkPreludeMiscIdUnique 29
1119 unpackCStringFoldrIdKey = mkPreludeMiscIdUnique 30
1120 unpackCStringIdKey = mkPreludeMiscIdUnique 31
1122 unsafeCoerceIdKey, concatIdKey, filterIdKey, zipIdKey, bindIOIdKey,
1123 returnIOIdKey, deRefStablePtrIdKey, newStablePtrIdKey,
1124 smallIntegerIdKey, plusIntegerIdKey, timesIntegerIdKey,
1125 printIdKey, failIOIdKey, nullAddrIdKey, voidArgIdKey,
1126 fstIdKey, sndIdKey, otherwiseIdKey, assertIdKey, runSTRepIdKey :: Unique
1127 unsafeCoerceIdKey = mkPreludeMiscIdUnique 32
1128 concatIdKey = mkPreludeMiscIdUnique 33
1129 filterIdKey = mkPreludeMiscIdUnique 34
1130 zipIdKey = mkPreludeMiscIdUnique 35
1131 bindIOIdKey = mkPreludeMiscIdUnique 36
1132 returnIOIdKey = mkPreludeMiscIdUnique 37
1133 deRefStablePtrIdKey = mkPreludeMiscIdUnique 38
1134 newStablePtrIdKey = mkPreludeMiscIdUnique 39
1135 smallIntegerIdKey = mkPreludeMiscIdUnique 40
1136 plusIntegerIdKey = mkPreludeMiscIdUnique 41
1137 timesIntegerIdKey = mkPreludeMiscIdUnique 42
1138 printIdKey = mkPreludeMiscIdUnique 43
1139 failIOIdKey = mkPreludeMiscIdUnique 44
1140 nullAddrIdKey = mkPreludeMiscIdUnique 46
1141 voidArgIdKey = mkPreludeMiscIdUnique 47
1142 fstIdKey = mkPreludeMiscIdUnique 49
1143 sndIdKey = mkPreludeMiscIdUnique 50
1144 otherwiseIdKey = mkPreludeMiscIdUnique 51
1145 assertIdKey = mkPreludeMiscIdUnique 53
1146 runSTRepIdKey = mkPreludeMiscIdUnique 54
1148 rootMainKey, runMainKey :: Unique
1149 rootMainKey = mkPreludeMiscIdUnique 55
1150 runMainKey = mkPreludeMiscIdUnique 56
1152 andIdKey, orIdKey, thenIOIdKey, lazyIdKey, assertErrorIdKey :: Unique
1153 andIdKey = mkPreludeMiscIdUnique 57
1154 orIdKey = mkPreludeMiscIdUnique 58
1155 thenIOIdKey = mkPreludeMiscIdUnique 59
1156 lazyIdKey = mkPreludeMiscIdUnique 60
1157 assertErrorIdKey = mkPreludeMiscIdUnique 61
1159 breakpointIdKey, breakpointCondIdKey, breakpointAutoIdKey,
1160 breakpointJumpIdKey, breakpointCondJumpIdKey,
1161 breakpointAutoJumpIdKey :: Unique
1162 breakpointIdKey = mkPreludeMiscIdUnique 62
1163 breakpointCondIdKey = mkPreludeMiscIdUnique 63
1164 breakpointAutoIdKey = mkPreludeMiscIdUnique 64
1165 breakpointJumpIdKey = mkPreludeMiscIdUnique 65
1166 breakpointCondJumpIdKey = mkPreludeMiscIdUnique 66
1167 breakpointAutoJumpIdKey = mkPreludeMiscIdUnique 67
1169 inlineIdKey :: Unique
1170 inlineIdKey = mkPreludeMiscIdUnique 68
1172 mapIdKey, groupWithIdKey :: Unique
1173 mapIdKey = mkPreludeMiscIdUnique 69
1174 groupWithIdKey = mkPreludeMiscIdUnique 70
1176 -- Parallel array functions
1177 singletonPIdKey, nullPIdKey, lengthPIdKey, replicatePIdKey, mapPIdKey,
1178 filterPIdKey, zipPIdKey, crossMapPIdKey, indexPIdKey, toPIdKey,
1179 enumFromToPIdKey, enumFromThenToPIdKey, emptyPIdKey, appPIdKey :: Unique
1180 singletonPIdKey = mkPreludeMiscIdUnique 79
1181 nullPIdKey = mkPreludeMiscIdUnique 80
1182 lengthPIdKey = mkPreludeMiscIdUnique 81
1183 replicatePIdKey = mkPreludeMiscIdUnique 82
1184 mapPIdKey = mkPreludeMiscIdUnique 83
1185 filterPIdKey = mkPreludeMiscIdUnique 84
1186 zipPIdKey = mkPreludeMiscIdUnique 85
1187 crossMapPIdKey = mkPreludeMiscIdUnique 86
1188 indexPIdKey = mkPreludeMiscIdUnique 87
1189 toPIdKey = mkPreludeMiscIdUnique 88
1190 enumFromToPIdKey = mkPreludeMiscIdUnique 89
1191 enumFromThenToPIdKey = mkPreludeMiscIdUnique 90
1192 emptyPIdKey = mkPreludeMiscIdUnique 91
1193 appPIdKey = mkPreludeMiscIdUnique 92
1196 unmarshalObjectIdKey, marshalObjectIdKey, marshalStringIdKey,
1197 unmarshalStringIdKey, checkDotnetResNameIdKey :: Unique
1198 unmarshalObjectIdKey = mkPreludeMiscIdUnique 94
1199 marshalObjectIdKey = mkPreludeMiscIdUnique 95
1200 marshalStringIdKey = mkPreludeMiscIdUnique 96
1201 unmarshalStringIdKey = mkPreludeMiscIdUnique 97
1202 checkDotnetResNameIdKey = mkPreludeMiscIdUnique 98
1206 Certain class operations from Prelude classes. They get their own
1207 uniques so we can look them up easily when we want to conjure them up
1208 during type checking.
1211 -- Just a place holder for unbound variables produced by the renamer:
1212 unboundKey :: Unique
1213 unboundKey = mkPreludeMiscIdUnique 101
1215 fromIntegerClassOpKey, minusClassOpKey, fromRationalClassOpKey,
1216 enumFromClassOpKey, enumFromThenClassOpKey, enumFromToClassOpKey,
1217 enumFromThenToClassOpKey, eqClassOpKey, geClassOpKey, negateClassOpKey,
1218 failMClassOpKey, bindMClassOpKey, thenMClassOpKey, returnMClassOpKey
1220 fromIntegerClassOpKey = mkPreludeMiscIdUnique 102
1221 minusClassOpKey = mkPreludeMiscIdUnique 103
1222 fromRationalClassOpKey = mkPreludeMiscIdUnique 104
1223 enumFromClassOpKey = mkPreludeMiscIdUnique 105
1224 enumFromThenClassOpKey = mkPreludeMiscIdUnique 106
1225 enumFromToClassOpKey = mkPreludeMiscIdUnique 107
1226 enumFromThenToClassOpKey = mkPreludeMiscIdUnique 108
1227 eqClassOpKey = mkPreludeMiscIdUnique 109
1228 geClassOpKey = mkPreludeMiscIdUnique 110
1229 negateClassOpKey = mkPreludeMiscIdUnique 111
1230 failMClassOpKey = mkPreludeMiscIdUnique 112
1231 bindMClassOpKey = mkPreludeMiscIdUnique 113 -- (>>=)
1232 thenMClassOpKey = mkPreludeMiscIdUnique 114 -- (>>)
1233 returnMClassOpKey = mkPreludeMiscIdUnique 117
1235 -- Recursive do notation
1237 mfixIdKey = mkPreludeMiscIdUnique 118
1240 arrAIdKey, composeAIdKey, firstAIdKey, appAIdKey, choiceAIdKey,
1241 loopAIdKey :: Unique
1242 arrAIdKey = mkPreludeMiscIdUnique 119
1243 composeAIdKey = mkPreludeMiscIdUnique 120 -- >>>
1244 firstAIdKey = mkPreludeMiscIdUnique 121
1245 appAIdKey = mkPreludeMiscIdUnique 122
1246 choiceAIdKey = mkPreludeMiscIdUnique 123 -- |||
1247 loopAIdKey = mkPreludeMiscIdUnique 124
1249 fromStringClassOpKey :: Unique
1250 fromStringClassOpKey = mkPreludeMiscIdUnique 125
1252 ---------------- Template Haskell -------------------
1253 -- USES IdUniques 200-399
1254 -----------------------------------------------------
1258 %************************************************************************
1260 \subsection{Standard groups of types}
1262 %************************************************************************
1265 numericTyKeys :: [Unique]
1276 %************************************************************************
1278 \subsection[Class-std-groups]{Standard groups of Prelude classes}
1280 %************************************************************************
1282 NOTE: @Eq@ and @Text@ do need to appear in @standardClasses@
1283 even though every numeric class has these two as a superclass,
1284 because the list of ambiguous dictionaries hasn't been simplified.
1287 numericClassKeys :: [Unique]
1293 ++ fractionalClassKeys
1295 fractionalClassKeys :: [Unique]
1296 fractionalClassKeys =
1297 [ fractionalClassKey
1303 -- the strictness analyser needs to know about numeric types
1304 -- (see SaAbsInt.lhs)
1305 needsDataDeclCtxtClassKeys :: [Unique]
1306 needsDataDeclCtxtClassKeys = -- see comments in TcDeriv
1310 -- The "standard classes" are used in defaulting (Haskell 98 report 4.3.4),
1311 -- and are: "classes defined in the Prelude or a standard library"
1312 standardClassKeys :: [Unique]
1313 standardClassKeys = derivableClassKeys ++ numericClassKeys
1314 ++ [randomClassKey, randomGenClassKey,
1316 monadClassKey, monadPlusClassKey,
1321 @derivableClassKeys@ is also used in checking \tr{deriving} constructs
1325 derivableClassKeys :: [Unique]
1327 = [ eqClassKey, ordClassKey, enumClassKey, ixClassKey,
1328 boundedClassKey, showClassKey, readClassKey ]