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