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 = mkBaseModule (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 mkMainModule :: FastString -> Module
318 mkMainModule m = mkModule mainPackageId (mkModuleNameFS m)
320 mkMainModule_ :: ModuleName -> Module
321 mkMainModule_ m = mkModule mainPackageId m
324 %************************************************************************
326 \subsection{Constructing the names of tuples
328 %************************************************************************
331 mkTupleModule :: Boxity -> Arity -> Module
332 mkTupleModule Boxed 0 = gHC_UNIT
333 mkTupleModule Boxed _ = gHC_TUPLE
334 mkTupleModule Unboxed _ = gHC_PRIM
338 %************************************************************************
342 %************************************************************************
345 main_RDR_Unqual :: RdrName
346 main_RDR_Unqual = mkUnqual varName (fsLit "main")
347 -- We definitely don't want an Orig RdrName, because
348 -- main might, in principle, be imported into module Main
350 forall_tv_RDR, dot_tv_RDR :: RdrName
351 forall_tv_RDR = mkUnqual tvName (fsLit "forall")
352 dot_tv_RDR = mkUnqual tvName (fsLit ".")
354 eq_RDR, ge_RDR, ne_RDR, le_RDR, lt_RDR, gt_RDR, compare_RDR,
355 ltTag_RDR, eqTag_RDR, gtTag_RDR :: RdrName
356 eq_RDR = nameRdrName eqName
357 ge_RDR = nameRdrName geName
358 ne_RDR = varQual_RDR gHC_CLASSES (fsLit "/=")
359 le_RDR = varQual_RDR gHC_CLASSES (fsLit "<=")
360 lt_RDR = varQual_RDR gHC_CLASSES (fsLit "<")
361 gt_RDR = varQual_RDR gHC_CLASSES (fsLit ">")
362 compare_RDR = varQual_RDR gHC_CLASSES (fsLit "compare")
363 ltTag_RDR = dataQual_RDR gHC_ORDERING (fsLit "LT")
364 eqTag_RDR = dataQual_RDR gHC_ORDERING (fsLit "EQ")
365 gtTag_RDR = dataQual_RDR gHC_ORDERING (fsLit "GT")
367 eqClass_RDR, numClass_RDR, ordClass_RDR, enumClass_RDR, monadClass_RDR
369 eqClass_RDR = nameRdrName eqClassName
370 numClass_RDR = nameRdrName numClassName
371 ordClass_RDR = nameRdrName ordClassName
372 enumClass_RDR = nameRdrName enumClassName
373 monadClass_RDR = nameRdrName monadClassName
375 map_RDR, append_RDR :: RdrName
376 map_RDR = varQual_RDR gHC_BASE (fsLit "map")
377 append_RDR = varQual_RDR gHC_BASE (fsLit "++")
379 foldr_RDR, build_RDR, returnM_RDR, bindM_RDR, failM_RDR :: RdrName
380 foldr_RDR = nameRdrName foldrName
381 build_RDR = nameRdrName buildName
382 returnM_RDR = nameRdrName returnMName
383 bindM_RDR = nameRdrName bindMName
384 failM_RDR = nameRdrName failMName
387 and_RDR = nameRdrName andName
389 left_RDR, right_RDR :: RdrName
390 left_RDR = nameRdrName leftDataConName
391 right_RDR = nameRdrName rightDataConName
393 fromEnum_RDR, toEnum_RDR :: RdrName
394 fromEnum_RDR = varQual_RDR gHC_ENUM (fsLit "fromEnum")
395 toEnum_RDR = varQual_RDR gHC_ENUM (fsLit "toEnum")
397 enumFrom_RDR, enumFromTo_RDR, enumFromThen_RDR, enumFromThenTo_RDR :: RdrName
398 enumFrom_RDR = nameRdrName enumFromName
399 enumFromTo_RDR = nameRdrName enumFromToName
400 enumFromThen_RDR = nameRdrName enumFromThenName
401 enumFromThenTo_RDR = nameRdrName enumFromThenToName
403 ratioDataCon_RDR, plusInteger_RDR, timesInteger_RDR :: RdrName
404 ratioDataCon_RDR = nameRdrName ratioDataConName
405 plusInteger_RDR = nameRdrName plusIntegerName
406 timesInteger_RDR = nameRdrName timesIntegerName
408 ioDataCon_RDR :: RdrName
409 ioDataCon_RDR = nameRdrName ioDataConName
411 eqString_RDR, unpackCString_RDR, unpackCStringFoldr_RDR,
412 unpackCStringUtf8_RDR :: RdrName
413 eqString_RDR = nameRdrName eqStringName
414 unpackCString_RDR = nameRdrName unpackCStringName
415 unpackCStringFoldr_RDR = nameRdrName unpackCStringFoldrName
416 unpackCStringUtf8_RDR = nameRdrName unpackCStringUtf8Name
418 newStablePtr_RDR, wordDataCon_RDR :: RdrName
419 newStablePtr_RDR = nameRdrName newStablePtrName
420 wordDataCon_RDR = dataQual_RDR gHC_WORD (fsLit "W#")
422 bindIO_RDR, returnIO_RDR :: RdrName
423 bindIO_RDR = nameRdrName bindIOName
424 returnIO_RDR = nameRdrName returnIOName
426 fromInteger_RDR, fromRational_RDR, minus_RDR, times_RDR, plus_RDR :: RdrName
427 fromInteger_RDR = nameRdrName fromIntegerName
428 fromRational_RDR = nameRdrName fromRationalName
429 minus_RDR = nameRdrName minusName
430 times_RDR = varQual_RDR gHC_NUM (fsLit "*")
431 plus_RDR = varQual_RDR gHC_NUM (fsLit "+")
433 fromString_RDR :: RdrName
434 fromString_RDR = nameRdrName fromStringName
436 compose_RDR :: RdrName
437 compose_RDR = varQual_RDR gHC_BASE (fsLit ".")
439 not_RDR, getTag_RDR, succ_RDR, pred_RDR, minBound_RDR, maxBound_RDR,
440 range_RDR, inRange_RDR, index_RDR,
441 unsafeIndex_RDR, unsafeRangeSize_RDR :: RdrName
442 not_RDR = varQual_RDR gHC_CLASSES (fsLit "not")
443 getTag_RDR = varQual_RDR gHC_BASE (fsLit "getTag")
444 succ_RDR = varQual_RDR gHC_ENUM (fsLit "succ")
445 pred_RDR = varQual_RDR gHC_ENUM (fsLit "pred")
446 minBound_RDR = varQual_RDR gHC_ENUM (fsLit "minBound")
447 maxBound_RDR = varQual_RDR gHC_ENUM (fsLit "maxBound")
448 range_RDR = varQual_RDR gHC_ARR (fsLit "range")
449 inRange_RDR = varQual_RDR gHC_ARR (fsLit "inRange")
450 index_RDR = varQual_RDR gHC_ARR (fsLit "index")
451 unsafeIndex_RDR = varQual_RDR gHC_ARR (fsLit "unsafeIndex")
452 unsafeRangeSize_RDR = varQual_RDR gHC_ARR (fsLit "unsafeRangeSize")
454 readList_RDR, readListDefault_RDR, readListPrec_RDR, readListPrecDefault_RDR,
455 readPrec_RDR, parens_RDR, choose_RDR, lexP_RDR :: RdrName
456 readList_RDR = varQual_RDR gHC_READ (fsLit "readList")
457 readListDefault_RDR = varQual_RDR gHC_READ (fsLit "readListDefault")
458 readListPrec_RDR = varQual_RDR gHC_READ (fsLit "readListPrec")
459 readListPrecDefault_RDR = varQual_RDR gHC_READ (fsLit "readListPrecDefault")
460 readPrec_RDR = varQual_RDR gHC_READ (fsLit "readPrec")
461 parens_RDR = varQual_RDR gHC_READ (fsLit "parens")
462 choose_RDR = varQual_RDR gHC_READ (fsLit "choose")
463 lexP_RDR = varQual_RDR gHC_READ (fsLit "lexP")
465 punc_RDR, ident_RDR, symbol_RDR :: RdrName
466 punc_RDR = dataQual_RDR lEX (fsLit "Punc")
467 ident_RDR = dataQual_RDR lEX (fsLit "Ident")
468 symbol_RDR = dataQual_RDR lEX (fsLit "Symbol")
470 step_RDR, alt_RDR, reset_RDR, prec_RDR :: RdrName
471 step_RDR = varQual_RDR rEAD_PREC (fsLit "step")
472 alt_RDR = varQual_RDR rEAD_PREC (fsLit "+++")
473 reset_RDR = varQual_RDR rEAD_PREC (fsLit "reset")
474 prec_RDR = varQual_RDR rEAD_PREC (fsLit "prec")
476 showList_RDR, showList___RDR, showsPrec_RDR, showString_RDR,
477 showSpace_RDR, showParen_RDR :: RdrName
478 showList_RDR = varQual_RDR gHC_SHOW (fsLit "showList")
479 showList___RDR = varQual_RDR gHC_SHOW (fsLit "showList__")
480 showsPrec_RDR = varQual_RDR gHC_SHOW (fsLit "showsPrec")
481 showString_RDR = varQual_RDR gHC_SHOW (fsLit "showString")
482 showSpace_RDR = varQual_RDR gHC_SHOW (fsLit "showSpace")
483 showParen_RDR = varQual_RDR gHC_SHOW (fsLit "showParen")
485 typeOf_RDR, mkTypeRep_RDR, mkTyConRep_RDR :: RdrName
486 typeOf_RDR = varQual_RDR tYPEABLE (fsLit "typeOf")
487 mkTypeRep_RDR = varQual_RDR tYPEABLE (fsLit "mkTyConApp")
488 mkTyConRep_RDR = varQual_RDR tYPEABLE (fsLit "mkTyCon")
490 undefined_RDR :: RdrName
491 undefined_RDR = varQual_RDR gHC_ERR (fsLit "undefined")
493 crossDataCon_RDR, inlDataCon_RDR, inrDataCon_RDR, genUnitDataCon_RDR :: RdrName
494 crossDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit ":*:")
495 inlDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Inl")
496 inrDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Inr")
497 genUnitDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Unit")
499 ----------------------
500 varQual_RDR, tcQual_RDR, clsQual_RDR, dataQual_RDR
501 :: Module -> FastString -> RdrName
502 varQual_RDR mod str = mkOrig mod (mkOccNameFS varName str)
503 tcQual_RDR mod str = mkOrig mod (mkOccNameFS tcName str)
504 clsQual_RDR mod str = mkOrig mod (mkOccNameFS clsName str)
505 dataQual_RDR mod str = mkOrig mod (mkOccNameFS dataName str)
508 %************************************************************************
510 \subsection{Known-key names}
512 %************************************************************************
514 Many of these Names are not really "built in", but some parts of the
515 compiler (notably the deriving mechanism) need to mention their names,
516 and it's convenient to write them all down in one place.
518 --MetaHaskell Extension add the constrs and the lower case case
519 -- guys as well (perhaps) e.g. see trueDataConName below
523 runMainIOName :: Name
524 runMainIOName = varQual gHC_TOP_HANDLER (fsLit "runMainIO") runMainKey
526 orderingTyConName :: Name
527 orderingTyConName = tcQual gHC_ORDERING (fsLit "Ordering") orderingTyConKey
529 eitherTyConName, leftDataConName, rightDataConName :: Name
530 eitherTyConName = tcQual dATA_EITHER (fsLit "Either") eitherTyConKey
531 leftDataConName = conName dATA_EITHER (fsLit "Left") leftDataConKey
532 rightDataConName = conName dATA_EITHER (fsLit "Right") rightDataConKey
535 crossTyConName, plusTyConName, genUnitTyConName :: Name
536 crossTyConName = tcQual gHC_GENERICS (fsLit ":*:") crossTyConKey
537 plusTyConName = tcQual gHC_GENERICS (fsLit ":+:") plusTyConKey
538 genUnitTyConName = tcQual gHC_GENERICS (fsLit "Unit") genUnitTyConKey
540 -- Base strings Strings
541 unpackCStringName, unpackCStringAppendName, unpackCStringFoldrName,
542 unpackCStringUtf8Name, eqStringName, stringTyConName :: Name
543 unpackCStringName = varQual gHC_BASE (fsLit "unpackCString#") unpackCStringIdKey
544 unpackCStringAppendName = varQual gHC_BASE (fsLit "unpackAppendCString#") unpackCStringAppendIdKey
545 unpackCStringFoldrName = varQual gHC_BASE (fsLit "unpackFoldrCString#") unpackCStringFoldrIdKey
546 unpackCStringUtf8Name = varQual gHC_BASE (fsLit "unpackCStringUtf8#") unpackCStringUtf8IdKey
547 eqStringName = varQual gHC_BASE (fsLit "eqString") eqStringIdKey
548 stringTyConName = tcQual gHC_BASE (fsLit "String") stringTyConKey
550 -- The 'inline' function
552 inlineIdName = varQual gHC_BASE (fsLit "inline") inlineIdKey
554 -- Base classes (Eq, Ord, Functor)
555 eqClassName, eqName, ordClassName, geName, functorClassName :: Name
556 eqClassName = clsQual gHC_CLASSES (fsLit "Eq") eqClassKey
557 eqName = methName gHC_CLASSES (fsLit "==") eqClassOpKey
558 ordClassName = clsQual gHC_CLASSES (fsLit "Ord") ordClassKey
559 geName = methName gHC_CLASSES (fsLit ">=") geClassOpKey
560 functorClassName = clsQual gHC_BASE (fsLit "Functor") functorClassKey
563 monadClassName, thenMName, bindMName, returnMName, failMName :: Name
564 monadClassName = clsQual gHC_BASE (fsLit "Monad") monadClassKey
565 thenMName = methName gHC_BASE (fsLit ">>") thenMClassOpKey
566 bindMName = methName gHC_BASE (fsLit ">>=") bindMClassOpKey
567 returnMName = methName gHC_BASE (fsLit "return") returnMClassOpKey
568 failMName = methName gHC_BASE (fsLit "fail") failMClassOpKey
570 -- Functions for GHC extensions
571 groupWithName :: Name
572 groupWithName = varQual gHC_EXTS (fsLit "groupWith") groupWithIdKey
574 -- Random PrelBase functions
575 fromStringName, otherwiseIdName, foldrName, buildName, augmentName,
576 mapName, appendName, andName, orName, assertName,
577 breakpointName, breakpointCondName, breakpointAutoName,
578 opaqueTyConName :: Name
579 fromStringName = methName dATA_STRING (fsLit "fromString") fromStringClassOpKey
580 otherwiseIdName = varQual gHC_BASE (fsLit "otherwise") otherwiseIdKey
581 foldrName = varQual gHC_BASE (fsLit "foldr") foldrIdKey
582 buildName = varQual gHC_BASE (fsLit "build") buildIdKey
583 augmentName = varQual gHC_BASE (fsLit "augment") augmentIdKey
584 mapName = varQual gHC_BASE (fsLit "map") mapIdKey
585 appendName = varQual gHC_BASE (fsLit "++") appendIdKey
586 andName = varQual gHC_CLASSES (fsLit "&&") andIdKey
587 orName = varQual gHC_CLASSES (fsLit "||") orIdKey
588 assertName = varQual gHC_BASE (fsLit "assert") assertIdKey
589 breakpointName = varQual gHC_BASE (fsLit "breakpoint") breakpointIdKey
590 breakpointCondName= varQual gHC_BASE (fsLit "breakpointCond") breakpointCondIdKey
591 breakpointAutoName= varQual gHC_BASE (fsLit "breakpointAuto") breakpointAutoIdKey
592 opaqueTyConName = tcQual gHC_BASE (fsLit "Opaque") opaqueTyConKey
594 breakpointJumpName :: Name
598 (mkOccNameFS varName (fsLit "breakpointJump"))
600 breakpointCondJumpName :: Name
601 breakpointCondJumpName
603 breakpointCondJumpIdKey
604 (mkOccNameFS varName (fsLit "breakpointCondJump"))
606 breakpointAutoJumpName :: Name
607 breakpointAutoJumpName
609 breakpointAutoJumpIdKey
610 (mkOccNameFS varName (fsLit "breakpointAutoJump"))
614 fstName, sndName :: Name
615 fstName = varQual dATA_TUPLE (fsLit "fst") fstIdKey
616 sndName = varQual dATA_TUPLE (fsLit "snd") sndIdKey
619 numClassName, fromIntegerName, minusName, negateName, plusIntegerName,
620 timesIntegerName, integerTyConName, smallIntegerName :: Name
621 numClassName = clsQual gHC_NUM (fsLit "Num") numClassKey
622 fromIntegerName = methName gHC_NUM (fsLit "fromInteger") fromIntegerClassOpKey
623 minusName = methName gHC_NUM (fsLit "-") minusClassOpKey
624 negateName = methName gHC_NUM (fsLit "negate") negateClassOpKey
625 plusIntegerName = varQual gHC_INTEGER (fsLit "plusInteger") plusIntegerIdKey
626 timesIntegerName = varQual gHC_INTEGER (fsLit "timesInteger") timesIntegerIdKey
627 integerTyConName = tcQual gHC_INTEGER (fsLit "Integer") integerTyConKey
628 smallIntegerName = varQual gHC_INTEGER (fsLit "smallInteger") smallIntegerIdKey
630 -- PrelReal types and classes
631 rationalTyConName, ratioTyConName, ratioDataConName, realClassName,
632 integralClassName, realFracClassName, fractionalClassName,
633 fromRationalName :: Name
634 rationalTyConName = tcQual gHC_REAL (fsLit "Rational") rationalTyConKey
635 ratioTyConName = tcQual gHC_REAL (fsLit "Ratio") ratioTyConKey
636 ratioDataConName = conName gHC_REAL (fsLit ":%") ratioDataConKey
637 realClassName = clsQual gHC_REAL (fsLit "Real") realClassKey
638 integralClassName = clsQual gHC_REAL (fsLit "Integral") integralClassKey
639 realFracClassName = clsQual gHC_REAL (fsLit "RealFrac") realFracClassKey
640 fractionalClassName = clsQual gHC_REAL (fsLit "Fractional") fractionalClassKey
641 fromRationalName = methName gHC_REAL (fsLit "fromRational") fromRationalClassOpKey
644 floatingClassName, realFloatClassName :: Name
645 floatingClassName = clsQual gHC_FLOAT (fsLit "Floating") floatingClassKey
646 realFloatClassName = clsQual gHC_FLOAT (fsLit "RealFloat") realFloatClassKey
650 ixClassName = clsQual gHC_ARR (fsLit "Ix") ixClassKey
653 typeableClassName, typeable1ClassName, typeable2ClassName,
654 typeable3ClassName, typeable4ClassName, typeable5ClassName,
655 typeable6ClassName, typeable7ClassName :: Name
656 typeableClassName = clsQual tYPEABLE (fsLit "Typeable") typeableClassKey
657 typeable1ClassName = clsQual tYPEABLE (fsLit "Typeable1") typeable1ClassKey
658 typeable2ClassName = clsQual tYPEABLE (fsLit "Typeable2") typeable2ClassKey
659 typeable3ClassName = clsQual tYPEABLE (fsLit "Typeable3") typeable3ClassKey
660 typeable4ClassName = clsQual tYPEABLE (fsLit "Typeable4") typeable4ClassKey
661 typeable5ClassName = clsQual tYPEABLE (fsLit "Typeable5") typeable5ClassKey
662 typeable6ClassName = clsQual tYPEABLE (fsLit "Typeable6") typeable6ClassKey
663 typeable7ClassName = clsQual tYPEABLE (fsLit "Typeable7") typeable7ClassKey
665 typeableClassNames :: [Name]
666 typeableClassNames = [ typeableClassName, typeable1ClassName, typeable2ClassName
667 , typeable3ClassName, typeable4ClassName, typeable5ClassName
668 , typeable6ClassName, typeable7ClassName ]
671 dataClassName :: Name
672 dataClassName = clsQual gENERICS (fsLit "Data") dataClassKey
675 assertErrorName :: Name
676 assertErrorName = varQual gHC_IO_BASE (fsLit "assertError") assertErrorIdKey
678 -- Enum module (Enum, Bounded)
679 enumClassName, enumFromName, enumFromToName, enumFromThenName,
680 enumFromThenToName, boundedClassName :: Name
681 enumClassName = clsQual gHC_ENUM (fsLit "Enum") enumClassKey
682 enumFromName = methName gHC_ENUM (fsLit "enumFrom") enumFromClassOpKey
683 enumFromToName = methName gHC_ENUM (fsLit "enumFromTo") enumFromToClassOpKey
684 enumFromThenName = methName gHC_ENUM (fsLit "enumFromThen") enumFromThenClassOpKey
685 enumFromThenToName = methName gHC_ENUM (fsLit "enumFromThenTo") enumFromThenToClassOpKey
686 boundedClassName = clsQual gHC_ENUM (fsLit "Bounded") boundedClassKey
689 concatName, filterName, zipName :: Name
690 concatName = varQual gHC_LIST (fsLit "concat") concatIdKey
691 filterName = varQual gHC_LIST (fsLit "filter") filterIdKey
692 zipName = varQual gHC_LIST (fsLit "zip") zipIdKey
695 showClassName :: Name
696 showClassName = clsQual gHC_SHOW (fsLit "Show") showClassKey
699 readClassName :: Name
700 readClassName = clsQual gHC_READ (fsLit "Read") readClassKey
702 -- parallel array types and functions
703 enumFromToPName, enumFromThenToPName, nullPName, lengthPName,
704 singletonPName, replicatePName, mapPName, filterPName,
705 zipPName, crossMapPName, indexPName, toPName, bpermutePName,
706 bpermuteDftPName, indexOfPName :: Name
707 enumFromToPName = varQual gHC_PARR (fsLit "enumFromToP") enumFromToPIdKey
708 enumFromThenToPName= varQual gHC_PARR (fsLit "enumFromThenToP") enumFromThenToPIdKey
709 nullPName = varQual gHC_PARR (fsLit "nullP") nullPIdKey
710 lengthPName = varQual gHC_PARR (fsLit "lengthP") lengthPIdKey
711 singletonPName = varQual gHC_PARR (fsLit "singletonP") singletonPIdKey
712 replicatePName = varQual gHC_PARR (fsLit "replicateP") replicatePIdKey
713 mapPName = varQual gHC_PARR (fsLit "mapP") mapPIdKey
714 filterPName = varQual gHC_PARR (fsLit "filterP") filterPIdKey
715 zipPName = varQual gHC_PARR (fsLit "zipP") zipPIdKey
716 crossMapPName = varQual gHC_PARR (fsLit "crossMapP") crossMapPIdKey
717 indexPName = varQual gHC_PARR (fsLit "!:") indexPIdKey
718 toPName = varQual gHC_PARR (fsLit "toP") toPIdKey
719 bpermutePName = varQual gHC_PARR (fsLit "bpermuteP") bpermutePIdKey
720 bpermuteDftPName = varQual gHC_PARR (fsLit "bpermuteDftP") bpermuteDftPIdKey
721 indexOfPName = varQual gHC_PARR (fsLit "indexOfP") indexOfPIdKey
724 ioTyConName, ioDataConName, thenIOName, bindIOName, returnIOName,
726 ioTyConName = tcQual gHC_IO_BASE (fsLit "IO") ioTyConKey
727 ioDataConName = conName gHC_IO_BASE (fsLit "IO") ioDataConKey
728 thenIOName = varQual gHC_IO_BASE (fsLit "thenIO") thenIOIdKey
729 bindIOName = varQual gHC_IO_BASE (fsLit "bindIO") bindIOIdKey
730 returnIOName = varQual gHC_IO_BASE (fsLit "returnIO") returnIOIdKey
731 failIOName = varQual gHC_IO_BASE (fsLit "failIO") failIOIdKey
735 printName = varQual sYSTEM_IO (fsLit "print") printIdKey
737 -- Int, Word, and Addr things
738 int8TyConName, int16TyConName, int32TyConName, int64TyConName :: Name
739 int8TyConName = tcQual gHC_INT (fsLit "Int8") int8TyConKey
740 int16TyConName = tcQual gHC_INT (fsLit "Int16") int16TyConKey
741 int32TyConName = tcQual gHC_INT (fsLit "Int32") int32TyConKey
742 int64TyConName = tcQual gHC_INT (fsLit "Int64") int64TyConKey
745 word8TyConName, word16TyConName, word32TyConName, word64TyConName,
746 wordTyConName, wordDataConName :: Name
747 word8TyConName = tcQual gHC_WORD (fsLit "Word8") word8TyConKey
748 word16TyConName = tcQual gHC_WORD (fsLit "Word16") word16TyConKey
749 word32TyConName = tcQual gHC_WORD (fsLit "Word32") word32TyConKey
750 word64TyConName = tcQual gHC_WORD (fsLit "Word64") word64TyConKey
751 wordTyConName = tcQual gHC_WORD (fsLit "Word") wordTyConKey
752 wordDataConName = conName gHC_WORD (fsLit "W#") wordDataConKey
755 ptrTyConName, funPtrTyConName :: Name
756 ptrTyConName = tcQual gHC_PTR (fsLit "Ptr") ptrTyConKey
757 funPtrTyConName = tcQual gHC_PTR (fsLit "FunPtr") funPtrTyConKey
759 -- Foreign objects and weak pointers
760 stablePtrTyConName, newStablePtrName :: Name
761 stablePtrTyConName = tcQual gHC_STABLE (fsLit "StablePtr") stablePtrTyConKey
762 newStablePtrName = varQual gHC_STABLE (fsLit "newStablePtr") newStablePtrIdKey
766 runSTRepName = varQual gHC_ST (fsLit "runSTRep") runSTRepIdKey
768 -- Recursive-do notation
769 monadFixClassName, mfixName :: Name
770 monadFixClassName = clsQual mONAD_FIX (fsLit "MonadFix") monadFixClassKey
771 mfixName = methName mONAD_FIX (fsLit "mfix") mfixIdKey
774 arrAName, composeAName, firstAName, appAName, choiceAName, loopAName :: Name
775 arrAName = varQual aRROW (fsLit "arr") arrAIdKey
776 composeAName = varQual gHC_DESUGAR (fsLit ">>>") composeAIdKey
777 firstAName = varQual aRROW (fsLit "first") firstAIdKey
778 appAName = varQual aRROW (fsLit "app") appAIdKey
779 choiceAName = varQual aRROW (fsLit "|||") choiceAIdKey
780 loopAName = varQual aRROW (fsLit "loop") loopAIdKey
782 -- Other classes, needed for type defaulting
783 monadPlusClassName, randomClassName, randomGenClassName,
784 isStringClassName :: Name
785 monadPlusClassName = clsQual mONAD (fsLit "MonadPlus") monadPlusClassKey
786 randomClassName = clsQual rANDOM (fsLit "Random") randomClassKey
787 randomGenClassName = clsQual rANDOM (fsLit "RandomGen") randomGenClassKey
788 isStringClassName = clsQual dATA_STRING (fsLit "IsString") isStringClassKey
791 objectTyConName :: Name
792 objectTyConName = tcQual dOTNET (fsLit "Object") objectTyConKey
793 -- objectTyConName was "wTcQual", but that's gone now, and
794 -- I can't see why it was wired in anyway...
795 unmarshalObjectName, marshalObjectName, marshalStringName,
796 unmarshalStringName, checkDotnetResName :: Name
797 unmarshalObjectName = varQual dOTNET (fsLit "unmarshalObject") unmarshalObjectIdKey
798 marshalObjectName = varQual dOTNET (fsLit "marshalObject") marshalObjectIdKey
799 marshalStringName = varQual dOTNET (fsLit "marshalString") marshalStringIdKey
800 unmarshalStringName = varQual dOTNET (fsLit "unmarshalString") unmarshalStringIdKey
801 checkDotnetResName = varQual dOTNET (fsLit "checkResult") checkDotnetResNameIdKey
804 %************************************************************************
806 \subsection{Local helpers}
808 %************************************************************************
810 All these are original names; hence mkOrig
813 varQual, tcQual, clsQual :: Module -> FastString -> Unique -> Name
814 varQual = mk_known_key_name varName
815 tcQual = mk_known_key_name tcName
816 clsQual = mk_known_key_name clsName
818 mk_known_key_name :: NameSpace -> Module -> FastString -> Unique -> Name
819 mk_known_key_name space modu str unique
820 = mkExternalName unique modu (mkOccNameFS space str) noSrcSpan
822 conName :: Module -> FastString -> Unique -> Name
823 conName modu occ unique
824 = mkExternalName unique modu (mkOccNameFS dataName occ) noSrcSpan
826 methName :: Module -> FastString -> Unique -> Name
827 methName modu occ unique
828 = mkExternalName unique modu (mkVarOccFS occ) noSrcSpan
831 %************************************************************************
833 \subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@}
835 %************************************************************************
836 --MetaHaskell extension hand allocate keys here
839 boundedClassKey, enumClassKey, eqClassKey, floatingClassKey,
840 fractionalClassKey, integralClassKey, monadClassKey, dataClassKey,
841 functorClassKey, numClassKey, ordClassKey, readClassKey, realClassKey,
842 realFloatClassKey, realFracClassKey, showClassKey, ixClassKey :: Unique
843 boundedClassKey = mkPreludeClassUnique 1
844 enumClassKey = mkPreludeClassUnique 2
845 eqClassKey = mkPreludeClassUnique 3
846 floatingClassKey = mkPreludeClassUnique 5
847 fractionalClassKey = mkPreludeClassUnique 6
848 integralClassKey = mkPreludeClassUnique 7
849 monadClassKey = mkPreludeClassUnique 8
850 dataClassKey = mkPreludeClassUnique 9
851 functorClassKey = mkPreludeClassUnique 10
852 numClassKey = mkPreludeClassUnique 11
853 ordClassKey = mkPreludeClassUnique 12
854 readClassKey = mkPreludeClassUnique 13
855 realClassKey = mkPreludeClassUnique 14
856 realFloatClassKey = mkPreludeClassUnique 15
857 realFracClassKey = mkPreludeClassUnique 16
858 showClassKey = mkPreludeClassUnique 17
859 ixClassKey = mkPreludeClassUnique 18
861 typeableClassKey, typeable1ClassKey, typeable2ClassKey, typeable3ClassKey,
862 typeable4ClassKey, typeable5ClassKey, typeable6ClassKey, typeable7ClassKey
864 typeableClassKey = mkPreludeClassUnique 20
865 typeable1ClassKey = mkPreludeClassUnique 21
866 typeable2ClassKey = mkPreludeClassUnique 22
867 typeable3ClassKey = mkPreludeClassUnique 23
868 typeable4ClassKey = mkPreludeClassUnique 24
869 typeable5ClassKey = mkPreludeClassUnique 25
870 typeable6ClassKey = mkPreludeClassUnique 26
871 typeable7ClassKey = mkPreludeClassUnique 27
873 monadFixClassKey :: Unique
874 monadFixClassKey = mkPreludeClassUnique 28
876 monadPlusClassKey, randomClassKey, randomGenClassKey :: Unique
877 monadPlusClassKey = mkPreludeClassUnique 30
878 randomClassKey = mkPreludeClassUnique 31
879 randomGenClassKey = mkPreludeClassUnique 32
881 isStringClassKey :: Unique
882 isStringClassKey = mkPreludeClassUnique 33
885 %************************************************************************
887 \subsubsection[Uniques-prelude-TyCons]{@Uniques@ for wired-in @TyCons@}
889 %************************************************************************
892 addrPrimTyConKey, arrayPrimTyConKey, boolTyConKey, byteArrayPrimTyConKey,
893 charPrimTyConKey, charTyConKey, doublePrimTyConKey, doubleTyConKey,
894 floatPrimTyConKey, floatTyConKey, funTyConKey, intPrimTyConKey,
895 intTyConKey, int8TyConKey, int16TyConKey, int32PrimTyConKey,
896 int32TyConKey, int64PrimTyConKey, int64TyConKey, integerTyConKey,
897 listTyConKey, foreignObjPrimTyConKey, weakPrimTyConKey,
898 mutableArrayPrimTyConKey, mutableByteArrayPrimTyConKey,
899 orderingTyConKey, mVarPrimTyConKey, ratioTyConKey, rationalTyConKey,
900 realWorldTyConKey, stablePtrPrimTyConKey, stablePtrTyConKey :: Unique
901 addrPrimTyConKey = mkPreludeTyConUnique 1
902 arrayPrimTyConKey = mkPreludeTyConUnique 3
903 boolTyConKey = mkPreludeTyConUnique 4
904 byteArrayPrimTyConKey = mkPreludeTyConUnique 5
905 charPrimTyConKey = mkPreludeTyConUnique 7
906 charTyConKey = mkPreludeTyConUnique 8
907 doublePrimTyConKey = mkPreludeTyConUnique 9
908 doubleTyConKey = mkPreludeTyConUnique 10
909 floatPrimTyConKey = mkPreludeTyConUnique 11
910 floatTyConKey = mkPreludeTyConUnique 12
911 funTyConKey = mkPreludeTyConUnique 13
912 intPrimTyConKey = mkPreludeTyConUnique 14
913 intTyConKey = mkPreludeTyConUnique 15
914 int8TyConKey = mkPreludeTyConUnique 16
915 int16TyConKey = mkPreludeTyConUnique 17
916 int32PrimTyConKey = mkPreludeTyConUnique 18
917 int32TyConKey = mkPreludeTyConUnique 19
918 int64PrimTyConKey = mkPreludeTyConUnique 20
919 int64TyConKey = mkPreludeTyConUnique 21
920 integerTyConKey = mkPreludeTyConUnique 22
921 listTyConKey = mkPreludeTyConUnique 23
922 foreignObjPrimTyConKey = mkPreludeTyConUnique 24
923 weakPrimTyConKey = mkPreludeTyConUnique 27
924 mutableArrayPrimTyConKey = mkPreludeTyConUnique 28
925 mutableByteArrayPrimTyConKey = mkPreludeTyConUnique 29
926 orderingTyConKey = mkPreludeTyConUnique 30
927 mVarPrimTyConKey = mkPreludeTyConUnique 31
928 ratioTyConKey = mkPreludeTyConUnique 32
929 rationalTyConKey = mkPreludeTyConUnique 33
930 realWorldTyConKey = mkPreludeTyConUnique 34
931 stablePtrPrimTyConKey = mkPreludeTyConUnique 35
932 stablePtrTyConKey = mkPreludeTyConUnique 36
934 anyPrimTyConKey, anyPrimTyCon1Key :: Unique
935 anyPrimTyConKey = mkPreludeTyConUnique 37
936 anyPrimTyCon1Key = mkPreludeTyConUnique 38
938 statePrimTyConKey, stableNamePrimTyConKey, stableNameTyConKey,
939 mutVarPrimTyConKey, ioTyConKey,
940 wordPrimTyConKey, wordTyConKey, word8TyConKey, word16TyConKey,
941 word32PrimTyConKey, word32TyConKey, word64PrimTyConKey, word64TyConKey,
942 liftedConKey, unliftedConKey, anyBoxConKey, kindConKey, boxityConKey,
943 typeConKey, threadIdPrimTyConKey, bcoPrimTyConKey, ptrTyConKey,
944 funPtrTyConKey, tVarPrimTyConKey :: Unique
945 statePrimTyConKey = mkPreludeTyConUnique 50
946 stableNamePrimTyConKey = mkPreludeTyConUnique 51
947 stableNameTyConKey = mkPreludeTyConUnique 52
948 mutVarPrimTyConKey = mkPreludeTyConUnique 55
949 ioTyConKey = mkPreludeTyConUnique 56
950 wordPrimTyConKey = mkPreludeTyConUnique 58
951 wordTyConKey = mkPreludeTyConUnique 59
952 word8TyConKey = mkPreludeTyConUnique 60
953 word16TyConKey = mkPreludeTyConUnique 61
954 word32PrimTyConKey = mkPreludeTyConUnique 62
955 word32TyConKey = mkPreludeTyConUnique 63
956 word64PrimTyConKey = mkPreludeTyConUnique 64
957 word64TyConKey = mkPreludeTyConUnique 65
958 liftedConKey = mkPreludeTyConUnique 66
959 unliftedConKey = mkPreludeTyConUnique 67
960 anyBoxConKey = mkPreludeTyConUnique 68
961 kindConKey = mkPreludeTyConUnique 69
962 boxityConKey = mkPreludeTyConUnique 70
963 typeConKey = mkPreludeTyConUnique 71
964 threadIdPrimTyConKey = mkPreludeTyConUnique 72
965 bcoPrimTyConKey = mkPreludeTyConUnique 73
966 ptrTyConKey = mkPreludeTyConUnique 74
967 funPtrTyConKey = mkPreludeTyConUnique 75
968 tVarPrimTyConKey = mkPreludeTyConUnique 76
970 -- Generic Type Constructors
971 crossTyConKey, plusTyConKey, genUnitTyConKey :: Unique
972 crossTyConKey = mkPreludeTyConUnique 79
973 plusTyConKey = mkPreludeTyConUnique 80
974 genUnitTyConKey = mkPreludeTyConUnique 81
976 -- Parallel array type constructor
977 parrTyConKey :: Unique
978 parrTyConKey = mkPreludeTyConUnique 82
981 objectTyConKey :: Unique
982 objectTyConKey = mkPreludeTyConUnique 83
984 eitherTyConKey :: Unique
985 eitherTyConKey = mkPreludeTyConUnique 84
987 -- Super Kinds constructors
988 tySuperKindTyConKey, coSuperKindTyConKey :: Unique
989 tySuperKindTyConKey = mkPreludeTyConUnique 85
990 coSuperKindTyConKey = mkPreludeTyConUnique 86
993 liftedTypeKindTyConKey, openTypeKindTyConKey, unliftedTypeKindTyConKey,
994 ubxTupleKindTyConKey, argTypeKindTyConKey :: Unique
995 liftedTypeKindTyConKey = mkPreludeTyConUnique 87
996 openTypeKindTyConKey = mkPreludeTyConUnique 88
997 unliftedTypeKindTyConKey = mkPreludeTyConUnique 89
998 ubxTupleKindTyConKey = mkPreludeTyConUnique 90
999 argTypeKindTyConKey = mkPreludeTyConUnique 91
1001 -- Coercion constructors
1002 symCoercionTyConKey, transCoercionTyConKey, leftCoercionTyConKey,
1003 rightCoercionTyConKey, instCoercionTyConKey, unsafeCoercionTyConKey
1005 symCoercionTyConKey = mkPreludeTyConUnique 93
1006 transCoercionTyConKey = mkPreludeTyConUnique 94
1007 leftCoercionTyConKey = mkPreludeTyConUnique 95
1008 rightCoercionTyConKey = mkPreludeTyConUnique 96
1009 instCoercionTyConKey = mkPreludeTyConUnique 97
1010 unsafeCoercionTyConKey = mkPreludeTyConUnique 98
1012 unknownTyConKey, unknown1TyConKey, unknown2TyConKey, unknown3TyConKey,
1013 opaqueTyConKey :: Unique
1014 unknownTyConKey = mkPreludeTyConUnique 99
1015 unknown1TyConKey = mkPreludeTyConUnique 130
1016 unknown2TyConKey = mkPreludeTyConUnique 131
1017 unknown3TyConKey = mkPreludeTyConUnique 132
1018 opaqueTyConKey = mkPreludeTyConUnique 133
1020 stringTyConKey :: Unique
1021 stringTyConKey = mkPreludeTyConUnique 134
1023 ---------------- Template Haskell -------------------
1024 -- USES TyConUniques 100-129
1025 -----------------------------------------------------
1027 unitTyConKey :: Unique
1028 unitTyConKey = mkTupleTyConUnique Boxed 0
1031 %************************************************************************
1033 \subsubsection[Uniques-prelude-DataCons]{@Uniques@ for wired-in @DataCons@}
1035 %************************************************************************
1038 charDataConKey, consDataConKey, doubleDataConKey, falseDataConKey,
1039 floatDataConKey, intDataConKey, nilDataConKey, ratioDataConKey,
1040 stableNameDataConKey, trueDataConKey, wordDataConKey,
1041 ioDataConKey :: Unique
1042 charDataConKey = mkPreludeDataConUnique 1
1043 consDataConKey = mkPreludeDataConUnique 2
1044 doubleDataConKey = mkPreludeDataConUnique 3
1045 falseDataConKey = mkPreludeDataConUnique 4
1046 floatDataConKey = mkPreludeDataConUnique 5
1047 intDataConKey = mkPreludeDataConUnique 6
1048 nilDataConKey = mkPreludeDataConUnique 11
1049 ratioDataConKey = mkPreludeDataConUnique 12
1050 stableNameDataConKey = mkPreludeDataConUnique 14
1051 trueDataConKey = mkPreludeDataConUnique 15
1052 wordDataConKey = mkPreludeDataConUnique 16
1053 ioDataConKey = mkPreludeDataConUnique 17
1055 -- Generic data constructors
1056 crossDataConKey, inlDataConKey, inrDataConKey, genUnitDataConKey :: Unique
1057 crossDataConKey = mkPreludeDataConUnique 20
1058 inlDataConKey = mkPreludeDataConUnique 21
1059 inrDataConKey = mkPreludeDataConUnique 22
1060 genUnitDataConKey = mkPreludeDataConUnique 23
1062 -- Data constructor for parallel arrays
1063 parrDataConKey :: Unique
1064 parrDataConKey = mkPreludeDataConUnique 24
1066 leftDataConKey, rightDataConKey :: Unique
1067 leftDataConKey = mkPreludeDataConUnique 25
1068 rightDataConKey = mkPreludeDataConUnique 26
1071 %************************************************************************
1073 \subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}
1075 %************************************************************************
1078 absentErrorIdKey, augmentIdKey, appendIdKey, buildIdKey, errorIdKey,
1079 foldlIdKey, foldrIdKey, recSelErrorIdKey,
1080 integerMinusOneIdKey, integerPlusOneIdKey,
1081 integerPlusTwoIdKey, integerZeroIdKey,
1082 int2IntegerIdKey, seqIdKey, irrefutPatErrorIdKey, eqStringIdKey,
1083 noMethodBindingErrorIdKey, nonExhaustiveGuardsErrorIdKey,
1084 runtimeErrorIdKey, parErrorIdKey, parIdKey, patErrorIdKey,
1085 realWorldPrimIdKey, recConErrorIdKey, recUpdErrorIdKey,
1087 unpackCStringUtf8IdKey, unpackCStringAppendIdKey,
1088 unpackCStringFoldrIdKey, unpackCStringIdKey :: Unique
1089 absentErrorIdKey = mkPreludeMiscIdUnique 1
1090 augmentIdKey = mkPreludeMiscIdUnique 3
1091 appendIdKey = mkPreludeMiscIdUnique 4
1092 buildIdKey = mkPreludeMiscIdUnique 5
1093 errorIdKey = mkPreludeMiscIdUnique 6
1094 foldlIdKey = mkPreludeMiscIdUnique 7
1095 foldrIdKey = mkPreludeMiscIdUnique 8
1096 recSelErrorIdKey = mkPreludeMiscIdUnique 9
1097 integerMinusOneIdKey = mkPreludeMiscIdUnique 10
1098 integerPlusOneIdKey = mkPreludeMiscIdUnique 11
1099 integerPlusTwoIdKey = mkPreludeMiscIdUnique 12
1100 integerZeroIdKey = mkPreludeMiscIdUnique 13
1101 int2IntegerIdKey = mkPreludeMiscIdUnique 14
1102 seqIdKey = mkPreludeMiscIdUnique 15
1103 irrefutPatErrorIdKey = mkPreludeMiscIdUnique 16
1104 eqStringIdKey = mkPreludeMiscIdUnique 17
1105 noMethodBindingErrorIdKey = mkPreludeMiscIdUnique 18
1106 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 19
1107 runtimeErrorIdKey = mkPreludeMiscIdUnique 20
1108 parErrorIdKey = mkPreludeMiscIdUnique 21
1109 parIdKey = mkPreludeMiscIdUnique 22
1110 patErrorIdKey = mkPreludeMiscIdUnique 23
1111 realWorldPrimIdKey = mkPreludeMiscIdUnique 24
1112 recConErrorIdKey = mkPreludeMiscIdUnique 25
1113 recUpdErrorIdKey = mkPreludeMiscIdUnique 26
1114 traceIdKey = mkPreludeMiscIdUnique 27
1115 unpackCStringUtf8IdKey = mkPreludeMiscIdUnique 28
1116 unpackCStringAppendIdKey = mkPreludeMiscIdUnique 29
1117 unpackCStringFoldrIdKey = mkPreludeMiscIdUnique 30
1118 unpackCStringIdKey = mkPreludeMiscIdUnique 31
1120 unsafeCoerceIdKey, concatIdKey, filterIdKey, zipIdKey, bindIOIdKey,
1121 returnIOIdKey, deRefStablePtrIdKey, newStablePtrIdKey,
1122 smallIntegerIdKey, plusIntegerIdKey, timesIntegerIdKey,
1123 printIdKey, failIOIdKey, nullAddrIdKey, voidArgIdKey,
1124 fstIdKey, sndIdKey, otherwiseIdKey, assertIdKey, runSTRepIdKey :: Unique
1125 unsafeCoerceIdKey = mkPreludeMiscIdUnique 32
1126 concatIdKey = mkPreludeMiscIdUnique 33
1127 filterIdKey = mkPreludeMiscIdUnique 34
1128 zipIdKey = mkPreludeMiscIdUnique 35
1129 bindIOIdKey = mkPreludeMiscIdUnique 36
1130 returnIOIdKey = mkPreludeMiscIdUnique 37
1131 deRefStablePtrIdKey = mkPreludeMiscIdUnique 38
1132 newStablePtrIdKey = mkPreludeMiscIdUnique 39
1133 smallIntegerIdKey = mkPreludeMiscIdUnique 40
1134 plusIntegerIdKey = mkPreludeMiscIdUnique 41
1135 timesIntegerIdKey = mkPreludeMiscIdUnique 42
1136 printIdKey = mkPreludeMiscIdUnique 43
1137 failIOIdKey = mkPreludeMiscIdUnique 44
1138 nullAddrIdKey = mkPreludeMiscIdUnique 46
1139 voidArgIdKey = mkPreludeMiscIdUnique 47
1140 fstIdKey = mkPreludeMiscIdUnique 49
1141 sndIdKey = mkPreludeMiscIdUnique 50
1142 otherwiseIdKey = mkPreludeMiscIdUnique 51
1143 assertIdKey = mkPreludeMiscIdUnique 53
1144 runSTRepIdKey = mkPreludeMiscIdUnique 54
1146 rootMainKey, runMainKey :: Unique
1147 rootMainKey = mkPreludeMiscIdUnique 55
1148 runMainKey = mkPreludeMiscIdUnique 56
1150 andIdKey, orIdKey, thenIOIdKey, lazyIdKey, assertErrorIdKey :: Unique
1151 andIdKey = mkPreludeMiscIdUnique 57
1152 orIdKey = mkPreludeMiscIdUnique 58
1153 thenIOIdKey = mkPreludeMiscIdUnique 59
1154 lazyIdKey = mkPreludeMiscIdUnique 60
1155 assertErrorIdKey = mkPreludeMiscIdUnique 61
1157 breakpointIdKey, breakpointCondIdKey, breakpointAutoIdKey,
1158 breakpointJumpIdKey, breakpointCondJumpIdKey,
1159 breakpointAutoJumpIdKey :: Unique
1160 breakpointIdKey = mkPreludeMiscIdUnique 62
1161 breakpointCondIdKey = mkPreludeMiscIdUnique 63
1162 breakpointAutoIdKey = mkPreludeMiscIdUnique 64
1163 breakpointJumpIdKey = mkPreludeMiscIdUnique 65
1164 breakpointCondJumpIdKey = mkPreludeMiscIdUnique 66
1165 breakpointAutoJumpIdKey = mkPreludeMiscIdUnique 67
1167 inlineIdKey :: Unique
1168 inlineIdKey = mkPreludeMiscIdUnique 68
1170 mapIdKey, groupWithIdKey :: Unique
1171 mapIdKey = mkPreludeMiscIdUnique 69
1172 groupWithIdKey = mkPreludeMiscIdUnique 70
1174 -- Parallel array functions
1175 singletonPIdKey, nullPIdKey, lengthPIdKey, replicatePIdKey, mapPIdKey,
1176 filterPIdKey, zipPIdKey, crossMapPIdKey, indexPIdKey, toPIdKey,
1177 enumFromToPIdKey, enumFromThenToPIdKey,
1178 bpermutePIdKey, bpermuteDftPIdKey, indexOfPIdKey :: Unique
1179 singletonPIdKey = mkPreludeMiscIdUnique 79
1180 nullPIdKey = mkPreludeMiscIdUnique 80
1181 lengthPIdKey = mkPreludeMiscIdUnique 81
1182 replicatePIdKey = mkPreludeMiscIdUnique 82
1183 mapPIdKey = mkPreludeMiscIdUnique 83
1184 filterPIdKey = mkPreludeMiscIdUnique 84
1185 zipPIdKey = mkPreludeMiscIdUnique 85
1186 crossMapPIdKey = mkPreludeMiscIdUnique 86
1187 indexPIdKey = mkPreludeMiscIdUnique 87
1188 toPIdKey = mkPreludeMiscIdUnique 88
1189 enumFromToPIdKey = mkPreludeMiscIdUnique 89
1190 enumFromThenToPIdKey = mkPreludeMiscIdUnique 90
1191 bpermutePIdKey = mkPreludeMiscIdUnique 91
1192 bpermuteDftPIdKey = mkPreludeMiscIdUnique 92
1193 indexOfPIdKey = mkPreludeMiscIdUnique 93
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 ]