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
134 applicativeClassName,
136 traversableClassName,
139 negateName, minusName,
140 fromRationalName, fromIntegerName,
147 enumFromName, enumFromThenName,
148 enumFromThenToName, enumFromToName,
149 enumFromToPName, enumFromThenToPName,
152 thenIOName, bindIOName, returnIOName, failIOName,
153 failMName, bindMName, thenMName, returnMName,
159 arrAName, composeAName, firstAName,
160 appAName, choiceAName, loopAName,
178 unpackCStringName, unpackCStringAppendName,
179 unpackCStringFoldrName, unpackCStringUtf8Name,
182 concatName, filterName, mapName,
183 zipName, foldrName, buildName, augmentName, appendName,
185 -- Parallel array operations
186 nullPName, lengthPName, replicatePName, singletonPName, mapPName,
187 filterPName, zipPName, crossMapPName, indexPName,
188 toPName, emptyPName, appPName,
190 -- FFI primitive types that are not wired-in.
191 stablePtrTyConName, ptrTyConName, funPtrTyConName,
192 int8TyConName, int16TyConName, int32TyConName, int64TyConName,
193 wordTyConName, word8TyConName, word16TyConName, word32TyConName, word64TyConName,
196 otherwiseIdName, inlineIdName,
197 plusIntegerName, timesIntegerName,
198 eqStringName, assertName, breakpointName, breakpointCondName,
199 breakpointAutoName, opaqueTyConName,
200 assertErrorName, runSTRepName,
201 printName, fstName, sndName,
204 monadFixClassName, mfixName,
207 randomClassName, randomGenClassName, monadPlusClassName,
209 -- Annotation type checking
210 toAnnotationWrapperName
213 , eitherTyConName, leftDataConName, rightDataConName
216 , objectTyConName, marshalObjectName, unmarshalObjectName
217 , marshalStringName, unmarshalStringName, checkDotnetResName
220 genericTyConNames :: [Name]
221 genericTyConNames = [crossTyConName, plusTyConName, genUnitTyConName]
225 %************************************************************************
227 \subsection{Module names}
229 %************************************************************************
232 --MetaHaskell Extension Add a new module here
235 pRELUDE = mkBaseModule_ pRELUDE_NAME
237 gHC_PRIM, gHC_TYPES, gHC_BOOL, gHC_UNIT, gHC_ORDERING, gHC_GENERICS,
239 gHC_CLASSES, gHC_BASE, gHC_ENUM,
240 gHC_SHOW, gHC_READ, gHC_NUM, gHC_INTEGER, gHC_INTEGER_TYPE, gHC_LIST, gHC_PARR,
241 gHC_TUPLE, dATA_TUPLE, dATA_EITHER, dATA_STRING, dATA_FOLDABLE, dATA_TRAVERSABLE,
242 gHC_PACK, gHC_CONC, gHC_IO, gHC_IO_Exception,
243 gHC_ST, gHC_ARR, gHC_STABLE, gHC_ADDR, gHC_PTR, gHC_ERR, gHC_REAL,
244 gHC_FLOAT, gHC_TOP_HANDLER, sYSTEM_IO, dYNAMIC, tYPEABLE, gENERICS,
245 dOTNET, rEAD_PREC, lEX, gHC_INT, gHC_WORD, mONAD, mONAD_FIX, aRROW, cONTROL_APPLICATIVE,
246 gHC_DESUGAR, rANDOM, gHC_EXTS, cONTROL_EXCEPTION_BASE :: Module
248 gHC_PRIM = mkPrimModule (fsLit "GHC.Prim") -- Primitive types and values
249 gHC_TYPES = mkPrimModule (fsLit "GHC.Types")
250 gHC_UNIT = mkPrimModule (fsLit "GHC.Unit")
251 gHC_BOOL = mkPrimModule (fsLit "GHC.Bool")
252 gHC_ORDERING = mkPrimModule (fsLit "GHC.Ordering")
253 gHC_GENERICS = mkPrimModule (fsLit "GHC.Generics")
254 gHC_MAGIC = mkPrimModule (fsLit "GHC.Magic")
256 gHC_CLASSES = mkBaseModule (fsLit "GHC.Classes")
257 gHC_BASE = mkBaseModule (fsLit "GHC.Base")
258 gHC_ENUM = mkBaseModule (fsLit "GHC.Enum")
259 gHC_SHOW = mkBaseModule (fsLit "GHC.Show")
260 gHC_READ = mkBaseModule (fsLit "GHC.Read")
261 gHC_NUM = mkBaseModule (fsLit "GHC.Num")
262 gHC_INTEGER = mkIntegerModule (fsLit "GHC.Integer")
263 gHC_INTEGER_TYPE= mkIntegerModule (fsLit "GHC.Integer.Type")
264 gHC_LIST = mkBaseModule (fsLit "GHC.List")
265 gHC_PARR = mkBaseModule (fsLit "GHC.PArr")
266 gHC_TUPLE = mkPrimModule (fsLit "GHC.Tuple")
267 dATA_TUPLE = mkBaseModule (fsLit "Data.Tuple")
268 dATA_EITHER = mkBaseModule (fsLit "Data.Either")
269 dATA_STRING = mkBaseModule (fsLit "Data.String")
270 dATA_FOLDABLE = mkBaseModule (fsLit "Data.Foldable")
271 dATA_TRAVERSABLE= mkBaseModule (fsLit "Data.Traversable")
272 gHC_PACK = mkBaseModule (fsLit "GHC.Pack")
273 gHC_CONC = mkBaseModule (fsLit "GHC.Conc")
274 gHC_IO = mkBaseModule (fsLit "GHC.IO")
275 gHC_IO_Exception = mkBaseModule (fsLit "GHC.IO.Exception")
276 gHC_ST = mkBaseModule (fsLit "GHC.ST")
277 gHC_ARR = mkBaseModule (fsLit "GHC.Arr")
278 gHC_STABLE = mkBaseModule (fsLit "GHC.Stable")
279 gHC_ADDR = mkBaseModule (fsLit "GHC.Addr")
280 gHC_PTR = mkBaseModule (fsLit "GHC.Ptr")
281 gHC_ERR = mkBaseModule (fsLit "GHC.Err")
282 gHC_REAL = mkBaseModule (fsLit "GHC.Real")
283 gHC_FLOAT = mkBaseModule (fsLit "GHC.Float")
284 gHC_TOP_HANDLER = mkBaseModule (fsLit "GHC.TopHandler")
285 sYSTEM_IO = mkBaseModule (fsLit "System.IO")
286 dYNAMIC = mkBaseModule (fsLit "Data.Dynamic")
287 tYPEABLE = mkBaseModule (fsLit "Data.Typeable")
288 gENERICS = mkBaseModule (fsLit "Data.Data")
289 dOTNET = mkBaseModule (fsLit "GHC.Dotnet")
290 rEAD_PREC = mkBaseModule (fsLit "Text.ParserCombinators.ReadPrec")
291 lEX = mkBaseModule (fsLit "Text.Read.Lex")
292 gHC_INT = mkBaseModule (fsLit "GHC.Int")
293 gHC_WORD = mkBaseModule (fsLit "GHC.Word")
294 mONAD = mkBaseModule (fsLit "Control.Monad")
295 mONAD_FIX = mkBaseModule (fsLit "Control.Monad.Fix")
296 aRROW = mkBaseModule (fsLit "Control.Arrow")
297 cONTROL_APPLICATIVE = mkBaseModule (fsLit "Control.Applicative")
298 gHC_DESUGAR = mkBaseModule (fsLit "GHC.Desugar")
299 rANDOM = mkBaseModule (fsLit "System.Random")
300 gHC_EXTS = mkBaseModule (fsLit "GHC.Exts")
301 cONTROL_EXCEPTION_BASE = mkBaseModule (fsLit "Control.Exception.Base")
303 mAIN, rOOT_MAIN :: Module
304 mAIN = mkMainModule_ mAIN_NAME
305 rOOT_MAIN = mkMainModule (fsLit ":Main") -- Root module for initialisation
307 -- The ':xxx' makes a module name that the user can never
308 -- use himself. The z-encoding for ':' is "ZC", so the z-encoded
309 -- module name still starts with a capital letter, which keeps
310 -- the z-encoded version consistent.
311 iNTERACTIVE :: Module
312 iNTERACTIVE = mkMainModule (fsLit ":Interactive")
314 pRELUDE_NAME, mAIN_NAME :: ModuleName
315 pRELUDE_NAME = mkModuleNameFS (fsLit "Prelude")
316 mAIN_NAME = mkModuleNameFS (fsLit "Main")
318 mkPrimModule :: FastString -> Module
319 mkPrimModule m = mkModule primPackageId (mkModuleNameFS m)
321 mkIntegerModule :: FastString -> Module
322 mkIntegerModule m = mkModule integerPackageId (mkModuleNameFS m)
324 mkBaseModule :: FastString -> Module
325 mkBaseModule m = mkModule basePackageId (mkModuleNameFS m)
327 mkBaseModule_ :: ModuleName -> Module
328 mkBaseModule_ m = mkModule basePackageId m
330 mkMainModule :: FastString -> Module
331 mkMainModule m = mkModule mainPackageId (mkModuleNameFS m)
333 mkMainModule_ :: ModuleName -> Module
334 mkMainModule_ m = mkModule mainPackageId m
337 %************************************************************************
339 \subsection{Constructing the names of tuples
341 %************************************************************************
344 mkTupleModule :: Boxity -> Arity -> Module
345 mkTupleModule Boxed 0 = gHC_UNIT
346 mkTupleModule Boxed _ = gHC_TUPLE
347 mkTupleModule Unboxed _ = gHC_PRIM
351 %************************************************************************
355 %************************************************************************
358 main_RDR_Unqual :: RdrName
359 main_RDR_Unqual = mkUnqual varName (fsLit "main")
360 -- We definitely don't want an Orig RdrName, because
361 -- main might, in principle, be imported into module Main
363 forall_tv_RDR, dot_tv_RDR :: RdrName
364 forall_tv_RDR = mkUnqual tvName (fsLit "forall")
365 dot_tv_RDR = mkUnqual tvName (fsLit ".")
367 eq_RDR, ge_RDR, ne_RDR, le_RDR, lt_RDR, gt_RDR, compare_RDR,
368 ltTag_RDR, eqTag_RDR, gtTag_RDR :: RdrName
369 eq_RDR = nameRdrName eqName
370 ge_RDR = nameRdrName geName
371 ne_RDR = varQual_RDR gHC_CLASSES (fsLit "/=")
372 le_RDR = varQual_RDR gHC_CLASSES (fsLit "<=")
373 lt_RDR = varQual_RDR gHC_CLASSES (fsLit "<")
374 gt_RDR = varQual_RDR gHC_CLASSES (fsLit ">")
375 compare_RDR = varQual_RDR gHC_CLASSES (fsLit "compare")
376 ltTag_RDR = dataQual_RDR gHC_ORDERING (fsLit "LT")
377 eqTag_RDR = dataQual_RDR gHC_ORDERING (fsLit "EQ")
378 gtTag_RDR = dataQual_RDR gHC_ORDERING (fsLit "GT")
380 eqClass_RDR, numClass_RDR, ordClass_RDR, enumClass_RDR, monadClass_RDR
382 eqClass_RDR = nameRdrName eqClassName
383 numClass_RDR = nameRdrName numClassName
384 ordClass_RDR = nameRdrName ordClassName
385 enumClass_RDR = nameRdrName enumClassName
386 monadClass_RDR = nameRdrName monadClassName
388 map_RDR, append_RDR :: RdrName
389 map_RDR = varQual_RDR gHC_BASE (fsLit "map")
390 append_RDR = varQual_RDR gHC_BASE (fsLit "++")
392 foldr_RDR, build_RDR, returnM_RDR, bindM_RDR, failM_RDR :: RdrName
393 foldr_RDR = nameRdrName foldrName
394 build_RDR = nameRdrName buildName
395 returnM_RDR = nameRdrName returnMName
396 bindM_RDR = nameRdrName bindMName
397 failM_RDR = nameRdrName failMName
399 left_RDR, right_RDR :: RdrName
400 left_RDR = nameRdrName leftDataConName
401 right_RDR = nameRdrName rightDataConName
403 fromEnum_RDR, toEnum_RDR :: RdrName
404 fromEnum_RDR = varQual_RDR gHC_ENUM (fsLit "fromEnum")
405 toEnum_RDR = varQual_RDR gHC_ENUM (fsLit "toEnum")
407 enumFrom_RDR, enumFromTo_RDR, enumFromThen_RDR, enumFromThenTo_RDR :: RdrName
408 enumFrom_RDR = nameRdrName enumFromName
409 enumFromTo_RDR = nameRdrName enumFromToName
410 enumFromThen_RDR = nameRdrName enumFromThenName
411 enumFromThenTo_RDR = nameRdrName enumFromThenToName
413 ratioDataCon_RDR, plusInteger_RDR, timesInteger_RDR :: RdrName
414 ratioDataCon_RDR = nameRdrName ratioDataConName
415 plusInteger_RDR = nameRdrName plusIntegerName
416 timesInteger_RDR = nameRdrName timesIntegerName
418 ioDataCon_RDR :: RdrName
419 ioDataCon_RDR = nameRdrName ioDataConName
421 eqString_RDR, unpackCString_RDR, unpackCStringFoldr_RDR,
422 unpackCStringUtf8_RDR :: RdrName
423 eqString_RDR = nameRdrName eqStringName
424 unpackCString_RDR = nameRdrName unpackCStringName
425 unpackCStringFoldr_RDR = nameRdrName unpackCStringFoldrName
426 unpackCStringUtf8_RDR = nameRdrName unpackCStringUtf8Name
428 newStablePtr_RDR, wordDataCon_RDR :: RdrName
429 newStablePtr_RDR = nameRdrName newStablePtrName
430 wordDataCon_RDR = dataQual_RDR gHC_WORD (fsLit "W#")
432 bindIO_RDR, returnIO_RDR :: RdrName
433 bindIO_RDR = nameRdrName bindIOName
434 returnIO_RDR = nameRdrName returnIOName
436 fromInteger_RDR, fromRational_RDR, minus_RDR, times_RDR, plus_RDR :: RdrName
437 fromInteger_RDR = nameRdrName fromIntegerName
438 fromRational_RDR = nameRdrName fromRationalName
439 minus_RDR = nameRdrName minusName
440 times_RDR = varQual_RDR gHC_NUM (fsLit "*")
441 plus_RDR = varQual_RDR gHC_NUM (fsLit "+")
443 fromString_RDR :: RdrName
444 fromString_RDR = nameRdrName fromStringName
446 compose_RDR :: RdrName
447 compose_RDR = varQual_RDR gHC_BASE (fsLit ".")
449 not_RDR, getTag_RDR, succ_RDR, pred_RDR, minBound_RDR, maxBound_RDR,
450 and_RDR, range_RDR, inRange_RDR, index_RDR,
451 unsafeIndex_RDR, unsafeRangeSize_RDR :: RdrName
452 and_RDR = varQual_RDR gHC_CLASSES (fsLit "&&")
453 not_RDR = varQual_RDR gHC_CLASSES (fsLit "not")
454 getTag_RDR = varQual_RDR gHC_BASE (fsLit "getTag")
455 succ_RDR = varQual_RDR gHC_ENUM (fsLit "succ")
456 pred_RDR = varQual_RDR gHC_ENUM (fsLit "pred")
457 minBound_RDR = varQual_RDR gHC_ENUM (fsLit "minBound")
458 maxBound_RDR = varQual_RDR gHC_ENUM (fsLit "maxBound")
459 range_RDR = varQual_RDR gHC_ARR (fsLit "range")
460 inRange_RDR = varQual_RDR gHC_ARR (fsLit "inRange")
461 index_RDR = varQual_RDR gHC_ARR (fsLit "index")
462 unsafeIndex_RDR = varQual_RDR gHC_ARR (fsLit "unsafeIndex")
463 unsafeRangeSize_RDR = varQual_RDR gHC_ARR (fsLit "unsafeRangeSize")
465 readList_RDR, readListDefault_RDR, readListPrec_RDR, readListPrecDefault_RDR,
466 readPrec_RDR, parens_RDR, choose_RDR, lexP_RDR :: RdrName
467 readList_RDR = varQual_RDR gHC_READ (fsLit "readList")
468 readListDefault_RDR = varQual_RDR gHC_READ (fsLit "readListDefault")
469 readListPrec_RDR = varQual_RDR gHC_READ (fsLit "readListPrec")
470 readListPrecDefault_RDR = varQual_RDR gHC_READ (fsLit "readListPrecDefault")
471 readPrec_RDR = varQual_RDR gHC_READ (fsLit "readPrec")
472 parens_RDR = varQual_RDR gHC_READ (fsLit "parens")
473 choose_RDR = varQual_RDR gHC_READ (fsLit "choose")
474 lexP_RDR = varQual_RDR gHC_READ (fsLit "lexP")
476 punc_RDR, ident_RDR, symbol_RDR :: RdrName
477 punc_RDR = dataQual_RDR lEX (fsLit "Punc")
478 ident_RDR = dataQual_RDR lEX (fsLit "Ident")
479 symbol_RDR = dataQual_RDR lEX (fsLit "Symbol")
481 step_RDR, alt_RDR, reset_RDR, prec_RDR :: RdrName
482 step_RDR = varQual_RDR rEAD_PREC (fsLit "step")
483 alt_RDR = varQual_RDR rEAD_PREC (fsLit "+++")
484 reset_RDR = varQual_RDR rEAD_PREC (fsLit "reset")
485 prec_RDR = varQual_RDR rEAD_PREC (fsLit "prec")
487 showList_RDR, showList___RDR, showsPrec_RDR, showString_RDR,
488 showSpace_RDR, showParen_RDR :: RdrName
489 showList_RDR = varQual_RDR gHC_SHOW (fsLit "showList")
490 showList___RDR = varQual_RDR gHC_SHOW (fsLit "showList__")
491 showsPrec_RDR = varQual_RDR gHC_SHOW (fsLit "showsPrec")
492 showString_RDR = varQual_RDR gHC_SHOW (fsLit "showString")
493 showSpace_RDR = varQual_RDR gHC_SHOW (fsLit "showSpace")
494 showParen_RDR = varQual_RDR gHC_SHOW (fsLit "showParen")
496 typeOf_RDR, mkTypeRep_RDR, mkTyConRep_RDR :: RdrName
497 typeOf_RDR = varQual_RDR tYPEABLE (fsLit "typeOf")
498 mkTypeRep_RDR = varQual_RDR tYPEABLE (fsLit "mkTyConApp")
499 mkTyConRep_RDR = varQual_RDR tYPEABLE (fsLit "mkTyCon")
501 undefined_RDR :: RdrName
502 undefined_RDR = varQual_RDR gHC_ERR (fsLit "undefined")
504 crossDataCon_RDR, inlDataCon_RDR, inrDataCon_RDR, genUnitDataCon_RDR :: RdrName
505 crossDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit ":*:")
506 inlDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Inl")
507 inrDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Inr")
508 genUnitDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Unit")
510 fmap_RDR, pure_RDR, ap_RDR, foldable_foldr_RDR, traverse_RDR :: RdrName
511 fmap_RDR = varQual_RDR gHC_BASE (fsLit "fmap")
512 pure_RDR = varQual_RDR cONTROL_APPLICATIVE (fsLit "pure")
513 ap_RDR = varQual_RDR cONTROL_APPLICATIVE (fsLit "<*>")
514 foldable_foldr_RDR = varQual_RDR dATA_FOLDABLE (fsLit "foldr")
515 traverse_RDR = varQual_RDR dATA_TRAVERSABLE (fsLit "traverse")
517 ----------------------
518 varQual_RDR, tcQual_RDR, clsQual_RDR, dataQual_RDR
519 :: Module -> FastString -> RdrName
520 varQual_RDR mod str = mkOrig mod (mkOccNameFS varName str)
521 tcQual_RDR mod str = mkOrig mod (mkOccNameFS tcName str)
522 clsQual_RDR mod str = mkOrig mod (mkOccNameFS clsName str)
523 dataQual_RDR mod str = mkOrig mod (mkOccNameFS dataName str)
526 %************************************************************************
528 \subsection{Known-key names}
530 %************************************************************************
532 Many of these Names are not really "built in", but some parts of the
533 compiler (notably the deriving mechanism) need to mention their names,
534 and it's convenient to write them all down in one place.
536 --MetaHaskell Extension add the constrs and the lower case case
537 -- guys as well (perhaps) e.g. see trueDataConName below
541 runMainIOName :: Name
542 runMainIOName = varQual gHC_TOP_HANDLER (fsLit "runMainIO") runMainKey
544 orderingTyConName :: Name
545 orderingTyConName = tcQual gHC_ORDERING (fsLit "Ordering") orderingTyConKey
547 eitherTyConName, leftDataConName, rightDataConName :: Name
548 eitherTyConName = tcQual dATA_EITHER (fsLit "Either") eitherTyConKey
549 leftDataConName = conName dATA_EITHER (fsLit "Left") leftDataConKey
550 rightDataConName = conName dATA_EITHER (fsLit "Right") rightDataConKey
553 crossTyConName, plusTyConName, genUnitTyConName :: Name
554 crossTyConName = tcQual gHC_GENERICS (fsLit ":*:") crossTyConKey
555 plusTyConName = tcQual gHC_GENERICS (fsLit ":+:") plusTyConKey
556 genUnitTyConName = tcQual gHC_GENERICS (fsLit "Unit") genUnitTyConKey
558 -- Base strings Strings
559 unpackCStringName, unpackCStringAppendName, unpackCStringFoldrName,
560 unpackCStringUtf8Name, eqStringName, stringTyConName :: Name
561 unpackCStringName = varQual gHC_BASE (fsLit "unpackCString#") unpackCStringIdKey
562 unpackCStringAppendName = varQual gHC_BASE (fsLit "unpackAppendCString#") unpackCStringAppendIdKey
563 unpackCStringFoldrName = varQual gHC_BASE (fsLit "unpackFoldrCString#") unpackCStringFoldrIdKey
564 unpackCStringUtf8Name = varQual gHC_BASE (fsLit "unpackCStringUtf8#") unpackCStringUtf8IdKey
565 eqStringName = varQual gHC_BASE (fsLit "eqString") eqStringIdKey
566 stringTyConName = tcQual gHC_BASE (fsLit "String") stringTyConKey
568 -- The 'inline' function
570 inlineIdName = varQual gHC_MAGIC (fsLit "inline") inlineIdKey
572 -- Base classes (Eq, Ord, Functor)
573 eqClassName, eqName, ordClassName, geName, functorClassName :: Name
574 eqClassName = clsQual gHC_CLASSES (fsLit "Eq") eqClassKey
575 eqName = methName gHC_CLASSES (fsLit "==") eqClassOpKey
576 ordClassName = clsQual gHC_CLASSES (fsLit "Ord") ordClassKey
577 geName = methName gHC_CLASSES (fsLit ">=") geClassOpKey
578 functorClassName = clsQual gHC_BASE (fsLit "Functor") functorClassKey
581 monadClassName, thenMName, bindMName, returnMName, failMName :: Name
582 monadClassName = clsQual gHC_BASE (fsLit "Monad") monadClassKey
583 thenMName = methName gHC_BASE (fsLit ">>") thenMClassOpKey
584 bindMName = methName gHC_BASE (fsLit ">>=") bindMClassOpKey
585 returnMName = methName gHC_BASE (fsLit "return") returnMClassOpKey
586 failMName = methName gHC_BASE (fsLit "fail") failMClassOpKey
588 -- Classes (Applicative, Foldable, Traversable)
589 applicativeClassName, foldableClassName, traversableClassName :: Name
590 applicativeClassName = clsQual cONTROL_APPLICATIVE (fsLit "Applicative") applicativeClassKey
591 foldableClassName = clsQual dATA_FOLDABLE (fsLit "Foldable") foldableClassKey
592 traversableClassName = clsQual dATA_TRAVERSABLE (fsLit "Traversable") traversableClassKey
594 -- Functions for GHC extensions
595 groupWithName :: Name
596 groupWithName = varQual gHC_EXTS (fsLit "groupWith") groupWithIdKey
598 -- Random PrelBase functions
599 fromStringName, otherwiseIdName, foldrName, buildName, augmentName,
600 mapName, appendName, assertName,
601 breakpointName, breakpointCondName, breakpointAutoName,
602 opaqueTyConName :: Name
603 fromStringName = methName dATA_STRING (fsLit "fromString") fromStringClassOpKey
604 otherwiseIdName = varQual gHC_BASE (fsLit "otherwise") otherwiseIdKey
605 foldrName = varQual gHC_BASE (fsLit "foldr") foldrIdKey
606 buildName = varQual gHC_BASE (fsLit "build") buildIdKey
607 augmentName = varQual gHC_BASE (fsLit "augment") augmentIdKey
608 mapName = varQual gHC_BASE (fsLit "map") mapIdKey
609 appendName = varQual gHC_BASE (fsLit "++") appendIdKey
610 assertName = varQual gHC_BASE (fsLit "assert") assertIdKey
611 breakpointName = varQual gHC_BASE (fsLit "breakpoint") breakpointIdKey
612 breakpointCondName= varQual gHC_BASE (fsLit "breakpointCond") breakpointCondIdKey
613 breakpointAutoName= varQual gHC_BASE (fsLit "breakpointAuto") breakpointAutoIdKey
614 opaqueTyConName = tcQual gHC_BASE (fsLit "Opaque") opaqueTyConKey
616 breakpointJumpName :: Name
620 (mkOccNameFS varName (fsLit "breakpointJump"))
622 breakpointCondJumpName :: Name
623 breakpointCondJumpName
625 breakpointCondJumpIdKey
626 (mkOccNameFS varName (fsLit "breakpointCondJump"))
628 breakpointAutoJumpName :: Name
629 breakpointAutoJumpName
631 breakpointAutoJumpIdKey
632 (mkOccNameFS varName (fsLit "breakpointAutoJump"))
636 fstName, sndName :: Name
637 fstName = varQual dATA_TUPLE (fsLit "fst") fstIdKey
638 sndName = varQual dATA_TUPLE (fsLit "snd") sndIdKey
641 numClassName, fromIntegerName, minusName, negateName, plusIntegerName,
643 integerTyConName, smallIntegerName :: Name
644 numClassName = clsQual gHC_NUM (fsLit "Num") numClassKey
645 fromIntegerName = methName gHC_NUM (fsLit "fromInteger") fromIntegerClassOpKey
646 minusName = methName gHC_NUM (fsLit "-") minusClassOpKey
647 negateName = methName gHC_NUM (fsLit "negate") negateClassOpKey
648 plusIntegerName = varQual gHC_INTEGER (fsLit "plusInteger") plusIntegerIdKey
649 timesIntegerName = varQual gHC_INTEGER (fsLit "timesInteger") timesIntegerIdKey
650 integerTyConName = tcQual gHC_INTEGER_TYPE (fsLit "Integer") integerTyConKey
651 smallIntegerName = varQual gHC_INTEGER (fsLit "smallInteger") smallIntegerIdKey
653 -- PrelReal types and classes
654 rationalTyConName, ratioTyConName, ratioDataConName, realClassName,
655 integralClassName, realFracClassName, fractionalClassName,
656 fromRationalName :: Name
657 rationalTyConName = tcQual gHC_REAL (fsLit "Rational") rationalTyConKey
658 ratioTyConName = tcQual gHC_REAL (fsLit "Ratio") ratioTyConKey
659 ratioDataConName = conName gHC_REAL (fsLit ":%") ratioDataConKey
660 realClassName = clsQual gHC_REAL (fsLit "Real") realClassKey
661 integralClassName = clsQual gHC_REAL (fsLit "Integral") integralClassKey
662 realFracClassName = clsQual gHC_REAL (fsLit "RealFrac") realFracClassKey
663 fractionalClassName = clsQual gHC_REAL (fsLit "Fractional") fractionalClassKey
664 fromRationalName = methName gHC_REAL (fsLit "fromRational") fromRationalClassOpKey
667 floatingClassName, realFloatClassName :: Name
668 floatingClassName = clsQual gHC_FLOAT (fsLit "Floating") floatingClassKey
669 realFloatClassName = clsQual gHC_FLOAT (fsLit "RealFloat") realFloatClassKey
673 ixClassName = clsQual gHC_ARR (fsLit "Ix") ixClassKey
676 typeableClassName, typeable1ClassName, typeable2ClassName,
677 typeable3ClassName, typeable4ClassName, typeable5ClassName,
678 typeable6ClassName, typeable7ClassName :: Name
679 typeableClassName = clsQual tYPEABLE (fsLit "Typeable") typeableClassKey
680 typeable1ClassName = clsQual tYPEABLE (fsLit "Typeable1") typeable1ClassKey
681 typeable2ClassName = clsQual tYPEABLE (fsLit "Typeable2") typeable2ClassKey
682 typeable3ClassName = clsQual tYPEABLE (fsLit "Typeable3") typeable3ClassKey
683 typeable4ClassName = clsQual tYPEABLE (fsLit "Typeable4") typeable4ClassKey
684 typeable5ClassName = clsQual tYPEABLE (fsLit "Typeable5") typeable5ClassKey
685 typeable6ClassName = clsQual tYPEABLE (fsLit "Typeable6") typeable6ClassKey
686 typeable7ClassName = clsQual tYPEABLE (fsLit "Typeable7") typeable7ClassKey
688 typeableClassNames :: [Name]
689 typeableClassNames = [ typeableClassName, typeable1ClassName, typeable2ClassName
690 , typeable3ClassName, typeable4ClassName, typeable5ClassName
691 , typeable6ClassName, typeable7ClassName ]
694 dataClassName :: Name
695 dataClassName = clsQual gENERICS (fsLit "Data") dataClassKey
698 assertErrorName :: Name
699 assertErrorName = varQual gHC_IO_Exception (fsLit "assertError") assertErrorIdKey
701 -- Enum module (Enum, Bounded)
702 enumClassName, enumFromName, enumFromToName, enumFromThenName,
703 enumFromThenToName, boundedClassName :: Name
704 enumClassName = clsQual gHC_ENUM (fsLit "Enum") enumClassKey
705 enumFromName = methName gHC_ENUM (fsLit "enumFrom") enumFromClassOpKey
706 enumFromToName = methName gHC_ENUM (fsLit "enumFromTo") enumFromToClassOpKey
707 enumFromThenName = methName gHC_ENUM (fsLit "enumFromThen") enumFromThenClassOpKey
708 enumFromThenToName = methName gHC_ENUM (fsLit "enumFromThenTo") enumFromThenToClassOpKey
709 boundedClassName = clsQual gHC_ENUM (fsLit "Bounded") boundedClassKey
712 concatName, filterName, zipName :: Name
713 concatName = varQual gHC_LIST (fsLit "concat") concatIdKey
714 filterName = varQual gHC_LIST (fsLit "filter") filterIdKey
715 zipName = varQual gHC_LIST (fsLit "zip") zipIdKey
718 showClassName :: Name
719 showClassName = clsQual gHC_SHOW (fsLit "Show") showClassKey
722 readClassName :: Name
723 readClassName = clsQual gHC_READ (fsLit "Read") readClassKey
725 -- parallel array types and functions
726 enumFromToPName, enumFromThenToPName, nullPName, lengthPName,
727 singletonPName, replicatePName, mapPName, filterPName,
728 zipPName, crossMapPName, indexPName, toPName,
729 emptyPName, appPName :: Name
730 enumFromToPName = varQual gHC_PARR (fsLit "enumFromToP") enumFromToPIdKey
731 enumFromThenToPName= varQual gHC_PARR (fsLit "enumFromThenToP") enumFromThenToPIdKey
732 nullPName = varQual gHC_PARR (fsLit "nullP") nullPIdKey
733 lengthPName = varQual gHC_PARR (fsLit "lengthP") lengthPIdKey
734 singletonPName = varQual gHC_PARR (fsLit "singletonP") singletonPIdKey
735 replicatePName = varQual gHC_PARR (fsLit "replicateP") replicatePIdKey
736 mapPName = varQual gHC_PARR (fsLit "mapP") mapPIdKey
737 filterPName = varQual gHC_PARR (fsLit "filterP") filterPIdKey
738 zipPName = varQual gHC_PARR (fsLit "zipP") zipPIdKey
739 crossMapPName = varQual gHC_PARR (fsLit "crossMapP") crossMapPIdKey
740 indexPName = varQual gHC_PARR (fsLit "!:") indexPIdKey
741 toPName = varQual gHC_PARR (fsLit "toP") toPIdKey
742 emptyPName = varQual gHC_PARR (fsLit "emptyP") emptyPIdKey
743 appPName = varQual gHC_PARR (fsLit "+:+") appPIdKey
746 ioTyConName, ioDataConName, thenIOName, bindIOName, returnIOName,
748 ioTyConName = tcQual gHC_TYPES (fsLit "IO") ioTyConKey
749 ioDataConName = conName gHC_TYPES (fsLit "IO") ioDataConKey
750 thenIOName = varQual gHC_BASE (fsLit "thenIO") thenIOIdKey
751 bindIOName = varQual gHC_BASE (fsLit "bindIO") bindIOIdKey
752 returnIOName = varQual gHC_BASE (fsLit "returnIO") returnIOIdKey
753 failIOName = varQual gHC_IO (fsLit "failIO") failIOIdKey
757 printName = varQual sYSTEM_IO (fsLit "print") printIdKey
759 -- Int, Word, and Addr things
760 int8TyConName, int16TyConName, int32TyConName, int64TyConName :: Name
761 int8TyConName = tcQual gHC_INT (fsLit "Int8") int8TyConKey
762 int16TyConName = tcQual gHC_INT (fsLit "Int16") int16TyConKey
763 int32TyConName = tcQual gHC_INT (fsLit "Int32") int32TyConKey
764 int64TyConName = tcQual gHC_INT (fsLit "Int64") int64TyConKey
767 word8TyConName, word16TyConName, word32TyConName, word64TyConName,
768 wordTyConName, wordDataConName :: Name
769 word8TyConName = tcQual gHC_WORD (fsLit "Word8") word8TyConKey
770 word16TyConName = tcQual gHC_WORD (fsLit "Word16") word16TyConKey
771 word32TyConName = tcQual gHC_WORD (fsLit "Word32") word32TyConKey
772 word64TyConName = tcQual gHC_WORD (fsLit "Word64") word64TyConKey
773 wordTyConName = tcQual gHC_WORD (fsLit "Word") wordTyConKey
774 wordDataConName = conName gHC_WORD (fsLit "W#") wordDataConKey
777 ptrTyConName, funPtrTyConName :: Name
778 ptrTyConName = tcQual gHC_PTR (fsLit "Ptr") ptrTyConKey
779 funPtrTyConName = tcQual gHC_PTR (fsLit "FunPtr") funPtrTyConKey
781 -- Foreign objects and weak pointers
782 stablePtrTyConName, newStablePtrName :: Name
783 stablePtrTyConName = tcQual gHC_STABLE (fsLit "StablePtr") stablePtrTyConKey
784 newStablePtrName = varQual gHC_STABLE (fsLit "newStablePtr") newStablePtrIdKey
788 runSTRepName = varQual gHC_ST (fsLit "runSTRep") runSTRepIdKey
790 -- Recursive-do notation
791 monadFixClassName, mfixName :: Name
792 monadFixClassName = clsQual mONAD_FIX (fsLit "MonadFix") monadFixClassKey
793 mfixName = methName mONAD_FIX (fsLit "mfix") mfixIdKey
796 arrAName, composeAName, firstAName, appAName, choiceAName, loopAName :: Name
797 arrAName = varQual aRROW (fsLit "arr") arrAIdKey
798 composeAName = varQual gHC_DESUGAR (fsLit ">>>") composeAIdKey
799 firstAName = varQual aRROW (fsLit "first") firstAIdKey
800 appAName = varQual aRROW (fsLit "app") appAIdKey
801 choiceAName = varQual aRROW (fsLit "|||") choiceAIdKey
802 loopAName = varQual aRROW (fsLit "loop") loopAIdKey
804 -- Annotation type checking
805 toAnnotationWrapperName :: Name
806 toAnnotationWrapperName = varQual gHC_DESUGAR (fsLit "toAnnotationWrapper") toAnnotationWrapperIdKey
808 -- Other classes, needed for type defaulting
809 monadPlusClassName, randomClassName, randomGenClassName,
810 isStringClassName :: Name
811 monadPlusClassName = clsQual mONAD (fsLit "MonadPlus") monadPlusClassKey
812 randomClassName = clsQual rANDOM (fsLit "Random") randomClassKey
813 randomGenClassName = clsQual rANDOM (fsLit "RandomGen") randomGenClassKey
814 isStringClassName = clsQual dATA_STRING (fsLit "IsString") isStringClassKey
817 objectTyConName :: Name
818 objectTyConName = tcQual dOTNET (fsLit "Object") objectTyConKey
819 -- objectTyConName was "wTcQual", but that's gone now, and
820 -- I can't see why it was wired in anyway...
821 unmarshalObjectName, marshalObjectName, marshalStringName,
822 unmarshalStringName, checkDotnetResName :: Name
823 unmarshalObjectName = varQual dOTNET (fsLit "unmarshalObject") unmarshalObjectIdKey
824 marshalObjectName = varQual dOTNET (fsLit "marshalObject") marshalObjectIdKey
825 marshalStringName = varQual dOTNET (fsLit "marshalString") marshalStringIdKey
826 unmarshalStringName = varQual dOTNET (fsLit "unmarshalString") unmarshalStringIdKey
827 checkDotnetResName = varQual dOTNET (fsLit "checkResult") checkDotnetResNameIdKey
830 %************************************************************************
832 \subsection{Local helpers}
834 %************************************************************************
836 All these are original names; hence mkOrig
839 varQual, tcQual, clsQual :: Module -> FastString -> Unique -> Name
840 varQual = mk_known_key_name varName
841 tcQual = mk_known_key_name tcName
842 clsQual = mk_known_key_name clsName
844 mk_known_key_name :: NameSpace -> Module -> FastString -> Unique -> Name
845 mk_known_key_name space modu str unique
846 = mkExternalName unique modu (mkOccNameFS space str) noSrcSpan
848 conName :: Module -> FastString -> Unique -> Name
849 conName modu occ unique
850 = mkExternalName unique modu (mkOccNameFS dataName occ) noSrcSpan
852 methName :: Module -> FastString -> Unique -> Name
853 methName modu occ unique
854 = mkExternalName unique modu (mkVarOccFS occ) noSrcSpan
857 %************************************************************************
859 \subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@}
861 %************************************************************************
862 --MetaHaskell extension hand allocate keys here
865 boundedClassKey, enumClassKey, eqClassKey, floatingClassKey,
866 fractionalClassKey, integralClassKey, monadClassKey, dataClassKey,
867 functorClassKey, numClassKey, ordClassKey, readClassKey, realClassKey,
868 realFloatClassKey, realFracClassKey, showClassKey, ixClassKey :: Unique
869 boundedClassKey = mkPreludeClassUnique 1
870 enumClassKey = mkPreludeClassUnique 2
871 eqClassKey = mkPreludeClassUnique 3
872 floatingClassKey = mkPreludeClassUnique 5
873 fractionalClassKey = mkPreludeClassUnique 6
874 integralClassKey = mkPreludeClassUnique 7
875 monadClassKey = mkPreludeClassUnique 8
876 dataClassKey = mkPreludeClassUnique 9
877 functorClassKey = mkPreludeClassUnique 10
878 numClassKey = mkPreludeClassUnique 11
879 ordClassKey = mkPreludeClassUnique 12
880 readClassKey = mkPreludeClassUnique 13
881 realClassKey = mkPreludeClassUnique 14
882 realFloatClassKey = mkPreludeClassUnique 15
883 realFracClassKey = mkPreludeClassUnique 16
884 showClassKey = mkPreludeClassUnique 17
885 ixClassKey = mkPreludeClassUnique 18
887 typeableClassKey, typeable1ClassKey, typeable2ClassKey, typeable3ClassKey,
888 typeable4ClassKey, typeable5ClassKey, typeable6ClassKey, typeable7ClassKey
890 typeableClassKey = mkPreludeClassUnique 20
891 typeable1ClassKey = mkPreludeClassUnique 21
892 typeable2ClassKey = mkPreludeClassUnique 22
893 typeable3ClassKey = mkPreludeClassUnique 23
894 typeable4ClassKey = mkPreludeClassUnique 24
895 typeable5ClassKey = mkPreludeClassUnique 25
896 typeable6ClassKey = mkPreludeClassUnique 26
897 typeable7ClassKey = mkPreludeClassUnique 27
899 monadFixClassKey :: Unique
900 monadFixClassKey = mkPreludeClassUnique 28
902 monadPlusClassKey, randomClassKey, randomGenClassKey :: Unique
903 monadPlusClassKey = mkPreludeClassUnique 30
904 randomClassKey = mkPreludeClassUnique 31
905 randomGenClassKey = mkPreludeClassUnique 32
907 isStringClassKey :: Unique
908 isStringClassKey = mkPreludeClassUnique 33
910 applicativeClassKey, foldableClassKey, traversableClassKey :: Unique
911 applicativeClassKey = mkPreludeClassUnique 34
912 foldableClassKey = mkPreludeClassUnique 35
913 traversableClassKey = mkPreludeClassUnique 36
916 %************************************************************************
918 \subsubsection[Uniques-prelude-TyCons]{@Uniques@ for wired-in @TyCons@}
920 %************************************************************************
923 addrPrimTyConKey, arrayPrimTyConKey, boolTyConKey, byteArrayPrimTyConKey,
924 charPrimTyConKey, charTyConKey, doublePrimTyConKey, doubleTyConKey,
925 floatPrimTyConKey, floatTyConKey, funTyConKey, intPrimTyConKey,
926 intTyConKey, int8TyConKey, int16TyConKey, int32PrimTyConKey,
927 int32TyConKey, int64PrimTyConKey, int64TyConKey, integerTyConKey,
928 listTyConKey, foreignObjPrimTyConKey, weakPrimTyConKey,
929 mutableArrayPrimTyConKey, mutableByteArrayPrimTyConKey,
930 orderingTyConKey, mVarPrimTyConKey, ratioTyConKey, rationalTyConKey,
931 realWorldTyConKey, stablePtrPrimTyConKey, stablePtrTyConKey,
932 anyTyConKey :: Unique
933 addrPrimTyConKey = mkPreludeTyConUnique 1
934 arrayPrimTyConKey = mkPreludeTyConUnique 3
935 boolTyConKey = mkPreludeTyConUnique 4
936 byteArrayPrimTyConKey = mkPreludeTyConUnique 5
937 charPrimTyConKey = mkPreludeTyConUnique 7
938 charTyConKey = mkPreludeTyConUnique 8
939 doublePrimTyConKey = mkPreludeTyConUnique 9
940 doubleTyConKey = mkPreludeTyConUnique 10
941 floatPrimTyConKey = mkPreludeTyConUnique 11
942 floatTyConKey = mkPreludeTyConUnique 12
943 funTyConKey = mkPreludeTyConUnique 13
944 intPrimTyConKey = mkPreludeTyConUnique 14
945 intTyConKey = mkPreludeTyConUnique 15
946 int8TyConKey = mkPreludeTyConUnique 16
947 int16TyConKey = mkPreludeTyConUnique 17
948 int32PrimTyConKey = mkPreludeTyConUnique 18
949 int32TyConKey = mkPreludeTyConUnique 19
950 int64PrimTyConKey = mkPreludeTyConUnique 20
951 int64TyConKey = mkPreludeTyConUnique 21
952 integerTyConKey = mkPreludeTyConUnique 22
953 listTyConKey = mkPreludeTyConUnique 23
954 foreignObjPrimTyConKey = mkPreludeTyConUnique 24
955 weakPrimTyConKey = mkPreludeTyConUnique 27
956 mutableArrayPrimTyConKey = mkPreludeTyConUnique 28
957 mutableByteArrayPrimTyConKey = mkPreludeTyConUnique 29
958 orderingTyConKey = mkPreludeTyConUnique 30
959 mVarPrimTyConKey = mkPreludeTyConUnique 31
960 ratioTyConKey = mkPreludeTyConUnique 32
961 rationalTyConKey = mkPreludeTyConUnique 33
962 realWorldTyConKey = mkPreludeTyConUnique 34
963 stablePtrPrimTyConKey = mkPreludeTyConUnique 35
964 stablePtrTyConKey = mkPreludeTyConUnique 36
965 anyTyConKey = mkPreludeTyConUnique 37
967 statePrimTyConKey, stableNamePrimTyConKey, stableNameTyConKey,
968 mutVarPrimTyConKey, ioTyConKey,
969 wordPrimTyConKey, wordTyConKey, word8TyConKey, word16TyConKey,
970 word32PrimTyConKey, word32TyConKey, word64PrimTyConKey, word64TyConKey,
971 liftedConKey, unliftedConKey, anyBoxConKey, kindConKey, boxityConKey,
972 typeConKey, threadIdPrimTyConKey, bcoPrimTyConKey, ptrTyConKey,
973 funPtrTyConKey, tVarPrimTyConKey :: Unique
974 statePrimTyConKey = mkPreludeTyConUnique 50
975 stableNamePrimTyConKey = mkPreludeTyConUnique 51
976 stableNameTyConKey = mkPreludeTyConUnique 52
977 mutVarPrimTyConKey = mkPreludeTyConUnique 55
978 ioTyConKey = mkPreludeTyConUnique 56
979 wordPrimTyConKey = mkPreludeTyConUnique 58
980 wordTyConKey = mkPreludeTyConUnique 59
981 word8TyConKey = mkPreludeTyConUnique 60
982 word16TyConKey = mkPreludeTyConUnique 61
983 word32PrimTyConKey = mkPreludeTyConUnique 62
984 word32TyConKey = mkPreludeTyConUnique 63
985 word64PrimTyConKey = mkPreludeTyConUnique 64
986 word64TyConKey = mkPreludeTyConUnique 65
987 liftedConKey = mkPreludeTyConUnique 66
988 unliftedConKey = mkPreludeTyConUnique 67
989 anyBoxConKey = mkPreludeTyConUnique 68
990 kindConKey = mkPreludeTyConUnique 69
991 boxityConKey = mkPreludeTyConUnique 70
992 typeConKey = mkPreludeTyConUnique 71
993 threadIdPrimTyConKey = mkPreludeTyConUnique 72
994 bcoPrimTyConKey = mkPreludeTyConUnique 73
995 ptrTyConKey = mkPreludeTyConUnique 74
996 funPtrTyConKey = mkPreludeTyConUnique 75
997 tVarPrimTyConKey = mkPreludeTyConUnique 76
999 -- Generic Type Constructors
1000 crossTyConKey, plusTyConKey, genUnitTyConKey :: Unique
1001 crossTyConKey = mkPreludeTyConUnique 79
1002 plusTyConKey = mkPreludeTyConUnique 80
1003 genUnitTyConKey = mkPreludeTyConUnique 81
1005 -- Parallel array type constructor
1006 parrTyConKey :: Unique
1007 parrTyConKey = mkPreludeTyConUnique 82
1010 objectTyConKey :: Unique
1011 objectTyConKey = mkPreludeTyConUnique 83
1013 eitherTyConKey :: Unique
1014 eitherTyConKey = mkPreludeTyConUnique 84
1016 -- Super Kinds constructors
1017 tySuperKindTyConKey, coSuperKindTyConKey :: Unique
1018 tySuperKindTyConKey = mkPreludeTyConUnique 85
1019 coSuperKindTyConKey = mkPreludeTyConUnique 86
1021 -- Kind constructors
1022 liftedTypeKindTyConKey, openTypeKindTyConKey, unliftedTypeKindTyConKey,
1023 ubxTupleKindTyConKey, argTypeKindTyConKey :: Unique
1024 liftedTypeKindTyConKey = mkPreludeTyConUnique 87
1025 openTypeKindTyConKey = mkPreludeTyConUnique 88
1026 unliftedTypeKindTyConKey = mkPreludeTyConUnique 89
1027 ubxTupleKindTyConKey = mkPreludeTyConUnique 90
1028 argTypeKindTyConKey = mkPreludeTyConUnique 91
1030 -- Coercion constructors
1031 symCoercionTyConKey, transCoercionTyConKey, leftCoercionTyConKey,
1032 rightCoercionTyConKey, instCoercionTyConKey, unsafeCoercionTyConKey,
1033 csel1CoercionTyConKey, csel2CoercionTyConKey, cselRCoercionTyConKey
1035 symCoercionTyConKey = mkPreludeTyConUnique 93
1036 transCoercionTyConKey = mkPreludeTyConUnique 94
1037 leftCoercionTyConKey = mkPreludeTyConUnique 95
1038 rightCoercionTyConKey = mkPreludeTyConUnique 96
1039 instCoercionTyConKey = mkPreludeTyConUnique 97
1040 unsafeCoercionTyConKey = mkPreludeTyConUnique 98
1041 csel1CoercionTyConKey = mkPreludeTyConUnique 99
1042 csel2CoercionTyConKey = mkPreludeTyConUnique 100
1043 cselRCoercionTyConKey = mkPreludeTyConUnique 101
1045 unknownTyConKey, unknown1TyConKey, unknown2TyConKey, unknown3TyConKey,
1046 opaqueTyConKey :: Unique
1047 unknownTyConKey = mkPreludeTyConUnique 129
1048 unknown1TyConKey = mkPreludeTyConUnique 130
1049 unknown2TyConKey = mkPreludeTyConUnique 131
1050 unknown3TyConKey = mkPreludeTyConUnique 132
1051 opaqueTyConKey = mkPreludeTyConUnique 133
1053 stringTyConKey :: Unique
1054 stringTyConKey = mkPreludeTyConUnique 134
1056 ---------------- Template Haskell -------------------
1057 -- USES TyConUniques 100-129
1058 -----------------------------------------------------
1060 unitTyConKey :: Unique
1061 unitTyConKey = mkTupleTyConUnique Boxed 0
1064 %************************************************************************
1066 \subsubsection[Uniques-prelude-DataCons]{@Uniques@ for wired-in @DataCons@}
1068 %************************************************************************
1071 charDataConKey, consDataConKey, doubleDataConKey, falseDataConKey,
1072 floatDataConKey, intDataConKey, nilDataConKey, ratioDataConKey,
1073 stableNameDataConKey, trueDataConKey, wordDataConKey,
1074 ioDataConKey, integerDataConKey :: Unique
1075 charDataConKey = mkPreludeDataConUnique 1
1076 consDataConKey = mkPreludeDataConUnique 2
1077 doubleDataConKey = mkPreludeDataConUnique 3
1078 falseDataConKey = mkPreludeDataConUnique 4
1079 floatDataConKey = mkPreludeDataConUnique 5
1080 intDataConKey = mkPreludeDataConUnique 6
1081 nilDataConKey = mkPreludeDataConUnique 11
1082 ratioDataConKey = mkPreludeDataConUnique 12
1083 stableNameDataConKey = mkPreludeDataConUnique 14
1084 trueDataConKey = mkPreludeDataConUnique 15
1085 wordDataConKey = mkPreludeDataConUnique 16
1086 ioDataConKey = mkPreludeDataConUnique 17
1087 integerDataConKey = mkPreludeDataConUnique 18
1089 -- Generic data constructors
1090 crossDataConKey, inlDataConKey, inrDataConKey, genUnitDataConKey :: Unique
1091 crossDataConKey = mkPreludeDataConUnique 20
1092 inlDataConKey = mkPreludeDataConUnique 21
1093 inrDataConKey = mkPreludeDataConUnique 22
1094 genUnitDataConKey = mkPreludeDataConUnique 23
1096 -- Data constructor for parallel arrays
1097 parrDataConKey :: Unique
1098 parrDataConKey = mkPreludeDataConUnique 24
1100 leftDataConKey, rightDataConKey :: Unique
1101 leftDataConKey = mkPreludeDataConUnique 25
1102 rightDataConKey = mkPreludeDataConUnique 26
1105 %************************************************************************
1107 \subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}
1109 %************************************************************************
1112 absentErrorIdKey, augmentIdKey, appendIdKey, buildIdKey, errorIdKey,
1113 foldlIdKey, foldrIdKey, recSelErrorIdKey,
1114 integerMinusOneIdKey, integerPlusOneIdKey,
1115 integerPlusTwoIdKey, integerZeroIdKey,
1116 int2IntegerIdKey, seqIdKey, irrefutPatErrorIdKey, eqStringIdKey,
1117 noMethodBindingErrorIdKey, nonExhaustiveGuardsErrorIdKey,
1118 runtimeErrorIdKey, parErrorIdKey, parIdKey, patErrorIdKey,
1119 realWorldPrimIdKey, recConErrorIdKey, recUpdErrorIdKey,
1121 unpackCStringUtf8IdKey, unpackCStringAppendIdKey,
1122 unpackCStringFoldrIdKey, unpackCStringIdKey :: Unique
1123 absentErrorIdKey = mkPreludeMiscIdUnique 1
1124 augmentIdKey = mkPreludeMiscIdUnique 3
1125 appendIdKey = mkPreludeMiscIdUnique 4
1126 buildIdKey = mkPreludeMiscIdUnique 5
1127 errorIdKey = mkPreludeMiscIdUnique 6
1128 foldlIdKey = mkPreludeMiscIdUnique 7
1129 foldrIdKey = mkPreludeMiscIdUnique 8
1130 recSelErrorIdKey = mkPreludeMiscIdUnique 9
1131 integerMinusOneIdKey = mkPreludeMiscIdUnique 10
1132 integerPlusOneIdKey = mkPreludeMiscIdUnique 11
1133 integerPlusTwoIdKey = mkPreludeMiscIdUnique 12
1134 integerZeroIdKey = mkPreludeMiscIdUnique 13
1135 int2IntegerIdKey = mkPreludeMiscIdUnique 14
1136 seqIdKey = mkPreludeMiscIdUnique 15
1137 irrefutPatErrorIdKey = mkPreludeMiscIdUnique 16
1138 eqStringIdKey = mkPreludeMiscIdUnique 17
1139 noMethodBindingErrorIdKey = mkPreludeMiscIdUnique 18
1140 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 19
1141 runtimeErrorIdKey = mkPreludeMiscIdUnique 20
1142 parErrorIdKey = mkPreludeMiscIdUnique 21
1143 parIdKey = mkPreludeMiscIdUnique 22
1144 patErrorIdKey = mkPreludeMiscIdUnique 23
1145 realWorldPrimIdKey = mkPreludeMiscIdUnique 24
1146 recConErrorIdKey = mkPreludeMiscIdUnique 25
1147 recUpdErrorIdKey = mkPreludeMiscIdUnique 26
1148 traceIdKey = mkPreludeMiscIdUnique 27
1149 unpackCStringUtf8IdKey = mkPreludeMiscIdUnique 28
1150 unpackCStringAppendIdKey = mkPreludeMiscIdUnique 29
1151 unpackCStringFoldrIdKey = mkPreludeMiscIdUnique 30
1152 unpackCStringIdKey = mkPreludeMiscIdUnique 31
1154 unsafeCoerceIdKey, concatIdKey, filterIdKey, zipIdKey, bindIOIdKey,
1155 returnIOIdKey, deRefStablePtrIdKey, newStablePtrIdKey,
1156 smallIntegerIdKey, plusIntegerIdKey, timesIntegerIdKey,
1157 printIdKey, failIOIdKey, nullAddrIdKey, voidArgIdKey,
1158 fstIdKey, sndIdKey, otherwiseIdKey, assertIdKey, runSTRepIdKey :: Unique
1159 unsafeCoerceIdKey = mkPreludeMiscIdUnique 32
1160 concatIdKey = mkPreludeMiscIdUnique 33
1161 filterIdKey = mkPreludeMiscIdUnique 34
1162 zipIdKey = mkPreludeMiscIdUnique 35
1163 bindIOIdKey = mkPreludeMiscIdUnique 36
1164 returnIOIdKey = mkPreludeMiscIdUnique 37
1165 deRefStablePtrIdKey = mkPreludeMiscIdUnique 38
1166 newStablePtrIdKey = mkPreludeMiscIdUnique 39
1167 smallIntegerIdKey = mkPreludeMiscIdUnique 40
1168 plusIntegerIdKey = mkPreludeMiscIdUnique 41
1169 timesIntegerIdKey = mkPreludeMiscIdUnique 42
1170 printIdKey = mkPreludeMiscIdUnique 43
1171 failIOIdKey = mkPreludeMiscIdUnique 44
1172 nullAddrIdKey = mkPreludeMiscIdUnique 46
1173 voidArgIdKey = mkPreludeMiscIdUnique 47
1174 fstIdKey = mkPreludeMiscIdUnique 49
1175 sndIdKey = mkPreludeMiscIdUnique 50
1176 otherwiseIdKey = mkPreludeMiscIdUnique 51
1177 assertIdKey = mkPreludeMiscIdUnique 53
1178 runSTRepIdKey = mkPreludeMiscIdUnique 54
1180 rootMainKey, runMainKey :: Unique
1181 rootMainKey = mkPreludeMiscIdUnique 55
1182 runMainKey = mkPreludeMiscIdUnique 56
1184 thenIOIdKey, lazyIdKey, assertErrorIdKey :: Unique
1185 thenIOIdKey = mkPreludeMiscIdUnique 59
1186 lazyIdKey = mkPreludeMiscIdUnique 60
1187 assertErrorIdKey = mkPreludeMiscIdUnique 61
1189 breakpointIdKey, breakpointCondIdKey, breakpointAutoIdKey,
1190 breakpointJumpIdKey, breakpointCondJumpIdKey,
1191 breakpointAutoJumpIdKey :: Unique
1192 breakpointIdKey = mkPreludeMiscIdUnique 62
1193 breakpointCondIdKey = mkPreludeMiscIdUnique 63
1194 breakpointAutoIdKey = mkPreludeMiscIdUnique 64
1195 breakpointJumpIdKey = mkPreludeMiscIdUnique 65
1196 breakpointCondJumpIdKey = mkPreludeMiscIdUnique 66
1197 breakpointAutoJumpIdKey = mkPreludeMiscIdUnique 67
1199 inlineIdKey :: Unique
1200 inlineIdKey = mkPreludeMiscIdUnique 68
1202 mapIdKey, groupWithIdKey :: Unique
1203 mapIdKey = mkPreludeMiscIdUnique 69
1204 groupWithIdKey = mkPreludeMiscIdUnique 70
1206 -- Parallel array functions
1207 singletonPIdKey, nullPIdKey, lengthPIdKey, replicatePIdKey, mapPIdKey,
1208 filterPIdKey, zipPIdKey, crossMapPIdKey, indexPIdKey, toPIdKey,
1209 enumFromToPIdKey, enumFromThenToPIdKey, emptyPIdKey, appPIdKey :: Unique
1210 singletonPIdKey = mkPreludeMiscIdUnique 79
1211 nullPIdKey = mkPreludeMiscIdUnique 80
1212 lengthPIdKey = mkPreludeMiscIdUnique 81
1213 replicatePIdKey = mkPreludeMiscIdUnique 82
1214 mapPIdKey = mkPreludeMiscIdUnique 83
1215 filterPIdKey = mkPreludeMiscIdUnique 84
1216 zipPIdKey = mkPreludeMiscIdUnique 85
1217 crossMapPIdKey = mkPreludeMiscIdUnique 86
1218 indexPIdKey = mkPreludeMiscIdUnique 87
1219 toPIdKey = mkPreludeMiscIdUnique 88
1220 enumFromToPIdKey = mkPreludeMiscIdUnique 89
1221 enumFromThenToPIdKey = mkPreludeMiscIdUnique 90
1222 emptyPIdKey = mkPreludeMiscIdUnique 91
1223 appPIdKey = mkPreludeMiscIdUnique 92
1226 unmarshalObjectIdKey, marshalObjectIdKey, marshalStringIdKey,
1227 unmarshalStringIdKey, checkDotnetResNameIdKey :: Unique
1228 unmarshalObjectIdKey = mkPreludeMiscIdUnique 94
1229 marshalObjectIdKey = mkPreludeMiscIdUnique 95
1230 marshalStringIdKey = mkPreludeMiscIdUnique 96
1231 unmarshalStringIdKey = mkPreludeMiscIdUnique 97
1232 checkDotnetResNameIdKey = mkPreludeMiscIdUnique 98
1236 Certain class operations from Prelude classes. They get their own
1237 uniques so we can look them up easily when we want to conjure them up
1238 during type checking.
1241 -- Just a place holder for unbound variables produced by the renamer:
1242 unboundKey :: Unique
1243 unboundKey = mkPreludeMiscIdUnique 101
1245 fromIntegerClassOpKey, minusClassOpKey, fromRationalClassOpKey,
1246 enumFromClassOpKey, enumFromThenClassOpKey, enumFromToClassOpKey,
1247 enumFromThenToClassOpKey, eqClassOpKey, geClassOpKey, negateClassOpKey,
1248 failMClassOpKey, bindMClassOpKey, thenMClassOpKey, returnMClassOpKey
1250 fromIntegerClassOpKey = mkPreludeMiscIdUnique 102
1251 minusClassOpKey = mkPreludeMiscIdUnique 103
1252 fromRationalClassOpKey = mkPreludeMiscIdUnique 104
1253 enumFromClassOpKey = mkPreludeMiscIdUnique 105
1254 enumFromThenClassOpKey = mkPreludeMiscIdUnique 106
1255 enumFromToClassOpKey = mkPreludeMiscIdUnique 107
1256 enumFromThenToClassOpKey = mkPreludeMiscIdUnique 108
1257 eqClassOpKey = mkPreludeMiscIdUnique 109
1258 geClassOpKey = mkPreludeMiscIdUnique 110
1259 negateClassOpKey = mkPreludeMiscIdUnique 111
1260 failMClassOpKey = mkPreludeMiscIdUnique 112
1261 bindMClassOpKey = mkPreludeMiscIdUnique 113 -- (>>=)
1262 thenMClassOpKey = mkPreludeMiscIdUnique 114 -- (>>)
1263 returnMClassOpKey = mkPreludeMiscIdUnique 117
1265 -- Recursive do notation
1267 mfixIdKey = mkPreludeMiscIdUnique 118
1270 arrAIdKey, composeAIdKey, firstAIdKey, appAIdKey, choiceAIdKey,
1271 loopAIdKey :: Unique
1272 arrAIdKey = mkPreludeMiscIdUnique 119
1273 composeAIdKey = mkPreludeMiscIdUnique 120 -- >>>
1274 firstAIdKey = mkPreludeMiscIdUnique 121
1275 appAIdKey = mkPreludeMiscIdUnique 122
1276 choiceAIdKey = mkPreludeMiscIdUnique 123 -- |||
1277 loopAIdKey = mkPreludeMiscIdUnique 124
1279 fromStringClassOpKey :: Unique
1280 fromStringClassOpKey = mkPreludeMiscIdUnique 125
1282 -- Annotation type checking
1283 toAnnotationWrapperIdKey :: Unique
1284 toAnnotationWrapperIdKey = mkPreludeMiscIdUnique 126
1287 ---------------- Template Haskell -------------------
1288 -- USES IdUniques 200-399
1289 -----------------------------------------------------
1293 %************************************************************************
1295 \subsection{Standard groups of types}
1297 %************************************************************************
1300 numericTyKeys :: [Unique]
1309 kindKeys :: [Unique]
1310 kindKeys = [ liftedTypeKindTyConKey
1311 , openTypeKindTyConKey
1312 , unliftedTypeKindTyConKey
1313 , ubxTupleKindTyConKey
1314 , argTypeKindTyConKey ]
1318 %************************************************************************
1320 \subsection[Class-std-groups]{Standard groups of Prelude classes}
1322 %************************************************************************
1324 NOTE: @Eq@ and @Text@ do need to appear in @standardClasses@
1325 even though every numeric class has these two as a superclass,
1326 because the list of ambiguous dictionaries hasn't been simplified.
1329 numericClassKeys :: [Unique]
1335 ++ fractionalClassKeys
1337 fractionalClassKeys :: [Unique]
1338 fractionalClassKeys =
1339 [ fractionalClassKey
1345 -- the strictness analyser needs to know about numeric types
1346 -- (see SaAbsInt.lhs)
1347 needsDataDeclCtxtClassKeys :: [Unique]
1348 needsDataDeclCtxtClassKeys = -- see comments in TcDeriv
1352 -- The "standard classes" are used in defaulting (Haskell 98 report 4.3.4),
1353 -- and are: "classes defined in the Prelude or a standard library"
1354 standardClassKeys :: [Unique]
1355 standardClassKeys = derivableClassKeys ++ numericClassKeys
1356 ++ [randomClassKey, randomGenClassKey,
1358 monadClassKey, monadPlusClassKey,
1360 applicativeClassKey, foldableClassKey, traversableClassKey
1364 @derivableClassKeys@ is also used in checking \tr{deriving} constructs
1368 derivableClassKeys :: [Unique]
1370 = [ eqClassKey, ordClassKey, enumClassKey, ixClassKey,
1371 boundedClassKey, showClassKey, readClassKey ]