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_INTERNALS, gHC_LIST, gHC_PARR,
239 gHC_TUPLE, dATA_TUPLE, dATA_EITHER, dATA_STRING, dATA_FOLDABLE, dATA_TRAVERSABLE,
240 gHC_PACK, gHC_CONC, gHC_IO_BASE,
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_INTERNALS = mkIntegerModule (fsLit "GHC.Integer.Internals")
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_BASE = mkBaseModule (fsLit "GHC.IOBase")
270 gHC_ST = mkBaseModule (fsLit "GHC.ST")
271 gHC_ARR = mkBaseModule (fsLit "GHC.Arr")
272 gHC_STABLE = mkBaseModule (fsLit "GHC.Stable")
273 gHC_ADDR = mkBaseModule (fsLit "GHC.Addr")
274 gHC_PTR = mkBaseModule (fsLit "GHC.Ptr")
275 gHC_ERR = mkBaseModule (fsLit "GHC.Err")
276 gHC_REAL = mkBaseModule (fsLit "GHC.Real")
277 gHC_FLOAT = mkBaseModule (fsLit "GHC.Float")
278 gHC_TOP_HANDLER = mkBaseModule (fsLit "GHC.TopHandler")
279 sYSTEM_IO = mkBaseModule (fsLit "System.IO")
280 dYNAMIC = mkBaseModule (fsLit "Data.Dynamic")
281 tYPEABLE = mkBaseModule (fsLit "Data.Typeable")
282 gENERICS = mkBaseModule (fsLit "Data.Data")
283 dOTNET = mkBaseModule (fsLit "GHC.Dotnet")
284 rEAD_PREC = mkBaseModule (fsLit "Text.ParserCombinators.ReadPrec")
285 lEX = mkBaseModule (fsLit "Text.Read.Lex")
286 gHC_INT = mkBaseModule (fsLit "GHC.Int")
287 gHC_WORD = mkBaseModule (fsLit "GHC.Word")
288 mONAD = mkBaseModule (fsLit "Control.Monad")
289 mONAD_FIX = mkBaseModule (fsLit "Control.Monad.Fix")
290 aRROW = mkBaseModule (fsLit "Control.Arrow")
291 cONTROL_APPLICATIVE = mkBaseModule (fsLit "Control.Applicative")
292 gHC_DESUGAR = mkBaseModule (fsLit "GHC.Desugar")
293 rANDOM = mkBaseModule (fsLit "System.Random")
294 gHC_EXTS = mkBaseModule (fsLit "GHC.Exts")
295 cONTROL_EXCEPTION_BASE = mkBaseModule (fsLit "Control.Exception.Base")
297 mAIN, rOOT_MAIN :: Module
298 mAIN = mkMainModule_ mAIN_NAME
299 rOOT_MAIN = mkMainModule (fsLit ":Main") -- Root module for initialisation
301 -- The ':xxx' makes a module name that the user can never
302 -- use himself. The z-encoding for ':' is "ZC", so the z-encoded
303 -- module name still starts with a capital letter, which keeps
304 -- the z-encoded version consistent.
305 iNTERACTIVE :: Module
306 iNTERACTIVE = mkMainModule (fsLit ":Interactive")
308 pRELUDE_NAME, mAIN_NAME :: ModuleName
309 pRELUDE_NAME = mkModuleNameFS (fsLit "Prelude")
310 mAIN_NAME = mkModuleNameFS (fsLit "Main")
312 mkPrimModule :: FastString -> Module
313 mkPrimModule m = mkModule primPackageId (mkModuleNameFS m)
315 mkIntegerModule :: FastString -> Module
316 mkIntegerModule m = mkModule integerPackageId (mkModuleNameFS m)
318 mkBaseModule :: FastString -> Module
319 mkBaseModule m = mkModule basePackageId (mkModuleNameFS m)
321 mkBaseModule_ :: ModuleName -> Module
322 mkBaseModule_ m = mkModule basePackageId m
324 mkMainModule :: FastString -> Module
325 mkMainModule m = mkModule mainPackageId (mkModuleNameFS m)
327 mkMainModule_ :: ModuleName -> Module
328 mkMainModule_ m = mkModule mainPackageId m
331 %************************************************************************
333 \subsection{Constructing the names of tuples
335 %************************************************************************
338 mkTupleModule :: Boxity -> Arity -> Module
339 mkTupleModule Boxed 0 = gHC_UNIT
340 mkTupleModule Boxed _ = gHC_TUPLE
341 mkTupleModule Unboxed _ = gHC_PRIM
345 %************************************************************************
349 %************************************************************************
352 main_RDR_Unqual :: RdrName
353 main_RDR_Unqual = mkUnqual varName (fsLit "main")
354 -- We definitely don't want an Orig RdrName, because
355 -- main might, in principle, be imported into module Main
357 forall_tv_RDR, dot_tv_RDR :: RdrName
358 forall_tv_RDR = mkUnqual tvName (fsLit "forall")
359 dot_tv_RDR = mkUnqual tvName (fsLit ".")
361 eq_RDR, ge_RDR, ne_RDR, le_RDR, lt_RDR, gt_RDR, compare_RDR,
362 ltTag_RDR, eqTag_RDR, gtTag_RDR :: RdrName
363 eq_RDR = nameRdrName eqName
364 ge_RDR = nameRdrName geName
365 ne_RDR = varQual_RDR gHC_CLASSES (fsLit "/=")
366 le_RDR = varQual_RDR gHC_CLASSES (fsLit "<=")
367 lt_RDR = varQual_RDR gHC_CLASSES (fsLit "<")
368 gt_RDR = varQual_RDR gHC_CLASSES (fsLit ">")
369 compare_RDR = varQual_RDR gHC_CLASSES (fsLit "compare")
370 ltTag_RDR = dataQual_RDR gHC_ORDERING (fsLit "LT")
371 eqTag_RDR = dataQual_RDR gHC_ORDERING (fsLit "EQ")
372 gtTag_RDR = dataQual_RDR gHC_ORDERING (fsLit "GT")
374 eqClass_RDR, numClass_RDR, ordClass_RDR, enumClass_RDR, monadClass_RDR
376 eqClass_RDR = nameRdrName eqClassName
377 numClass_RDR = nameRdrName numClassName
378 ordClass_RDR = nameRdrName ordClassName
379 enumClass_RDR = nameRdrName enumClassName
380 monadClass_RDR = nameRdrName monadClassName
382 map_RDR, append_RDR :: RdrName
383 map_RDR = varQual_RDR gHC_BASE (fsLit "map")
384 append_RDR = varQual_RDR gHC_BASE (fsLit "++")
386 foldr_RDR, build_RDR, returnM_RDR, bindM_RDR, failM_RDR :: RdrName
387 foldr_RDR = nameRdrName foldrName
388 build_RDR = nameRdrName buildName
389 returnM_RDR = nameRdrName returnMName
390 bindM_RDR = nameRdrName bindMName
391 failM_RDR = nameRdrName failMName
393 left_RDR, right_RDR :: RdrName
394 left_RDR = nameRdrName leftDataConName
395 right_RDR = nameRdrName rightDataConName
397 fromEnum_RDR, toEnum_RDR :: RdrName
398 fromEnum_RDR = varQual_RDR gHC_ENUM (fsLit "fromEnum")
399 toEnum_RDR = varQual_RDR gHC_ENUM (fsLit "toEnum")
401 enumFrom_RDR, enumFromTo_RDR, enumFromThen_RDR, enumFromThenTo_RDR :: RdrName
402 enumFrom_RDR = nameRdrName enumFromName
403 enumFromTo_RDR = nameRdrName enumFromToName
404 enumFromThen_RDR = nameRdrName enumFromThenName
405 enumFromThenTo_RDR = nameRdrName enumFromThenToName
407 ratioDataCon_RDR, plusInteger_RDR, timesInteger_RDR :: RdrName
408 ratioDataCon_RDR = nameRdrName ratioDataConName
409 plusInteger_RDR = nameRdrName plusIntegerName
410 timesInteger_RDR = nameRdrName timesIntegerName
412 ioDataCon_RDR :: RdrName
413 ioDataCon_RDR = nameRdrName ioDataConName
415 eqString_RDR, unpackCString_RDR, unpackCStringFoldr_RDR,
416 unpackCStringUtf8_RDR :: RdrName
417 eqString_RDR = nameRdrName eqStringName
418 unpackCString_RDR = nameRdrName unpackCStringName
419 unpackCStringFoldr_RDR = nameRdrName unpackCStringFoldrName
420 unpackCStringUtf8_RDR = nameRdrName unpackCStringUtf8Name
422 newStablePtr_RDR, wordDataCon_RDR :: RdrName
423 newStablePtr_RDR = nameRdrName newStablePtrName
424 wordDataCon_RDR = dataQual_RDR gHC_WORD (fsLit "W#")
426 bindIO_RDR, returnIO_RDR :: RdrName
427 bindIO_RDR = nameRdrName bindIOName
428 returnIO_RDR = nameRdrName returnIOName
430 fromInteger_RDR, fromRational_RDR, minus_RDR, times_RDR, plus_RDR :: RdrName
431 fromInteger_RDR = nameRdrName fromIntegerName
432 fromRational_RDR = nameRdrName fromRationalName
433 minus_RDR = nameRdrName minusName
434 times_RDR = varQual_RDR gHC_NUM (fsLit "*")
435 plus_RDR = varQual_RDR gHC_NUM (fsLit "+")
437 fromString_RDR :: RdrName
438 fromString_RDR = nameRdrName fromStringName
440 compose_RDR :: RdrName
441 compose_RDR = varQual_RDR gHC_BASE (fsLit ".")
443 not_RDR, getTag_RDR, succ_RDR, pred_RDR, minBound_RDR, maxBound_RDR,
444 and_RDR, range_RDR, inRange_RDR, index_RDR,
445 unsafeIndex_RDR, unsafeRangeSize_RDR :: RdrName
446 and_RDR = varQual_RDR gHC_CLASSES (fsLit "&&")
447 not_RDR = varQual_RDR gHC_CLASSES (fsLit "not")
448 getTag_RDR = varQual_RDR gHC_BASE (fsLit "getTag")
449 succ_RDR = varQual_RDR gHC_ENUM (fsLit "succ")
450 pred_RDR = varQual_RDR gHC_ENUM (fsLit "pred")
451 minBound_RDR = varQual_RDR gHC_ENUM (fsLit "minBound")
452 maxBound_RDR = varQual_RDR gHC_ENUM (fsLit "maxBound")
453 range_RDR = varQual_RDR gHC_ARR (fsLit "range")
454 inRange_RDR = varQual_RDR gHC_ARR (fsLit "inRange")
455 index_RDR = varQual_RDR gHC_ARR (fsLit "index")
456 unsafeIndex_RDR = varQual_RDR gHC_ARR (fsLit "unsafeIndex")
457 unsafeRangeSize_RDR = varQual_RDR gHC_ARR (fsLit "unsafeRangeSize")
459 readList_RDR, readListDefault_RDR, readListPrec_RDR, readListPrecDefault_RDR,
460 readPrec_RDR, parens_RDR, choose_RDR, lexP_RDR :: RdrName
461 readList_RDR = varQual_RDR gHC_READ (fsLit "readList")
462 readListDefault_RDR = varQual_RDR gHC_READ (fsLit "readListDefault")
463 readListPrec_RDR = varQual_RDR gHC_READ (fsLit "readListPrec")
464 readListPrecDefault_RDR = varQual_RDR gHC_READ (fsLit "readListPrecDefault")
465 readPrec_RDR = varQual_RDR gHC_READ (fsLit "readPrec")
466 parens_RDR = varQual_RDR gHC_READ (fsLit "parens")
467 choose_RDR = varQual_RDR gHC_READ (fsLit "choose")
468 lexP_RDR = varQual_RDR gHC_READ (fsLit "lexP")
470 punc_RDR, ident_RDR, symbol_RDR :: RdrName
471 punc_RDR = dataQual_RDR lEX (fsLit "Punc")
472 ident_RDR = dataQual_RDR lEX (fsLit "Ident")
473 symbol_RDR = dataQual_RDR lEX (fsLit "Symbol")
475 step_RDR, alt_RDR, reset_RDR, prec_RDR :: RdrName
476 step_RDR = varQual_RDR rEAD_PREC (fsLit "step")
477 alt_RDR = varQual_RDR rEAD_PREC (fsLit "+++")
478 reset_RDR = varQual_RDR rEAD_PREC (fsLit "reset")
479 prec_RDR = varQual_RDR rEAD_PREC (fsLit "prec")
481 showList_RDR, showList___RDR, showsPrec_RDR, showString_RDR,
482 showSpace_RDR, showParen_RDR :: RdrName
483 showList_RDR = varQual_RDR gHC_SHOW (fsLit "showList")
484 showList___RDR = varQual_RDR gHC_SHOW (fsLit "showList__")
485 showsPrec_RDR = varQual_RDR gHC_SHOW (fsLit "showsPrec")
486 showString_RDR = varQual_RDR gHC_SHOW (fsLit "showString")
487 showSpace_RDR = varQual_RDR gHC_SHOW (fsLit "showSpace")
488 showParen_RDR = varQual_RDR gHC_SHOW (fsLit "showParen")
490 typeOf_RDR, mkTypeRep_RDR, mkTyConRep_RDR :: RdrName
491 typeOf_RDR = varQual_RDR tYPEABLE (fsLit "typeOf")
492 mkTypeRep_RDR = varQual_RDR tYPEABLE (fsLit "mkTyConApp")
493 mkTyConRep_RDR = varQual_RDR tYPEABLE (fsLit "mkTyCon")
495 undefined_RDR :: RdrName
496 undefined_RDR = varQual_RDR gHC_ERR (fsLit "undefined")
498 crossDataCon_RDR, inlDataCon_RDR, inrDataCon_RDR, genUnitDataCon_RDR :: RdrName
499 crossDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit ":*:")
500 inlDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Inl")
501 inrDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Inr")
502 genUnitDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Unit")
504 fmap_RDR, pure_RDR, ap_RDR, foldable_foldr_RDR, traverse_RDR :: RdrName
505 fmap_RDR = varQual_RDR gHC_BASE (fsLit "fmap")
506 pure_RDR = varQual_RDR cONTROL_APPLICATIVE (fsLit "pure")
507 ap_RDR = varQual_RDR cONTROL_APPLICATIVE (fsLit "<*>")
508 foldable_foldr_RDR = varQual_RDR dATA_FOLDABLE (fsLit "foldr")
509 traverse_RDR = varQual_RDR dATA_TRAVERSABLE (fsLit "traverse")
511 ----------------------
512 varQual_RDR, tcQual_RDR, clsQual_RDR, dataQual_RDR
513 :: Module -> FastString -> RdrName
514 varQual_RDR mod str = mkOrig mod (mkOccNameFS varName str)
515 tcQual_RDR mod str = mkOrig mod (mkOccNameFS tcName str)
516 clsQual_RDR mod str = mkOrig mod (mkOccNameFS clsName str)
517 dataQual_RDR mod str = mkOrig mod (mkOccNameFS dataName str)
520 %************************************************************************
522 \subsection{Known-key names}
524 %************************************************************************
526 Many of these Names are not really "built in", but some parts of the
527 compiler (notably the deriving mechanism) need to mention their names,
528 and it's convenient to write them all down in one place.
530 --MetaHaskell Extension add the constrs and the lower case case
531 -- guys as well (perhaps) e.g. see trueDataConName below
535 runMainIOName :: Name
536 runMainIOName = varQual gHC_TOP_HANDLER (fsLit "runMainIO") runMainKey
538 orderingTyConName :: Name
539 orderingTyConName = tcQual gHC_ORDERING (fsLit "Ordering") orderingTyConKey
541 eitherTyConName, leftDataConName, rightDataConName :: Name
542 eitherTyConName = tcQual dATA_EITHER (fsLit "Either") eitherTyConKey
543 leftDataConName = conName dATA_EITHER (fsLit "Left") leftDataConKey
544 rightDataConName = conName dATA_EITHER (fsLit "Right") rightDataConKey
547 crossTyConName, plusTyConName, genUnitTyConName :: Name
548 crossTyConName = tcQual gHC_GENERICS (fsLit ":*:") crossTyConKey
549 plusTyConName = tcQual gHC_GENERICS (fsLit ":+:") plusTyConKey
550 genUnitTyConName = tcQual gHC_GENERICS (fsLit "Unit") genUnitTyConKey
552 -- Base strings Strings
553 unpackCStringName, unpackCStringAppendName, unpackCStringFoldrName,
554 unpackCStringUtf8Name, eqStringName, stringTyConName :: Name
555 unpackCStringName = varQual gHC_BASE (fsLit "unpackCString#") unpackCStringIdKey
556 unpackCStringAppendName = varQual gHC_BASE (fsLit "unpackAppendCString#") unpackCStringAppendIdKey
557 unpackCStringFoldrName = varQual gHC_BASE (fsLit "unpackFoldrCString#") unpackCStringFoldrIdKey
558 unpackCStringUtf8Name = varQual gHC_BASE (fsLit "unpackCStringUtf8#") unpackCStringUtf8IdKey
559 eqStringName = varQual gHC_BASE (fsLit "eqString") eqStringIdKey
560 stringTyConName = tcQual gHC_BASE (fsLit "String") stringTyConKey
562 -- The 'inline' function
564 inlineIdName = varQual gHC_BASE (fsLit "inline") inlineIdKey
566 -- Base classes (Eq, Ord, Functor)
567 eqClassName, eqName, ordClassName, geName, functorClassName :: Name
568 eqClassName = clsQual gHC_CLASSES (fsLit "Eq") eqClassKey
569 eqName = methName gHC_CLASSES (fsLit "==") eqClassOpKey
570 ordClassName = clsQual gHC_CLASSES (fsLit "Ord") ordClassKey
571 geName = methName gHC_CLASSES (fsLit ">=") geClassOpKey
572 functorClassName = clsQual gHC_BASE (fsLit "Functor") functorClassKey
575 monadClassName, thenMName, bindMName, returnMName, failMName :: Name
576 monadClassName = clsQual gHC_BASE (fsLit "Monad") monadClassKey
577 thenMName = methName gHC_BASE (fsLit ">>") thenMClassOpKey
578 bindMName = methName gHC_BASE (fsLit ">>=") bindMClassOpKey
579 returnMName = methName gHC_BASE (fsLit "return") returnMClassOpKey
580 failMName = methName gHC_BASE (fsLit "fail") failMClassOpKey
582 -- Classes (Applicative, Foldable, Traversable)
583 applicativeClassName, foldableClassName, traversableClassName :: Name
584 applicativeClassName = clsQual cONTROL_APPLICATIVE (fsLit "Applicative") applicativeClassKey
585 foldableClassName = clsQual dATA_FOLDABLE (fsLit "Foldable") foldableClassKey
586 traversableClassName = clsQual dATA_TRAVERSABLE (fsLit "Traversable") traversableClassKey
588 -- Functions for GHC extensions
589 groupWithName :: Name
590 groupWithName = varQual gHC_EXTS (fsLit "groupWith") groupWithIdKey
592 -- Random PrelBase functions
593 fromStringName, otherwiseIdName, foldrName, buildName, augmentName,
594 mapName, appendName, assertName,
595 breakpointName, breakpointCondName, breakpointAutoName,
596 opaqueTyConName :: Name
597 fromStringName = methName dATA_STRING (fsLit "fromString") fromStringClassOpKey
598 otherwiseIdName = varQual gHC_BASE (fsLit "otherwise") otherwiseIdKey
599 foldrName = varQual gHC_BASE (fsLit "foldr") foldrIdKey
600 buildName = varQual gHC_BASE (fsLit "build") buildIdKey
601 augmentName = varQual gHC_BASE (fsLit "augment") augmentIdKey
602 mapName = varQual gHC_BASE (fsLit "map") mapIdKey
603 appendName = varQual gHC_BASE (fsLit "++") appendIdKey
604 assertName = varQual gHC_BASE (fsLit "assert") assertIdKey
605 breakpointName = varQual gHC_BASE (fsLit "breakpoint") breakpointIdKey
606 breakpointCondName= varQual gHC_BASE (fsLit "breakpointCond") breakpointCondIdKey
607 breakpointAutoName= varQual gHC_BASE (fsLit "breakpointAuto") breakpointAutoIdKey
608 opaqueTyConName = tcQual gHC_BASE (fsLit "Opaque") opaqueTyConKey
610 breakpointJumpName :: Name
614 (mkOccNameFS varName (fsLit "breakpointJump"))
616 breakpointCondJumpName :: Name
617 breakpointCondJumpName
619 breakpointCondJumpIdKey
620 (mkOccNameFS varName (fsLit "breakpointCondJump"))
622 breakpointAutoJumpName :: Name
623 breakpointAutoJumpName
625 breakpointAutoJumpIdKey
626 (mkOccNameFS varName (fsLit "breakpointAutoJump"))
630 fstName, sndName :: Name
631 fstName = varQual dATA_TUPLE (fsLit "fst") fstIdKey
632 sndName = varQual dATA_TUPLE (fsLit "snd") sndIdKey
635 numClassName, fromIntegerName, minusName, negateName, plusIntegerName,
636 timesIntegerName, integerTyConName, smallIntegerName :: Name
637 numClassName = clsQual gHC_NUM (fsLit "Num") numClassKey
638 fromIntegerName = methName gHC_NUM (fsLit "fromInteger") fromIntegerClassOpKey
639 minusName = methName gHC_NUM (fsLit "-") minusClassOpKey
640 negateName = methName gHC_NUM (fsLit "negate") negateClassOpKey
641 plusIntegerName = varQual gHC_INTEGER (fsLit "plusInteger") plusIntegerIdKey
642 timesIntegerName = varQual gHC_INTEGER (fsLit "timesInteger") timesIntegerIdKey
643 integerTyConName = tcQual gHC_INTEGER_INTERNALS (fsLit "Integer") integerTyConKey
644 smallIntegerName = varQual gHC_INTEGER (fsLit "smallInteger") smallIntegerIdKey
646 -- PrelReal types and classes
647 rationalTyConName, ratioTyConName, ratioDataConName, realClassName,
648 integralClassName, realFracClassName, fractionalClassName,
649 fromRationalName :: Name
650 rationalTyConName = tcQual gHC_REAL (fsLit "Rational") rationalTyConKey
651 ratioTyConName = tcQual gHC_REAL (fsLit "Ratio") ratioTyConKey
652 ratioDataConName = conName gHC_REAL (fsLit ":%") ratioDataConKey
653 realClassName = clsQual gHC_REAL (fsLit "Real") realClassKey
654 integralClassName = clsQual gHC_REAL (fsLit "Integral") integralClassKey
655 realFracClassName = clsQual gHC_REAL (fsLit "RealFrac") realFracClassKey
656 fractionalClassName = clsQual gHC_REAL (fsLit "Fractional") fractionalClassKey
657 fromRationalName = methName gHC_REAL (fsLit "fromRational") fromRationalClassOpKey
660 floatingClassName, realFloatClassName :: Name
661 floatingClassName = clsQual gHC_FLOAT (fsLit "Floating") floatingClassKey
662 realFloatClassName = clsQual gHC_FLOAT (fsLit "RealFloat") realFloatClassKey
666 ixClassName = clsQual gHC_ARR (fsLit "Ix") ixClassKey
669 typeableClassName, typeable1ClassName, typeable2ClassName,
670 typeable3ClassName, typeable4ClassName, typeable5ClassName,
671 typeable6ClassName, typeable7ClassName :: Name
672 typeableClassName = clsQual tYPEABLE (fsLit "Typeable") typeableClassKey
673 typeable1ClassName = clsQual tYPEABLE (fsLit "Typeable1") typeable1ClassKey
674 typeable2ClassName = clsQual tYPEABLE (fsLit "Typeable2") typeable2ClassKey
675 typeable3ClassName = clsQual tYPEABLE (fsLit "Typeable3") typeable3ClassKey
676 typeable4ClassName = clsQual tYPEABLE (fsLit "Typeable4") typeable4ClassKey
677 typeable5ClassName = clsQual tYPEABLE (fsLit "Typeable5") typeable5ClassKey
678 typeable6ClassName = clsQual tYPEABLE (fsLit "Typeable6") typeable6ClassKey
679 typeable7ClassName = clsQual tYPEABLE (fsLit "Typeable7") typeable7ClassKey
681 typeableClassNames :: [Name]
682 typeableClassNames = [ typeableClassName, typeable1ClassName, typeable2ClassName
683 , typeable3ClassName, typeable4ClassName, typeable5ClassName
684 , typeable6ClassName, typeable7ClassName ]
687 dataClassName :: Name
688 dataClassName = clsQual gENERICS (fsLit "Data") dataClassKey
691 assertErrorName :: Name
692 assertErrorName = varQual gHC_IO_BASE (fsLit "assertError") assertErrorIdKey
694 -- Enum module (Enum, Bounded)
695 enumClassName, enumFromName, enumFromToName, enumFromThenName,
696 enumFromThenToName, boundedClassName :: Name
697 enumClassName = clsQual gHC_ENUM (fsLit "Enum") enumClassKey
698 enumFromName = methName gHC_ENUM (fsLit "enumFrom") enumFromClassOpKey
699 enumFromToName = methName gHC_ENUM (fsLit "enumFromTo") enumFromToClassOpKey
700 enumFromThenName = methName gHC_ENUM (fsLit "enumFromThen") enumFromThenClassOpKey
701 enumFromThenToName = methName gHC_ENUM (fsLit "enumFromThenTo") enumFromThenToClassOpKey
702 boundedClassName = clsQual gHC_ENUM (fsLit "Bounded") boundedClassKey
705 concatName, filterName, zipName :: Name
706 concatName = varQual gHC_LIST (fsLit "concat") concatIdKey
707 filterName = varQual gHC_LIST (fsLit "filter") filterIdKey
708 zipName = varQual gHC_LIST (fsLit "zip") zipIdKey
711 showClassName :: Name
712 showClassName = clsQual gHC_SHOW (fsLit "Show") showClassKey
715 readClassName :: Name
716 readClassName = clsQual gHC_READ (fsLit "Read") readClassKey
718 -- parallel array types and functions
719 enumFromToPName, enumFromThenToPName, nullPName, lengthPName,
720 singletonPName, replicatePName, mapPName, filterPName,
721 zipPName, crossMapPName, indexPName, toPName,
722 emptyPName, appPName :: Name
723 enumFromToPName = varQual gHC_PARR (fsLit "enumFromToP") enumFromToPIdKey
724 enumFromThenToPName= varQual gHC_PARR (fsLit "enumFromThenToP") enumFromThenToPIdKey
725 nullPName = varQual gHC_PARR (fsLit "nullP") nullPIdKey
726 lengthPName = varQual gHC_PARR (fsLit "lengthP") lengthPIdKey
727 singletonPName = varQual gHC_PARR (fsLit "singletonP") singletonPIdKey
728 replicatePName = varQual gHC_PARR (fsLit "replicateP") replicatePIdKey
729 mapPName = varQual gHC_PARR (fsLit "mapP") mapPIdKey
730 filterPName = varQual gHC_PARR (fsLit "filterP") filterPIdKey
731 zipPName = varQual gHC_PARR (fsLit "zipP") zipPIdKey
732 crossMapPName = varQual gHC_PARR (fsLit "crossMapP") crossMapPIdKey
733 indexPName = varQual gHC_PARR (fsLit "!:") indexPIdKey
734 toPName = varQual gHC_PARR (fsLit "toP") toPIdKey
735 emptyPName = varQual gHC_PARR (fsLit "emptyP") emptyPIdKey
736 appPName = varQual gHC_PARR (fsLit "+:+") appPIdKey
739 ioTyConName, ioDataConName, thenIOName, bindIOName, returnIOName,
741 ioTyConName = tcQual gHC_IO_BASE (fsLit "IO") ioTyConKey
742 ioDataConName = conName gHC_IO_BASE (fsLit "IO") ioDataConKey
743 thenIOName = varQual gHC_IO_BASE (fsLit "thenIO") thenIOIdKey
744 bindIOName = varQual gHC_IO_BASE (fsLit "bindIO") bindIOIdKey
745 returnIOName = varQual gHC_IO_BASE (fsLit "returnIO") returnIOIdKey
746 failIOName = varQual gHC_IO_BASE (fsLit "failIO") failIOIdKey
750 printName = varQual sYSTEM_IO (fsLit "print") printIdKey
752 -- Int, Word, and Addr things
753 int8TyConName, int16TyConName, int32TyConName, int64TyConName :: Name
754 int8TyConName = tcQual gHC_INT (fsLit "Int8") int8TyConKey
755 int16TyConName = tcQual gHC_INT (fsLit "Int16") int16TyConKey
756 int32TyConName = tcQual gHC_INT (fsLit "Int32") int32TyConKey
757 int64TyConName = tcQual gHC_INT (fsLit "Int64") int64TyConKey
760 word8TyConName, word16TyConName, word32TyConName, word64TyConName,
761 wordTyConName, wordDataConName :: Name
762 word8TyConName = tcQual gHC_WORD (fsLit "Word8") word8TyConKey
763 word16TyConName = tcQual gHC_WORD (fsLit "Word16") word16TyConKey
764 word32TyConName = tcQual gHC_WORD (fsLit "Word32") word32TyConKey
765 word64TyConName = tcQual gHC_WORD (fsLit "Word64") word64TyConKey
766 wordTyConName = tcQual gHC_WORD (fsLit "Word") wordTyConKey
767 wordDataConName = conName gHC_WORD (fsLit "W#") wordDataConKey
770 ptrTyConName, funPtrTyConName :: Name
771 ptrTyConName = tcQual gHC_PTR (fsLit "Ptr") ptrTyConKey
772 funPtrTyConName = tcQual gHC_PTR (fsLit "FunPtr") funPtrTyConKey
774 -- Foreign objects and weak pointers
775 stablePtrTyConName, newStablePtrName :: Name
776 stablePtrTyConName = tcQual gHC_STABLE (fsLit "StablePtr") stablePtrTyConKey
777 newStablePtrName = varQual gHC_STABLE (fsLit "newStablePtr") newStablePtrIdKey
781 runSTRepName = varQual gHC_ST (fsLit "runSTRep") runSTRepIdKey
783 -- Recursive-do notation
784 monadFixClassName, mfixName :: Name
785 monadFixClassName = clsQual mONAD_FIX (fsLit "MonadFix") monadFixClassKey
786 mfixName = methName mONAD_FIX (fsLit "mfix") mfixIdKey
789 arrAName, composeAName, firstAName, appAName, choiceAName, loopAName :: Name
790 arrAName = varQual aRROW (fsLit "arr") arrAIdKey
791 composeAName = varQual gHC_DESUGAR (fsLit ">>>") composeAIdKey
792 firstAName = varQual aRROW (fsLit "first") firstAIdKey
793 appAName = varQual aRROW (fsLit "app") appAIdKey
794 choiceAName = varQual aRROW (fsLit "|||") choiceAIdKey
795 loopAName = varQual aRROW (fsLit "loop") loopAIdKey
797 -- Annotation type checking
798 toAnnotationWrapperName :: Name
799 toAnnotationWrapperName = varQual gHC_DESUGAR (fsLit "toAnnotationWrapper") toAnnotationWrapperIdKey
801 -- Other classes, needed for type defaulting
802 monadPlusClassName, randomClassName, randomGenClassName,
803 isStringClassName :: Name
804 monadPlusClassName = clsQual mONAD (fsLit "MonadPlus") monadPlusClassKey
805 randomClassName = clsQual rANDOM (fsLit "Random") randomClassKey
806 randomGenClassName = clsQual rANDOM (fsLit "RandomGen") randomGenClassKey
807 isStringClassName = clsQual dATA_STRING (fsLit "IsString") isStringClassKey
810 objectTyConName :: Name
811 objectTyConName = tcQual dOTNET (fsLit "Object") objectTyConKey
812 -- objectTyConName was "wTcQual", but that's gone now, and
813 -- I can't see why it was wired in anyway...
814 unmarshalObjectName, marshalObjectName, marshalStringName,
815 unmarshalStringName, checkDotnetResName :: Name
816 unmarshalObjectName = varQual dOTNET (fsLit "unmarshalObject") unmarshalObjectIdKey
817 marshalObjectName = varQual dOTNET (fsLit "marshalObject") marshalObjectIdKey
818 marshalStringName = varQual dOTNET (fsLit "marshalString") marshalStringIdKey
819 unmarshalStringName = varQual dOTNET (fsLit "unmarshalString") unmarshalStringIdKey
820 checkDotnetResName = varQual dOTNET (fsLit "checkResult") checkDotnetResNameIdKey
823 %************************************************************************
825 \subsection{Local helpers}
827 %************************************************************************
829 All these are original names; hence mkOrig
832 varQual, tcQual, clsQual :: Module -> FastString -> Unique -> Name
833 varQual = mk_known_key_name varName
834 tcQual = mk_known_key_name tcName
835 clsQual = mk_known_key_name clsName
837 mk_known_key_name :: NameSpace -> Module -> FastString -> Unique -> Name
838 mk_known_key_name space modu str unique
839 = mkExternalName unique modu (mkOccNameFS space str) noSrcSpan
841 conName :: Module -> FastString -> Unique -> Name
842 conName modu occ unique
843 = mkExternalName unique modu (mkOccNameFS dataName occ) noSrcSpan
845 methName :: Module -> FastString -> Unique -> Name
846 methName modu occ unique
847 = mkExternalName unique modu (mkVarOccFS occ) noSrcSpan
850 %************************************************************************
852 \subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@}
854 %************************************************************************
855 --MetaHaskell extension hand allocate keys here
858 boundedClassKey, enumClassKey, eqClassKey, floatingClassKey,
859 fractionalClassKey, integralClassKey, monadClassKey, dataClassKey,
860 functorClassKey, numClassKey, ordClassKey, readClassKey, realClassKey,
861 realFloatClassKey, realFracClassKey, showClassKey, ixClassKey :: Unique
862 boundedClassKey = mkPreludeClassUnique 1
863 enumClassKey = mkPreludeClassUnique 2
864 eqClassKey = mkPreludeClassUnique 3
865 floatingClassKey = mkPreludeClassUnique 5
866 fractionalClassKey = mkPreludeClassUnique 6
867 integralClassKey = mkPreludeClassUnique 7
868 monadClassKey = mkPreludeClassUnique 8
869 dataClassKey = mkPreludeClassUnique 9
870 functorClassKey = mkPreludeClassUnique 10
871 numClassKey = mkPreludeClassUnique 11
872 ordClassKey = mkPreludeClassUnique 12
873 readClassKey = mkPreludeClassUnique 13
874 realClassKey = mkPreludeClassUnique 14
875 realFloatClassKey = mkPreludeClassUnique 15
876 realFracClassKey = mkPreludeClassUnique 16
877 showClassKey = mkPreludeClassUnique 17
878 ixClassKey = mkPreludeClassUnique 18
880 typeableClassKey, typeable1ClassKey, typeable2ClassKey, typeable3ClassKey,
881 typeable4ClassKey, typeable5ClassKey, typeable6ClassKey, typeable7ClassKey
883 typeableClassKey = mkPreludeClassUnique 20
884 typeable1ClassKey = mkPreludeClassUnique 21
885 typeable2ClassKey = mkPreludeClassUnique 22
886 typeable3ClassKey = mkPreludeClassUnique 23
887 typeable4ClassKey = mkPreludeClassUnique 24
888 typeable5ClassKey = mkPreludeClassUnique 25
889 typeable6ClassKey = mkPreludeClassUnique 26
890 typeable7ClassKey = mkPreludeClassUnique 27
892 monadFixClassKey :: Unique
893 monadFixClassKey = mkPreludeClassUnique 28
895 monadPlusClassKey, randomClassKey, randomGenClassKey :: Unique
896 monadPlusClassKey = mkPreludeClassUnique 30
897 randomClassKey = mkPreludeClassUnique 31
898 randomGenClassKey = mkPreludeClassUnique 32
900 isStringClassKey :: Unique
901 isStringClassKey = mkPreludeClassUnique 33
903 applicativeClassKey, foldableClassKey, traversableClassKey :: Unique
904 applicativeClassKey = mkPreludeClassUnique 34
905 foldableClassKey = mkPreludeClassUnique 35
906 traversableClassKey = mkPreludeClassUnique 36
909 %************************************************************************
911 \subsubsection[Uniques-prelude-TyCons]{@Uniques@ for wired-in @TyCons@}
913 %************************************************************************
916 addrPrimTyConKey, arrayPrimTyConKey, boolTyConKey, byteArrayPrimTyConKey,
917 charPrimTyConKey, charTyConKey, doublePrimTyConKey, doubleTyConKey,
918 floatPrimTyConKey, floatTyConKey, funTyConKey, intPrimTyConKey,
919 intTyConKey, int8TyConKey, int16TyConKey, int32PrimTyConKey,
920 int32TyConKey, int64PrimTyConKey, int64TyConKey, integerTyConKey,
921 listTyConKey, foreignObjPrimTyConKey, weakPrimTyConKey,
922 mutableArrayPrimTyConKey, mutableByteArrayPrimTyConKey,
923 orderingTyConKey, mVarPrimTyConKey, ratioTyConKey, rationalTyConKey,
924 realWorldTyConKey, stablePtrPrimTyConKey, stablePtrTyConKey :: Unique
925 addrPrimTyConKey = mkPreludeTyConUnique 1
926 arrayPrimTyConKey = mkPreludeTyConUnique 3
927 boolTyConKey = mkPreludeTyConUnique 4
928 byteArrayPrimTyConKey = mkPreludeTyConUnique 5
929 charPrimTyConKey = mkPreludeTyConUnique 7
930 charTyConKey = mkPreludeTyConUnique 8
931 doublePrimTyConKey = mkPreludeTyConUnique 9
932 doubleTyConKey = mkPreludeTyConUnique 10
933 floatPrimTyConKey = mkPreludeTyConUnique 11
934 floatTyConKey = mkPreludeTyConUnique 12
935 funTyConKey = mkPreludeTyConUnique 13
936 intPrimTyConKey = mkPreludeTyConUnique 14
937 intTyConKey = mkPreludeTyConUnique 15
938 int8TyConKey = mkPreludeTyConUnique 16
939 int16TyConKey = mkPreludeTyConUnique 17
940 int32PrimTyConKey = mkPreludeTyConUnique 18
941 int32TyConKey = mkPreludeTyConUnique 19
942 int64PrimTyConKey = mkPreludeTyConUnique 20
943 int64TyConKey = mkPreludeTyConUnique 21
944 integerTyConKey = mkPreludeTyConUnique 22
945 listTyConKey = mkPreludeTyConUnique 23
946 foreignObjPrimTyConKey = mkPreludeTyConUnique 24
947 weakPrimTyConKey = mkPreludeTyConUnique 27
948 mutableArrayPrimTyConKey = mkPreludeTyConUnique 28
949 mutableByteArrayPrimTyConKey = mkPreludeTyConUnique 29
950 orderingTyConKey = mkPreludeTyConUnique 30
951 mVarPrimTyConKey = mkPreludeTyConUnique 31
952 ratioTyConKey = mkPreludeTyConUnique 32
953 rationalTyConKey = mkPreludeTyConUnique 33
954 realWorldTyConKey = mkPreludeTyConUnique 34
955 stablePtrPrimTyConKey = mkPreludeTyConUnique 35
956 stablePtrTyConKey = mkPreludeTyConUnique 36
958 anyPrimTyConKey, anyPrimTyCon1Key :: Unique
959 anyPrimTyConKey = mkPreludeTyConUnique 37
960 anyPrimTyCon1Key = mkPreludeTyConUnique 38
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 :: 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
1079 -- Generic data constructors
1080 crossDataConKey, inlDataConKey, inrDataConKey, genUnitDataConKey :: Unique
1081 crossDataConKey = mkPreludeDataConUnique 20
1082 inlDataConKey = mkPreludeDataConUnique 21
1083 inrDataConKey = mkPreludeDataConUnique 22
1084 genUnitDataConKey = mkPreludeDataConUnique 23
1086 -- Data constructor for parallel arrays
1087 parrDataConKey :: Unique
1088 parrDataConKey = mkPreludeDataConUnique 24
1090 leftDataConKey, rightDataConKey :: Unique
1091 leftDataConKey = mkPreludeDataConUnique 25
1092 rightDataConKey = mkPreludeDataConUnique 26
1095 %************************************************************************
1097 \subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}
1099 %************************************************************************
1102 absentErrorIdKey, augmentIdKey, appendIdKey, buildIdKey, errorIdKey,
1103 foldlIdKey, foldrIdKey, recSelErrorIdKey,
1104 integerMinusOneIdKey, integerPlusOneIdKey,
1105 integerPlusTwoIdKey, integerZeroIdKey,
1106 int2IntegerIdKey, seqIdKey, irrefutPatErrorIdKey, eqStringIdKey,
1107 noMethodBindingErrorIdKey, nonExhaustiveGuardsErrorIdKey,
1108 runtimeErrorIdKey, parErrorIdKey, parIdKey, patErrorIdKey,
1109 realWorldPrimIdKey, recConErrorIdKey, recUpdErrorIdKey,
1111 unpackCStringUtf8IdKey, unpackCStringAppendIdKey,
1112 unpackCStringFoldrIdKey, unpackCStringIdKey :: Unique
1113 absentErrorIdKey = mkPreludeMiscIdUnique 1
1114 augmentIdKey = mkPreludeMiscIdUnique 3
1115 appendIdKey = mkPreludeMiscIdUnique 4
1116 buildIdKey = mkPreludeMiscIdUnique 5
1117 errorIdKey = mkPreludeMiscIdUnique 6
1118 foldlIdKey = mkPreludeMiscIdUnique 7
1119 foldrIdKey = mkPreludeMiscIdUnique 8
1120 recSelErrorIdKey = mkPreludeMiscIdUnique 9
1121 integerMinusOneIdKey = mkPreludeMiscIdUnique 10
1122 integerPlusOneIdKey = mkPreludeMiscIdUnique 11
1123 integerPlusTwoIdKey = mkPreludeMiscIdUnique 12
1124 integerZeroIdKey = mkPreludeMiscIdUnique 13
1125 int2IntegerIdKey = mkPreludeMiscIdUnique 14
1126 seqIdKey = mkPreludeMiscIdUnique 15
1127 irrefutPatErrorIdKey = mkPreludeMiscIdUnique 16
1128 eqStringIdKey = mkPreludeMiscIdUnique 17
1129 noMethodBindingErrorIdKey = mkPreludeMiscIdUnique 18
1130 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 19
1131 runtimeErrorIdKey = mkPreludeMiscIdUnique 20
1132 parErrorIdKey = mkPreludeMiscIdUnique 21
1133 parIdKey = mkPreludeMiscIdUnique 22
1134 patErrorIdKey = mkPreludeMiscIdUnique 23
1135 realWorldPrimIdKey = mkPreludeMiscIdUnique 24
1136 recConErrorIdKey = mkPreludeMiscIdUnique 25
1137 recUpdErrorIdKey = mkPreludeMiscIdUnique 26
1138 traceIdKey = mkPreludeMiscIdUnique 27
1139 unpackCStringUtf8IdKey = mkPreludeMiscIdUnique 28
1140 unpackCStringAppendIdKey = mkPreludeMiscIdUnique 29
1141 unpackCStringFoldrIdKey = mkPreludeMiscIdUnique 30
1142 unpackCStringIdKey = mkPreludeMiscIdUnique 31
1144 unsafeCoerceIdKey, concatIdKey, filterIdKey, zipIdKey, bindIOIdKey,
1145 returnIOIdKey, deRefStablePtrIdKey, newStablePtrIdKey,
1146 smallIntegerIdKey, plusIntegerIdKey, timesIntegerIdKey,
1147 printIdKey, failIOIdKey, nullAddrIdKey, voidArgIdKey,
1148 fstIdKey, sndIdKey, otherwiseIdKey, assertIdKey, runSTRepIdKey :: Unique
1149 unsafeCoerceIdKey = mkPreludeMiscIdUnique 32
1150 concatIdKey = mkPreludeMiscIdUnique 33
1151 filterIdKey = mkPreludeMiscIdUnique 34
1152 zipIdKey = mkPreludeMiscIdUnique 35
1153 bindIOIdKey = mkPreludeMiscIdUnique 36
1154 returnIOIdKey = mkPreludeMiscIdUnique 37
1155 deRefStablePtrIdKey = mkPreludeMiscIdUnique 38
1156 newStablePtrIdKey = mkPreludeMiscIdUnique 39
1157 smallIntegerIdKey = mkPreludeMiscIdUnique 40
1158 plusIntegerIdKey = mkPreludeMiscIdUnique 41
1159 timesIntegerIdKey = mkPreludeMiscIdUnique 42
1160 printIdKey = mkPreludeMiscIdUnique 43
1161 failIOIdKey = mkPreludeMiscIdUnique 44
1162 nullAddrIdKey = mkPreludeMiscIdUnique 46
1163 voidArgIdKey = mkPreludeMiscIdUnique 47
1164 fstIdKey = mkPreludeMiscIdUnique 49
1165 sndIdKey = mkPreludeMiscIdUnique 50
1166 otherwiseIdKey = mkPreludeMiscIdUnique 51
1167 assertIdKey = mkPreludeMiscIdUnique 53
1168 runSTRepIdKey = mkPreludeMiscIdUnique 54
1170 rootMainKey, runMainKey :: Unique
1171 rootMainKey = mkPreludeMiscIdUnique 55
1172 runMainKey = mkPreludeMiscIdUnique 56
1174 thenIOIdKey, lazyIdKey, assertErrorIdKey :: Unique
1175 thenIOIdKey = mkPreludeMiscIdUnique 59
1176 lazyIdKey = mkPreludeMiscIdUnique 60
1177 assertErrorIdKey = mkPreludeMiscIdUnique 61
1179 breakpointIdKey, breakpointCondIdKey, breakpointAutoIdKey,
1180 breakpointJumpIdKey, breakpointCondJumpIdKey,
1181 breakpointAutoJumpIdKey :: Unique
1182 breakpointIdKey = mkPreludeMiscIdUnique 62
1183 breakpointCondIdKey = mkPreludeMiscIdUnique 63
1184 breakpointAutoIdKey = mkPreludeMiscIdUnique 64
1185 breakpointJumpIdKey = mkPreludeMiscIdUnique 65
1186 breakpointCondJumpIdKey = mkPreludeMiscIdUnique 66
1187 breakpointAutoJumpIdKey = mkPreludeMiscIdUnique 67
1189 inlineIdKey :: Unique
1190 inlineIdKey = mkPreludeMiscIdUnique 68
1192 mapIdKey, groupWithIdKey :: Unique
1193 mapIdKey = mkPreludeMiscIdUnique 69
1194 groupWithIdKey = mkPreludeMiscIdUnique 70
1196 -- Parallel array functions
1197 singletonPIdKey, nullPIdKey, lengthPIdKey, replicatePIdKey, mapPIdKey,
1198 filterPIdKey, zipPIdKey, crossMapPIdKey, indexPIdKey, toPIdKey,
1199 enumFromToPIdKey, enumFromThenToPIdKey, emptyPIdKey, appPIdKey :: Unique
1200 singletonPIdKey = mkPreludeMiscIdUnique 79
1201 nullPIdKey = mkPreludeMiscIdUnique 80
1202 lengthPIdKey = mkPreludeMiscIdUnique 81
1203 replicatePIdKey = mkPreludeMiscIdUnique 82
1204 mapPIdKey = mkPreludeMiscIdUnique 83
1205 filterPIdKey = mkPreludeMiscIdUnique 84
1206 zipPIdKey = mkPreludeMiscIdUnique 85
1207 crossMapPIdKey = mkPreludeMiscIdUnique 86
1208 indexPIdKey = mkPreludeMiscIdUnique 87
1209 toPIdKey = mkPreludeMiscIdUnique 88
1210 enumFromToPIdKey = mkPreludeMiscIdUnique 89
1211 enumFromThenToPIdKey = mkPreludeMiscIdUnique 90
1212 emptyPIdKey = mkPreludeMiscIdUnique 91
1213 appPIdKey = mkPreludeMiscIdUnique 92
1216 unmarshalObjectIdKey, marshalObjectIdKey, marshalStringIdKey,
1217 unmarshalStringIdKey, checkDotnetResNameIdKey :: Unique
1218 unmarshalObjectIdKey = mkPreludeMiscIdUnique 94
1219 marshalObjectIdKey = mkPreludeMiscIdUnique 95
1220 marshalStringIdKey = mkPreludeMiscIdUnique 96
1221 unmarshalStringIdKey = mkPreludeMiscIdUnique 97
1222 checkDotnetResNameIdKey = mkPreludeMiscIdUnique 98
1226 Certain class operations from Prelude classes. They get their own
1227 uniques so we can look them up easily when we want to conjure them up
1228 during type checking.
1231 -- Just a place holder for unbound variables produced by the renamer:
1232 unboundKey :: Unique
1233 unboundKey = mkPreludeMiscIdUnique 101
1235 fromIntegerClassOpKey, minusClassOpKey, fromRationalClassOpKey,
1236 enumFromClassOpKey, enumFromThenClassOpKey, enumFromToClassOpKey,
1237 enumFromThenToClassOpKey, eqClassOpKey, geClassOpKey, negateClassOpKey,
1238 failMClassOpKey, bindMClassOpKey, thenMClassOpKey, returnMClassOpKey
1240 fromIntegerClassOpKey = mkPreludeMiscIdUnique 102
1241 minusClassOpKey = mkPreludeMiscIdUnique 103
1242 fromRationalClassOpKey = mkPreludeMiscIdUnique 104
1243 enumFromClassOpKey = mkPreludeMiscIdUnique 105
1244 enumFromThenClassOpKey = mkPreludeMiscIdUnique 106
1245 enumFromToClassOpKey = mkPreludeMiscIdUnique 107
1246 enumFromThenToClassOpKey = mkPreludeMiscIdUnique 108
1247 eqClassOpKey = mkPreludeMiscIdUnique 109
1248 geClassOpKey = mkPreludeMiscIdUnique 110
1249 negateClassOpKey = mkPreludeMiscIdUnique 111
1250 failMClassOpKey = mkPreludeMiscIdUnique 112
1251 bindMClassOpKey = mkPreludeMiscIdUnique 113 -- (>>=)
1252 thenMClassOpKey = mkPreludeMiscIdUnique 114 -- (>>)
1253 returnMClassOpKey = mkPreludeMiscIdUnique 117
1255 -- Recursive do notation
1257 mfixIdKey = mkPreludeMiscIdUnique 118
1260 arrAIdKey, composeAIdKey, firstAIdKey, appAIdKey, choiceAIdKey,
1261 loopAIdKey :: Unique
1262 arrAIdKey = mkPreludeMiscIdUnique 119
1263 composeAIdKey = mkPreludeMiscIdUnique 120 -- >>>
1264 firstAIdKey = mkPreludeMiscIdUnique 121
1265 appAIdKey = mkPreludeMiscIdUnique 122
1266 choiceAIdKey = mkPreludeMiscIdUnique 123 -- |||
1267 loopAIdKey = mkPreludeMiscIdUnique 124
1269 fromStringClassOpKey :: Unique
1270 fromStringClassOpKey = mkPreludeMiscIdUnique 125
1272 -- Annotation type checking
1273 toAnnotationWrapperIdKey :: Unique
1274 toAnnotationWrapperIdKey = mkPreludeMiscIdUnique 126
1277 ---------------- Template Haskell -------------------
1278 -- USES IdUniques 200-399
1279 -----------------------------------------------------
1283 %************************************************************************
1285 \subsection{Standard groups of types}
1287 %************************************************************************
1290 numericTyKeys :: [Unique]
1301 %************************************************************************
1303 \subsection[Class-std-groups]{Standard groups of Prelude classes}
1305 %************************************************************************
1307 NOTE: @Eq@ and @Text@ do need to appear in @standardClasses@
1308 even though every numeric class has these two as a superclass,
1309 because the list of ambiguous dictionaries hasn't been simplified.
1312 numericClassKeys :: [Unique]
1318 ++ fractionalClassKeys
1320 fractionalClassKeys :: [Unique]
1321 fractionalClassKeys =
1322 [ fractionalClassKey
1328 -- the strictness analyser needs to know about numeric types
1329 -- (see SaAbsInt.lhs)
1330 needsDataDeclCtxtClassKeys :: [Unique]
1331 needsDataDeclCtxtClassKeys = -- see comments in TcDeriv
1335 -- The "standard classes" are used in defaulting (Haskell 98 report 4.3.4),
1336 -- and are: "classes defined in the Prelude or a standard library"
1337 standardClassKeys :: [Unique]
1338 standardClassKeys = derivableClassKeys ++ numericClassKeys
1339 ++ [randomClassKey, randomGenClassKey,
1341 monadClassKey, monadPlusClassKey,
1343 applicativeClassKey, foldableClassKey, traversableClassKey
1347 @derivableClassKeys@ is also used in checking \tr{deriving} constructs
1351 derivableClassKeys :: [Unique]
1353 = [ eqClassKey, ordClassKey, enumClassKey, ixClassKey,
1354 boundedClassKey, showClassKey, readClassKey ]