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