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