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, integerDataConName,
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_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_LIST = mkBaseModule (fsLit "GHC.List")
259 gHC_PARR = mkBaseModule (fsLit "GHC.PArr")
260 gHC_TUPLE = mkPrimModule (fsLit "GHC.Tuple")
261 dATA_TUPLE = mkBaseModule (fsLit "Data.Tuple")
262 dATA_EITHER = mkBaseModule (fsLit "Data.Either")
263 dATA_STRING = mkBaseModule (fsLit "Data.String")
264 dATA_FOLDABLE = mkBaseModule (fsLit "Data.Foldable")
265 dATA_TRAVERSABLE= mkBaseModule (fsLit "Data.Traversable")
266 gHC_PACK = mkBaseModule (fsLit "GHC.Pack")
267 gHC_CONC = mkBaseModule (fsLit "GHC.Conc")
268 gHC_IO = mkBaseModule (fsLit "GHC.IO")
269 gHC_IO_Exception = mkBaseModule (fsLit "GHC.IO.Exception")
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,
637 integerTyConName, integerDataConName, smallIntegerName :: Name
638 numClassName = clsQual gHC_NUM (fsLit "Num") numClassKey
639 fromIntegerName = methName gHC_NUM (fsLit "fromInteger") fromIntegerClassOpKey
640 minusName = methName gHC_NUM (fsLit "-") minusClassOpKey
641 negateName = methName gHC_NUM (fsLit "negate") negateClassOpKey
642 plusIntegerName = varQual gHC_INTEGER (fsLit "plusInteger") plusIntegerIdKey
643 timesIntegerName = varQual gHC_INTEGER (fsLit "timesInteger") timesIntegerIdKey
644 integerTyConName = tcQual gHC_INTEGER (fsLit "Integer") integerTyConKey
645 integerDataConName = conName gHC_INTEGER (fsLit "Integer") integerDataConKey
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_IO (fsLit "thenIO") thenIOIdKey
746 bindIOName = varQual gHC_IO (fsLit "bindIO") bindIOIdKey
747 returnIOName = varQual gHC_IO (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 :: Unique
927 addrPrimTyConKey = mkPreludeTyConUnique 1
928 arrayPrimTyConKey = mkPreludeTyConUnique 3
929 boolTyConKey = mkPreludeTyConUnique 4
930 byteArrayPrimTyConKey = mkPreludeTyConUnique 5
931 charPrimTyConKey = mkPreludeTyConUnique 7
932 charTyConKey = mkPreludeTyConUnique 8
933 doublePrimTyConKey = mkPreludeTyConUnique 9
934 doubleTyConKey = mkPreludeTyConUnique 10
935 floatPrimTyConKey = mkPreludeTyConUnique 11
936 floatTyConKey = mkPreludeTyConUnique 12
937 funTyConKey = mkPreludeTyConUnique 13
938 intPrimTyConKey = mkPreludeTyConUnique 14
939 intTyConKey = mkPreludeTyConUnique 15
940 int8TyConKey = mkPreludeTyConUnique 16
941 int16TyConKey = mkPreludeTyConUnique 17
942 int32PrimTyConKey = mkPreludeTyConUnique 18
943 int32TyConKey = mkPreludeTyConUnique 19
944 int64PrimTyConKey = mkPreludeTyConUnique 20
945 int64TyConKey = mkPreludeTyConUnique 21
946 integerTyConKey = mkPreludeTyConUnique 22
947 listTyConKey = mkPreludeTyConUnique 23
948 foreignObjPrimTyConKey = mkPreludeTyConUnique 24
949 weakPrimTyConKey = mkPreludeTyConUnique 27
950 mutableArrayPrimTyConKey = mkPreludeTyConUnique 28
951 mutableByteArrayPrimTyConKey = mkPreludeTyConUnique 29
952 orderingTyConKey = mkPreludeTyConUnique 30
953 mVarPrimTyConKey = mkPreludeTyConUnique 31
954 ratioTyConKey = mkPreludeTyConUnique 32
955 rationalTyConKey = mkPreludeTyConUnique 33
956 realWorldTyConKey = mkPreludeTyConUnique 34
957 stablePtrPrimTyConKey = mkPreludeTyConUnique 35
958 stablePtrTyConKey = mkPreludeTyConUnique 36
960 anyPrimTyConKey, anyPrimTyCon1Key :: Unique
961 anyPrimTyConKey = mkPreludeTyConUnique 37
962 anyPrimTyCon1Key = mkPreludeTyConUnique 38
964 statePrimTyConKey, stableNamePrimTyConKey, stableNameTyConKey,
965 mutVarPrimTyConKey, ioTyConKey,
966 wordPrimTyConKey, wordTyConKey, word8TyConKey, word16TyConKey,
967 word32PrimTyConKey, word32TyConKey, word64PrimTyConKey, word64TyConKey,
968 liftedConKey, unliftedConKey, anyBoxConKey, kindConKey, boxityConKey,
969 typeConKey, threadIdPrimTyConKey, bcoPrimTyConKey, ptrTyConKey,
970 funPtrTyConKey, tVarPrimTyConKey :: Unique
971 statePrimTyConKey = mkPreludeTyConUnique 50
972 stableNamePrimTyConKey = mkPreludeTyConUnique 51
973 stableNameTyConKey = mkPreludeTyConUnique 52
974 mutVarPrimTyConKey = mkPreludeTyConUnique 55
975 ioTyConKey = mkPreludeTyConUnique 56
976 wordPrimTyConKey = mkPreludeTyConUnique 58
977 wordTyConKey = mkPreludeTyConUnique 59
978 word8TyConKey = mkPreludeTyConUnique 60
979 word16TyConKey = mkPreludeTyConUnique 61
980 word32PrimTyConKey = mkPreludeTyConUnique 62
981 word32TyConKey = mkPreludeTyConUnique 63
982 word64PrimTyConKey = mkPreludeTyConUnique 64
983 word64TyConKey = mkPreludeTyConUnique 65
984 liftedConKey = mkPreludeTyConUnique 66
985 unliftedConKey = mkPreludeTyConUnique 67
986 anyBoxConKey = mkPreludeTyConUnique 68
987 kindConKey = mkPreludeTyConUnique 69
988 boxityConKey = mkPreludeTyConUnique 70
989 typeConKey = mkPreludeTyConUnique 71
990 threadIdPrimTyConKey = mkPreludeTyConUnique 72
991 bcoPrimTyConKey = mkPreludeTyConUnique 73
992 ptrTyConKey = mkPreludeTyConUnique 74
993 funPtrTyConKey = mkPreludeTyConUnique 75
994 tVarPrimTyConKey = mkPreludeTyConUnique 76
996 -- Generic Type Constructors
997 crossTyConKey, plusTyConKey, genUnitTyConKey :: Unique
998 crossTyConKey = mkPreludeTyConUnique 79
999 plusTyConKey = mkPreludeTyConUnique 80
1000 genUnitTyConKey = mkPreludeTyConUnique 81
1002 -- Parallel array type constructor
1003 parrTyConKey :: Unique
1004 parrTyConKey = mkPreludeTyConUnique 82
1007 objectTyConKey :: Unique
1008 objectTyConKey = mkPreludeTyConUnique 83
1010 eitherTyConKey :: Unique
1011 eitherTyConKey = mkPreludeTyConUnique 84
1013 -- Super Kinds constructors
1014 tySuperKindTyConKey, coSuperKindTyConKey :: Unique
1015 tySuperKindTyConKey = mkPreludeTyConUnique 85
1016 coSuperKindTyConKey = mkPreludeTyConUnique 86
1018 -- Kind constructors
1019 liftedTypeKindTyConKey, openTypeKindTyConKey, unliftedTypeKindTyConKey,
1020 ubxTupleKindTyConKey, argTypeKindTyConKey :: Unique
1021 liftedTypeKindTyConKey = mkPreludeTyConUnique 87
1022 openTypeKindTyConKey = mkPreludeTyConUnique 88
1023 unliftedTypeKindTyConKey = mkPreludeTyConUnique 89
1024 ubxTupleKindTyConKey = mkPreludeTyConUnique 90
1025 argTypeKindTyConKey = mkPreludeTyConUnique 91
1027 -- Coercion constructors
1028 symCoercionTyConKey, transCoercionTyConKey, leftCoercionTyConKey,
1029 rightCoercionTyConKey, instCoercionTyConKey, unsafeCoercionTyConKey
1031 symCoercionTyConKey = mkPreludeTyConUnique 93
1032 transCoercionTyConKey = mkPreludeTyConUnique 94
1033 leftCoercionTyConKey = mkPreludeTyConUnique 95
1034 rightCoercionTyConKey = mkPreludeTyConUnique 96
1035 instCoercionTyConKey = mkPreludeTyConUnique 97
1036 unsafeCoercionTyConKey = mkPreludeTyConUnique 98
1038 unknownTyConKey, unknown1TyConKey, unknown2TyConKey, unknown3TyConKey,
1039 opaqueTyConKey :: Unique
1040 unknownTyConKey = mkPreludeTyConUnique 99
1041 unknown1TyConKey = mkPreludeTyConUnique 130
1042 unknown2TyConKey = mkPreludeTyConUnique 131
1043 unknown3TyConKey = mkPreludeTyConUnique 132
1044 opaqueTyConKey = mkPreludeTyConUnique 133
1046 stringTyConKey :: Unique
1047 stringTyConKey = mkPreludeTyConUnique 134
1049 ---------------- Template Haskell -------------------
1050 -- USES TyConUniques 100-129
1051 -----------------------------------------------------
1053 unitTyConKey :: Unique
1054 unitTyConKey = mkTupleTyConUnique Boxed 0
1057 %************************************************************************
1059 \subsubsection[Uniques-prelude-DataCons]{@Uniques@ for wired-in @DataCons@}
1061 %************************************************************************
1064 charDataConKey, consDataConKey, doubleDataConKey, falseDataConKey,
1065 floatDataConKey, intDataConKey, nilDataConKey, ratioDataConKey,
1066 stableNameDataConKey, trueDataConKey, wordDataConKey,
1067 ioDataConKey, integerDataConKey :: Unique
1068 charDataConKey = mkPreludeDataConUnique 1
1069 consDataConKey = mkPreludeDataConUnique 2
1070 doubleDataConKey = mkPreludeDataConUnique 3
1071 falseDataConKey = mkPreludeDataConUnique 4
1072 floatDataConKey = mkPreludeDataConUnique 5
1073 intDataConKey = mkPreludeDataConUnique 6
1074 nilDataConKey = mkPreludeDataConUnique 11
1075 ratioDataConKey = mkPreludeDataConUnique 12
1076 stableNameDataConKey = mkPreludeDataConUnique 14
1077 trueDataConKey = mkPreludeDataConUnique 15
1078 wordDataConKey = mkPreludeDataConUnique 16
1079 ioDataConKey = mkPreludeDataConUnique 17
1080 integerDataConKey = mkPreludeDataConUnique 18
1082 -- Generic data constructors
1083 crossDataConKey, inlDataConKey, inrDataConKey, genUnitDataConKey :: Unique
1084 crossDataConKey = mkPreludeDataConUnique 20
1085 inlDataConKey = mkPreludeDataConUnique 21
1086 inrDataConKey = mkPreludeDataConUnique 22
1087 genUnitDataConKey = mkPreludeDataConUnique 23
1089 -- Data constructor for parallel arrays
1090 parrDataConKey :: Unique
1091 parrDataConKey = mkPreludeDataConUnique 24
1093 leftDataConKey, rightDataConKey :: Unique
1094 leftDataConKey = mkPreludeDataConUnique 25
1095 rightDataConKey = mkPreludeDataConUnique 26
1098 %************************************************************************
1100 \subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}
1102 %************************************************************************
1105 absentErrorIdKey, augmentIdKey, appendIdKey, buildIdKey, errorIdKey,
1106 foldlIdKey, foldrIdKey, recSelErrorIdKey,
1107 integerMinusOneIdKey, integerPlusOneIdKey,
1108 integerPlusTwoIdKey, integerZeroIdKey,
1109 int2IntegerIdKey, seqIdKey, irrefutPatErrorIdKey, eqStringIdKey,
1110 noMethodBindingErrorIdKey, nonExhaustiveGuardsErrorIdKey,
1111 runtimeErrorIdKey, parErrorIdKey, parIdKey, patErrorIdKey,
1112 realWorldPrimIdKey, recConErrorIdKey, recUpdErrorIdKey,
1114 unpackCStringUtf8IdKey, unpackCStringAppendIdKey,
1115 unpackCStringFoldrIdKey, unpackCStringIdKey :: Unique
1116 absentErrorIdKey = mkPreludeMiscIdUnique 1
1117 augmentIdKey = mkPreludeMiscIdUnique 3
1118 appendIdKey = mkPreludeMiscIdUnique 4
1119 buildIdKey = mkPreludeMiscIdUnique 5
1120 errorIdKey = mkPreludeMiscIdUnique 6
1121 foldlIdKey = mkPreludeMiscIdUnique 7
1122 foldrIdKey = mkPreludeMiscIdUnique 8
1123 recSelErrorIdKey = mkPreludeMiscIdUnique 9
1124 integerMinusOneIdKey = mkPreludeMiscIdUnique 10
1125 integerPlusOneIdKey = mkPreludeMiscIdUnique 11
1126 integerPlusTwoIdKey = mkPreludeMiscIdUnique 12
1127 integerZeroIdKey = mkPreludeMiscIdUnique 13
1128 int2IntegerIdKey = mkPreludeMiscIdUnique 14
1129 seqIdKey = mkPreludeMiscIdUnique 15
1130 irrefutPatErrorIdKey = mkPreludeMiscIdUnique 16
1131 eqStringIdKey = mkPreludeMiscIdUnique 17
1132 noMethodBindingErrorIdKey = mkPreludeMiscIdUnique 18
1133 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 19
1134 runtimeErrorIdKey = mkPreludeMiscIdUnique 20
1135 parErrorIdKey = mkPreludeMiscIdUnique 21
1136 parIdKey = mkPreludeMiscIdUnique 22
1137 patErrorIdKey = mkPreludeMiscIdUnique 23
1138 realWorldPrimIdKey = mkPreludeMiscIdUnique 24
1139 recConErrorIdKey = mkPreludeMiscIdUnique 25
1140 recUpdErrorIdKey = mkPreludeMiscIdUnique 26
1141 traceIdKey = mkPreludeMiscIdUnique 27
1142 unpackCStringUtf8IdKey = mkPreludeMiscIdUnique 28
1143 unpackCStringAppendIdKey = mkPreludeMiscIdUnique 29
1144 unpackCStringFoldrIdKey = mkPreludeMiscIdUnique 30
1145 unpackCStringIdKey = mkPreludeMiscIdUnique 31
1147 unsafeCoerceIdKey, concatIdKey, filterIdKey, zipIdKey, bindIOIdKey,
1148 returnIOIdKey, deRefStablePtrIdKey, newStablePtrIdKey,
1149 smallIntegerIdKey, plusIntegerIdKey, timesIntegerIdKey,
1150 printIdKey, failIOIdKey, nullAddrIdKey, voidArgIdKey,
1151 fstIdKey, sndIdKey, otherwiseIdKey, assertIdKey, runSTRepIdKey :: Unique
1152 unsafeCoerceIdKey = mkPreludeMiscIdUnique 32
1153 concatIdKey = mkPreludeMiscIdUnique 33
1154 filterIdKey = mkPreludeMiscIdUnique 34
1155 zipIdKey = mkPreludeMiscIdUnique 35
1156 bindIOIdKey = mkPreludeMiscIdUnique 36
1157 returnIOIdKey = mkPreludeMiscIdUnique 37
1158 deRefStablePtrIdKey = mkPreludeMiscIdUnique 38
1159 newStablePtrIdKey = mkPreludeMiscIdUnique 39
1160 smallIntegerIdKey = mkPreludeMiscIdUnique 40
1161 plusIntegerIdKey = mkPreludeMiscIdUnique 41
1162 timesIntegerIdKey = mkPreludeMiscIdUnique 42
1163 printIdKey = mkPreludeMiscIdUnique 43
1164 failIOIdKey = mkPreludeMiscIdUnique 44
1165 nullAddrIdKey = mkPreludeMiscIdUnique 46
1166 voidArgIdKey = mkPreludeMiscIdUnique 47
1167 fstIdKey = mkPreludeMiscIdUnique 49
1168 sndIdKey = mkPreludeMiscIdUnique 50
1169 otherwiseIdKey = mkPreludeMiscIdUnique 51
1170 assertIdKey = mkPreludeMiscIdUnique 53
1171 runSTRepIdKey = mkPreludeMiscIdUnique 54
1173 rootMainKey, runMainKey :: Unique
1174 rootMainKey = mkPreludeMiscIdUnique 55
1175 runMainKey = mkPreludeMiscIdUnique 56
1177 thenIOIdKey, lazyIdKey, assertErrorIdKey :: Unique
1178 thenIOIdKey = mkPreludeMiscIdUnique 59
1179 lazyIdKey = mkPreludeMiscIdUnique 60
1180 assertErrorIdKey = mkPreludeMiscIdUnique 61
1182 breakpointIdKey, breakpointCondIdKey, breakpointAutoIdKey,
1183 breakpointJumpIdKey, breakpointCondJumpIdKey,
1184 breakpointAutoJumpIdKey :: Unique
1185 breakpointIdKey = mkPreludeMiscIdUnique 62
1186 breakpointCondIdKey = mkPreludeMiscIdUnique 63
1187 breakpointAutoIdKey = mkPreludeMiscIdUnique 64
1188 breakpointJumpIdKey = mkPreludeMiscIdUnique 65
1189 breakpointCondJumpIdKey = mkPreludeMiscIdUnique 66
1190 breakpointAutoJumpIdKey = mkPreludeMiscIdUnique 67
1192 inlineIdKey :: Unique
1193 inlineIdKey = mkPreludeMiscIdUnique 68
1195 mapIdKey, groupWithIdKey :: Unique
1196 mapIdKey = mkPreludeMiscIdUnique 69
1197 groupWithIdKey = mkPreludeMiscIdUnique 70
1199 -- Parallel array functions
1200 singletonPIdKey, nullPIdKey, lengthPIdKey, replicatePIdKey, mapPIdKey,
1201 filterPIdKey, zipPIdKey, crossMapPIdKey, indexPIdKey, toPIdKey,
1202 enumFromToPIdKey, enumFromThenToPIdKey, emptyPIdKey, appPIdKey :: Unique
1203 singletonPIdKey = mkPreludeMiscIdUnique 79
1204 nullPIdKey = mkPreludeMiscIdUnique 80
1205 lengthPIdKey = mkPreludeMiscIdUnique 81
1206 replicatePIdKey = mkPreludeMiscIdUnique 82
1207 mapPIdKey = mkPreludeMiscIdUnique 83
1208 filterPIdKey = mkPreludeMiscIdUnique 84
1209 zipPIdKey = mkPreludeMiscIdUnique 85
1210 crossMapPIdKey = mkPreludeMiscIdUnique 86
1211 indexPIdKey = mkPreludeMiscIdUnique 87
1212 toPIdKey = mkPreludeMiscIdUnique 88
1213 enumFromToPIdKey = mkPreludeMiscIdUnique 89
1214 enumFromThenToPIdKey = mkPreludeMiscIdUnique 90
1215 emptyPIdKey = mkPreludeMiscIdUnique 91
1216 appPIdKey = mkPreludeMiscIdUnique 92
1219 unmarshalObjectIdKey, marshalObjectIdKey, marshalStringIdKey,
1220 unmarshalStringIdKey, checkDotnetResNameIdKey :: Unique
1221 unmarshalObjectIdKey = mkPreludeMiscIdUnique 94
1222 marshalObjectIdKey = mkPreludeMiscIdUnique 95
1223 marshalStringIdKey = mkPreludeMiscIdUnique 96
1224 unmarshalStringIdKey = mkPreludeMiscIdUnique 97
1225 checkDotnetResNameIdKey = mkPreludeMiscIdUnique 98
1229 Certain class operations from Prelude classes. They get their own
1230 uniques so we can look them up easily when we want to conjure them up
1231 during type checking.
1234 -- Just a place holder for unbound variables produced by the renamer:
1235 unboundKey :: Unique
1236 unboundKey = mkPreludeMiscIdUnique 101
1238 fromIntegerClassOpKey, minusClassOpKey, fromRationalClassOpKey,
1239 enumFromClassOpKey, enumFromThenClassOpKey, enumFromToClassOpKey,
1240 enumFromThenToClassOpKey, eqClassOpKey, geClassOpKey, negateClassOpKey,
1241 failMClassOpKey, bindMClassOpKey, thenMClassOpKey, returnMClassOpKey
1243 fromIntegerClassOpKey = mkPreludeMiscIdUnique 102
1244 minusClassOpKey = mkPreludeMiscIdUnique 103
1245 fromRationalClassOpKey = mkPreludeMiscIdUnique 104
1246 enumFromClassOpKey = mkPreludeMiscIdUnique 105
1247 enumFromThenClassOpKey = mkPreludeMiscIdUnique 106
1248 enumFromToClassOpKey = mkPreludeMiscIdUnique 107
1249 enumFromThenToClassOpKey = mkPreludeMiscIdUnique 108
1250 eqClassOpKey = mkPreludeMiscIdUnique 109
1251 geClassOpKey = mkPreludeMiscIdUnique 110
1252 negateClassOpKey = mkPreludeMiscIdUnique 111
1253 failMClassOpKey = mkPreludeMiscIdUnique 112
1254 bindMClassOpKey = mkPreludeMiscIdUnique 113 -- (>>=)
1255 thenMClassOpKey = mkPreludeMiscIdUnique 114 -- (>>)
1256 returnMClassOpKey = mkPreludeMiscIdUnique 117
1258 -- Recursive do notation
1260 mfixIdKey = mkPreludeMiscIdUnique 118
1263 arrAIdKey, composeAIdKey, firstAIdKey, appAIdKey, choiceAIdKey,
1264 loopAIdKey :: Unique
1265 arrAIdKey = mkPreludeMiscIdUnique 119
1266 composeAIdKey = mkPreludeMiscIdUnique 120 -- >>>
1267 firstAIdKey = mkPreludeMiscIdUnique 121
1268 appAIdKey = mkPreludeMiscIdUnique 122
1269 choiceAIdKey = mkPreludeMiscIdUnique 123 -- |||
1270 loopAIdKey = mkPreludeMiscIdUnique 124
1272 fromStringClassOpKey :: Unique
1273 fromStringClassOpKey = mkPreludeMiscIdUnique 125
1275 -- Annotation type checking
1276 toAnnotationWrapperIdKey :: Unique
1277 toAnnotationWrapperIdKey = mkPreludeMiscIdUnique 126
1280 ---------------- Template Haskell -------------------
1281 -- USES IdUniques 200-399
1282 -----------------------------------------------------
1286 %************************************************************************
1288 \subsection{Standard groups of types}
1290 %************************************************************************
1293 numericTyKeys :: [Unique]
1304 %************************************************************************
1306 \subsection[Class-std-groups]{Standard groups of Prelude classes}
1308 %************************************************************************
1310 NOTE: @Eq@ and @Text@ do need to appear in @standardClasses@
1311 even though every numeric class has these two as a superclass,
1312 because the list of ambiguous dictionaries hasn't been simplified.
1315 numericClassKeys :: [Unique]
1321 ++ fractionalClassKeys
1323 fractionalClassKeys :: [Unique]
1324 fractionalClassKeys =
1325 [ fractionalClassKey
1331 -- the strictness analyser needs to know about numeric types
1332 -- (see SaAbsInt.lhs)
1333 needsDataDeclCtxtClassKeys :: [Unique]
1334 needsDataDeclCtxtClassKeys = -- see comments in TcDeriv
1338 -- The "standard classes" are used in defaulting (Haskell 98 report 4.3.4),
1339 -- and are: "classes defined in the Prelude or a standard library"
1340 standardClassKeys :: [Unique]
1341 standardClassKeys = derivableClassKeys ++ numericClassKeys
1342 ++ [randomClassKey, randomGenClassKey,
1344 monadClassKey, monadPlusClassKey,
1346 applicativeClassKey, foldableClassKey, traversableClassKey
1350 @derivableClassKeys@ is also used in checking \tr{deriving} constructs
1354 derivableClassKeys :: [Unique]
1356 = [ eqClassKey, ordClassKey, enumClassKey, ixClassKey,
1357 boundedClassKey, showClassKey, readClassKey ]