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, mkSystemVarName )
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 association of
98 names with uniques. These ones are the *non* wired-in ones. The
99 wired in ones are defined in TysWiredIn etc.
101 The names for DPH can come from one of multiple backend packages. At the point where
102 'basicKnownKeyNames' is used, we don't know which backend it will be. Hence, we list
103 the names for multiple backends. That works out fine, although they use the same uniques,
104 as we are guaranteed to only load one backend; hence, only one of the different names
105 sharing a unique will be used.
108 basicKnownKeyNames :: [Name]
111 ++ typeableClassNames
112 ++ dphKnownKeyNames dphSeqPackageId ++ dphKnownKeyNames dphParPackageId
113 ++ [ -- Type constructors (synonyms especially)
114 ioTyConName, ioDataConName,
121 integerTyConName, smallIntegerName,
123 -- Classes. *Must* include:
124 -- classes that are grabbed by key (e.g., eqClassKey)
125 -- classes in "Class.standardClassKeys" (quite a few)
126 eqClassName, -- mentioned, derivable
127 ordClassName, -- derivable
128 boundedClassName, -- derivable
129 numClassName, -- mentioned, numeric
130 enumClassName, -- derivable
133 realClassName, -- numeric
134 integralClassName, -- numeric
135 fractionalClassName, -- numeric
136 floatingClassName, -- numeric
137 realFracClassName, -- numeric
138 realFloatClassName, -- numeric
141 applicativeClassName,
143 traversableClassName,
146 negateName, minusName, geName, eqName,
148 -- Conversion functions
149 fromRationalName, fromIntegerName,
150 toIntegerName, toRationalName,
151 fromIntegralName, realToFracName,
157 enumFromName, enumFromThenName,
158 enumFromThenToName, enumFromToName,
161 thenIOName, bindIOName, returnIOName, failIOName,
162 failMName, bindMName, thenMName, returnMName,
169 arrAName, composeAName, firstAName,
170 appAName, choiceAName, loopAName,
188 unpackCStringName, unpackCStringAppendName,
189 unpackCStringFoldrName, unpackCStringUtf8Name,
192 concatName, filterName, mapName,
193 zipName, foldrName, buildName, augmentName, appendName,
195 dollarName, -- The ($) apply function
197 -- FFI primitive types that are not wired-in.
198 stablePtrTyConName, ptrTyConName, funPtrTyConName,
199 int8TyConName, int16TyConName, int32TyConName, int64TyConName,
200 wordTyConName, word8TyConName, word16TyConName, word32TyConName, word64TyConName,
203 otherwiseIdName, inlineIdName,
204 plusIntegerName, timesIntegerName,
205 eqStringName, assertName, breakpointName, breakpointCondName,
206 breakpointAutoName, opaqueTyConName,
207 assertErrorName, runSTRepName,
208 printName, fstName, sndName,
211 monadFixClassName, mfixName,
214 randomClassName, randomGenClassName, monadPlusClassName,
216 -- Annotation type checking
217 toAnnotationWrapperName
220 , eitherTyConName, leftDataConName, rightDataConName
223 , objectTyConName, marshalObjectName, unmarshalObjectName
224 , marshalStringName, unmarshalStringName, checkDotnetResName
227 , genClassName, gen1ClassName
228 , datatypeClassName, constructorClassName, selectorClassName
230 -- Monad comprehensions
237 genericTyConNames :: [Name]
238 genericTyConNames = [
239 v1TyConName, u1TyConName, par1TyConName, rec1TyConName,
240 k1TyConName, m1TyConName, sumTyConName, prodTyConName,
241 compTyConName, rTyConName, pTyConName, dTyConName,
242 cTyConName, sTyConName, rec0TyConName, par0TyConName,
243 d1TyConName, c1TyConName, s1TyConName, noSelTyConName,
244 repTyConName, rep1TyConName
247 -- Know names from the DPH package which vary depending on the selected DPH backend.
249 dphKnownKeyNames :: PackageId -> [Name]
250 dphKnownKeyNames dphPkg
253 -- Parallel array operations
254 nullPName, lengthPName, replicatePName, singletonPName, mapPName,
255 filterPName, zipPName, crossMapPName, indexPName,
256 toPName, emptyPName, appPName,
257 enumFromToPName, enumFromThenToPName
263 %************************************************************************
265 \subsection{Module names}
267 %************************************************************************
270 --MetaHaskell Extension Add a new module here
273 pRELUDE = mkBaseModule_ pRELUDE_NAME
275 gHC_PRIM, gHC_TYPES, gHC_UNIT, gHC_ORDERING, gHC_GENERICS,
277 gHC_CLASSES, gHC_BASE, gHC_ENUM, gHC_CSTRING,
278 gHC_SHOW, gHC_READ, gHC_NUM, gHC_INTEGER, gHC_INTEGER_TYPE, gHC_LIST,
279 gHC_TUPLE, dATA_TUPLE, dATA_EITHER, dATA_STRING, dATA_FOLDABLE, dATA_TRAVERSABLE,
280 gHC_PACK, gHC_CONC, gHC_IO, gHC_IO_Exception,
281 gHC_ST, gHC_ARR, gHC_STABLE, gHC_ADDR, gHC_PTR, gHC_ERR, gHC_REAL,
282 gHC_FLOAT, gHC_TOP_HANDLER, sYSTEM_IO, dYNAMIC, tYPEABLE, gENERICS,
283 dOTNET, rEAD_PREC, lEX, gHC_INT, gHC_WORD, mONAD, mONAD_FIX, mONAD_GROUP, mONAD_ZIP,
284 aRROW, cONTROL_APPLICATIVE, gHC_DESUGAR, rANDOM, gHC_EXTS,
285 cONTROL_EXCEPTION_BASE :: Module
287 gHC_PRIM = mkPrimModule (fsLit "GHC.Prim") -- Primitive types and values
288 gHC_TYPES = mkPrimModule (fsLit "GHC.Types")
289 gHC_UNIT = mkPrimModule (fsLit "GHC.Unit")
290 gHC_ORDERING = mkPrimModule (fsLit "GHC.Ordering")
291 gHC_GENERICS = mkPrimModule (fsLit "GHC.Generics")
292 gHC_MAGIC = mkPrimModule (fsLit "GHC.Magic")
293 gHC_CSTRING = mkPrimModule (fsLit "GHC.CString")
295 gHC_CLASSES = mkBaseModule (fsLit "GHC.Classes")
296 gHC_BASE = mkBaseModule (fsLit "GHC.Base")
297 gHC_ENUM = mkBaseModule (fsLit "GHC.Enum")
298 gHC_SHOW = mkBaseModule (fsLit "GHC.Show")
299 gHC_READ = mkBaseModule (fsLit "GHC.Read")
300 gHC_NUM = mkBaseModule (fsLit "GHC.Num")
301 gHC_INTEGER = mkIntegerModule (fsLit "GHC.Integer")
302 gHC_INTEGER_TYPE= mkIntegerModule (fsLit "GHC.Integer.Type")
303 gHC_LIST = mkBaseModule (fsLit "GHC.List")
304 gHC_TUPLE = mkPrimModule (fsLit "GHC.Tuple")
305 dATA_TUPLE = mkBaseModule (fsLit "Data.Tuple")
306 dATA_EITHER = mkBaseModule (fsLit "Data.Either")
307 dATA_STRING = mkBaseModule (fsLit "Data.String")
308 dATA_FOLDABLE = mkBaseModule (fsLit "Data.Foldable")
309 dATA_TRAVERSABLE= mkBaseModule (fsLit "Data.Traversable")
310 gHC_PACK = mkBaseModule (fsLit "GHC.Pack")
311 gHC_CONC = mkBaseModule (fsLit "GHC.Conc")
312 gHC_IO = mkBaseModule (fsLit "GHC.IO")
313 gHC_IO_Exception = mkBaseModule (fsLit "GHC.IO.Exception")
314 gHC_ST = mkBaseModule (fsLit "GHC.ST")
315 gHC_ARR = mkBaseModule (fsLit "GHC.Arr")
316 gHC_STABLE = mkBaseModule (fsLit "GHC.Stable")
317 gHC_ADDR = mkBaseModule (fsLit "GHC.Addr")
318 gHC_PTR = mkBaseModule (fsLit "GHC.Ptr")
319 gHC_ERR = mkBaseModule (fsLit "GHC.Err")
320 gHC_REAL = mkBaseModule (fsLit "GHC.Real")
321 gHC_FLOAT = mkBaseModule (fsLit "GHC.Float")
322 gHC_TOP_HANDLER = mkBaseModule (fsLit "GHC.TopHandler")
323 sYSTEM_IO = mkBaseModule (fsLit "System.IO")
324 dYNAMIC = mkBaseModule (fsLit "Data.Dynamic")
325 tYPEABLE = mkBaseModule (fsLit "Data.Typeable")
326 gENERICS = mkBaseModule (fsLit "Data.Data")
327 dOTNET = mkBaseModule (fsLit "GHC.Dotnet")
328 rEAD_PREC = mkBaseModule (fsLit "Text.ParserCombinators.ReadPrec")
329 lEX = mkBaseModule (fsLit "Text.Read.Lex")
330 gHC_INT = mkBaseModule (fsLit "GHC.Int")
331 gHC_WORD = mkBaseModule (fsLit "GHC.Word")
332 mONAD = mkBaseModule (fsLit "Control.Monad")
333 mONAD_FIX = mkBaseModule (fsLit "Control.Monad.Fix")
334 mONAD_GROUP = mkBaseModule (fsLit "Control.Monad.Group")
335 mONAD_ZIP = mkBaseModule (fsLit "Control.Monad.Zip")
336 aRROW = mkBaseModule (fsLit "Control.Arrow")
337 cONTROL_APPLICATIVE = mkBaseModule (fsLit "Control.Applicative")
338 gHC_DESUGAR = mkBaseModule (fsLit "GHC.Desugar")
339 rANDOM = mkBaseModule (fsLit "System.Random")
340 gHC_EXTS = mkBaseModule (fsLit "GHC.Exts")
341 cONTROL_EXCEPTION_BASE = mkBaseModule (fsLit "Control.Exception.Base")
343 gHC_PARR :: PackageId -> Module
344 gHC_PARR pkg = mkModule pkg (mkModuleNameFS (fsLit "Data.Array.Parallel"))
347 gHC_PARR' = mkBaseModule (fsLit "GHC.PArr")
349 mAIN, rOOT_MAIN :: Module
350 mAIN = mkMainModule_ mAIN_NAME
351 rOOT_MAIN = mkMainModule (fsLit ":Main") -- Root module for initialisation
353 -- The ':xxx' makes a module name that the user can never
354 -- use himself. The z-encoding for ':' is "ZC", so the z-encoded
355 -- module name still starts with a capital letter, which keeps
356 -- the z-encoded version consistent.
357 iNTERACTIVE :: Module
358 iNTERACTIVE = mkMainModule (fsLit ":Interactive")
360 pRELUDE_NAME, mAIN_NAME :: ModuleName
361 pRELUDE_NAME = mkModuleNameFS (fsLit "Prelude")
362 mAIN_NAME = mkModuleNameFS (fsLit "Main")
364 mkPrimModule :: FastString -> Module
365 mkPrimModule m = mkModule primPackageId (mkModuleNameFS m)
367 mkIntegerModule :: FastString -> Module
368 mkIntegerModule m = mkModule integerPackageId (mkModuleNameFS m)
370 mkBaseModule :: FastString -> Module
371 mkBaseModule m = mkModule basePackageId (mkModuleNameFS m)
373 mkBaseModule_ :: ModuleName -> Module
374 mkBaseModule_ m = mkModule basePackageId m
376 mkMainModule :: FastString -> Module
377 mkMainModule m = mkModule mainPackageId (mkModuleNameFS m)
379 mkMainModule_ :: ModuleName -> Module
380 mkMainModule_ m = mkModule mainPackageId m
383 %************************************************************************
385 \subsection{Constructing the names of tuples
387 %************************************************************************
390 mkTupleModule :: Boxity -> Arity -> Module
391 mkTupleModule Boxed 0 = gHC_UNIT
392 mkTupleModule Boxed _ = gHC_TUPLE
393 mkTupleModule Unboxed _ = gHC_PRIM
397 %************************************************************************
401 %************************************************************************
404 main_RDR_Unqual :: RdrName
405 main_RDR_Unqual = mkUnqual varName (fsLit "main")
406 -- We definitely don't want an Orig RdrName, because
407 -- main might, in principle, be imported into module Main
409 forall_tv_RDR, dot_tv_RDR :: RdrName
410 forall_tv_RDR = mkUnqual tvName (fsLit "forall")
411 dot_tv_RDR = mkUnqual tvName (fsLit ".")
413 eq_RDR, ge_RDR, ne_RDR, le_RDR, lt_RDR, gt_RDR, compare_RDR,
414 ltTag_RDR, eqTag_RDR, gtTag_RDR :: RdrName
415 eq_RDR = nameRdrName eqName
416 ge_RDR = nameRdrName geName
417 ne_RDR = varQual_RDR gHC_CLASSES (fsLit "/=")
418 le_RDR = varQual_RDR gHC_CLASSES (fsLit "<=")
419 lt_RDR = varQual_RDR gHC_CLASSES (fsLit "<")
420 gt_RDR = varQual_RDR gHC_CLASSES (fsLit ">")
421 compare_RDR = varQual_RDR gHC_CLASSES (fsLit "compare")
422 ltTag_RDR = dataQual_RDR gHC_ORDERING (fsLit "LT")
423 eqTag_RDR = dataQual_RDR gHC_ORDERING (fsLit "EQ")
424 gtTag_RDR = dataQual_RDR gHC_ORDERING (fsLit "GT")
426 eqClass_RDR, numClass_RDR, ordClass_RDR, enumClass_RDR, monadClass_RDR
428 eqClass_RDR = nameRdrName eqClassName
429 numClass_RDR = nameRdrName numClassName
430 ordClass_RDR = nameRdrName ordClassName
431 enumClass_RDR = nameRdrName enumClassName
432 monadClass_RDR = nameRdrName monadClassName
434 map_RDR, append_RDR :: RdrName
435 map_RDR = varQual_RDR gHC_BASE (fsLit "map")
436 append_RDR = varQual_RDR gHC_BASE (fsLit "++")
438 foldr_RDR, build_RDR, returnM_RDR, bindM_RDR, failM_RDR :: RdrName
439 foldr_RDR = nameRdrName foldrName
440 build_RDR = nameRdrName buildName
441 returnM_RDR = nameRdrName returnMName
442 bindM_RDR = nameRdrName bindMName
443 failM_RDR = nameRdrName failMName
445 left_RDR, right_RDR :: RdrName
446 left_RDR = nameRdrName leftDataConName
447 right_RDR = nameRdrName rightDataConName
449 fromEnum_RDR, toEnum_RDR :: RdrName
450 fromEnum_RDR = varQual_RDR gHC_ENUM (fsLit "fromEnum")
451 toEnum_RDR = varQual_RDR gHC_ENUM (fsLit "toEnum")
453 enumFrom_RDR, enumFromTo_RDR, enumFromThen_RDR, enumFromThenTo_RDR :: RdrName
454 enumFrom_RDR = nameRdrName enumFromName
455 enumFromTo_RDR = nameRdrName enumFromToName
456 enumFromThen_RDR = nameRdrName enumFromThenName
457 enumFromThenTo_RDR = nameRdrName enumFromThenToName
459 ratioDataCon_RDR, plusInteger_RDR, timesInteger_RDR :: RdrName
460 ratioDataCon_RDR = nameRdrName ratioDataConName
461 plusInteger_RDR = nameRdrName plusIntegerName
462 timesInteger_RDR = nameRdrName timesIntegerName
464 ioDataCon_RDR :: RdrName
465 ioDataCon_RDR = nameRdrName ioDataConName
467 eqString_RDR, unpackCString_RDR, unpackCStringFoldr_RDR,
468 unpackCStringUtf8_RDR :: RdrName
469 eqString_RDR = nameRdrName eqStringName
470 unpackCString_RDR = nameRdrName unpackCStringName
471 unpackCStringFoldr_RDR = nameRdrName unpackCStringFoldrName
472 unpackCStringUtf8_RDR = nameRdrName unpackCStringUtf8Name
474 newStablePtr_RDR, wordDataCon_RDR :: RdrName
475 newStablePtr_RDR = nameRdrName newStablePtrName
476 wordDataCon_RDR = dataQual_RDR gHC_WORD (fsLit "W#")
478 bindIO_RDR, returnIO_RDR :: RdrName
479 bindIO_RDR = nameRdrName bindIOName
480 returnIO_RDR = nameRdrName returnIOName
482 fromInteger_RDR, fromRational_RDR, minus_RDR, times_RDR, plus_RDR :: RdrName
483 fromInteger_RDR = nameRdrName fromIntegerName
484 fromRational_RDR = nameRdrName fromRationalName
485 minus_RDR = nameRdrName minusName
486 times_RDR = varQual_RDR gHC_NUM (fsLit "*")
487 plus_RDR = varQual_RDR gHC_NUM (fsLit "+")
489 fromString_RDR :: RdrName
490 fromString_RDR = nameRdrName fromStringName
492 compose_RDR :: RdrName
493 compose_RDR = varQual_RDR gHC_BASE (fsLit ".")
495 not_RDR, getTag_RDR, succ_RDR, pred_RDR, minBound_RDR, maxBound_RDR,
496 and_RDR, range_RDR, inRange_RDR, index_RDR,
497 unsafeIndex_RDR, unsafeRangeSize_RDR :: RdrName
498 and_RDR = varQual_RDR gHC_CLASSES (fsLit "&&")
499 not_RDR = varQual_RDR gHC_CLASSES (fsLit "not")
500 getTag_RDR = varQual_RDR gHC_BASE (fsLit "getTag")
501 succ_RDR = varQual_RDR gHC_ENUM (fsLit "succ")
502 pred_RDR = varQual_RDR gHC_ENUM (fsLit "pred")
503 minBound_RDR = varQual_RDR gHC_ENUM (fsLit "minBound")
504 maxBound_RDR = varQual_RDR gHC_ENUM (fsLit "maxBound")
505 range_RDR = varQual_RDR gHC_ARR (fsLit "range")
506 inRange_RDR = varQual_RDR gHC_ARR (fsLit "inRange")
507 index_RDR = varQual_RDR gHC_ARR (fsLit "index")
508 unsafeIndex_RDR = varQual_RDR gHC_ARR (fsLit "unsafeIndex")
509 unsafeRangeSize_RDR = varQual_RDR gHC_ARR (fsLit "unsafeRangeSize")
511 readList_RDR, readListDefault_RDR, readListPrec_RDR, readListPrecDefault_RDR,
512 readPrec_RDR, parens_RDR, choose_RDR, lexP_RDR :: RdrName
513 readList_RDR = varQual_RDR gHC_READ (fsLit "readList")
514 readListDefault_RDR = varQual_RDR gHC_READ (fsLit "readListDefault")
515 readListPrec_RDR = varQual_RDR gHC_READ (fsLit "readListPrec")
516 readListPrecDefault_RDR = varQual_RDR gHC_READ (fsLit "readListPrecDefault")
517 readPrec_RDR = varQual_RDR gHC_READ (fsLit "readPrec")
518 parens_RDR = varQual_RDR gHC_READ (fsLit "parens")
519 choose_RDR = varQual_RDR gHC_READ (fsLit "choose")
520 lexP_RDR = varQual_RDR gHC_READ (fsLit "lexP")
522 punc_RDR, ident_RDR, symbol_RDR :: RdrName
523 punc_RDR = dataQual_RDR lEX (fsLit "Punc")
524 ident_RDR = dataQual_RDR lEX (fsLit "Ident")
525 symbol_RDR = dataQual_RDR lEX (fsLit "Symbol")
527 step_RDR, alt_RDR, reset_RDR, prec_RDR :: RdrName
528 step_RDR = varQual_RDR rEAD_PREC (fsLit "step")
529 alt_RDR = varQual_RDR rEAD_PREC (fsLit "+++")
530 reset_RDR = varQual_RDR rEAD_PREC (fsLit "reset")
531 prec_RDR = varQual_RDR rEAD_PREC (fsLit "prec")
533 showList_RDR, showList___RDR, showsPrec_RDR, showString_RDR,
534 showSpace_RDR, showParen_RDR :: RdrName
535 showList_RDR = varQual_RDR gHC_SHOW (fsLit "showList")
536 showList___RDR = varQual_RDR gHC_SHOW (fsLit "showList__")
537 showsPrec_RDR = varQual_RDR gHC_SHOW (fsLit "showsPrec")
538 showString_RDR = varQual_RDR gHC_SHOW (fsLit "showString")
539 showSpace_RDR = varQual_RDR gHC_SHOW (fsLit "showSpace")
540 showParen_RDR = varQual_RDR gHC_SHOW (fsLit "showParen")
542 typeOf_RDR, mkTypeRep_RDR, mkTyConRep_RDR :: RdrName
543 typeOf_RDR = varQual_RDR tYPEABLE (fsLit "typeOf")
544 mkTypeRep_RDR = varQual_RDR tYPEABLE (fsLit "mkTyConApp")
545 mkTyConRep_RDR = varQual_RDR tYPEABLE (fsLit "mkTyCon")
547 undefined_RDR :: RdrName
548 undefined_RDR = varQual_RDR gHC_ERR (fsLit "undefined")
551 error_RDR = varQual_RDR gHC_ERR (fsLit "error")
553 -- Old Generics (constructors and functions)
554 crossDataCon_RDR, inlDataCon_RDR, inrDataCon_RDR, genUnitDataCon_RDR :: RdrName
555 crossDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit ":*:")
556 inlDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Inl")
557 inrDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Inr")
558 genUnitDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Unit")
560 -- Generics (constructors and functions)
561 u1DataCon_RDR, par1DataCon_RDR, rec1DataCon_RDR,
562 k1DataCon_RDR, m1DataCon_RDR, l1DataCon_RDR, r1DataCon_RDR,
563 prodDataCon_RDR, comp1DataCon_RDR, from_RDR, from1_RDR,
564 to_RDR, to1_RDR, datatypeName_RDR, moduleName_RDR, conName_RDR,
565 conFixity_RDR, conIsRecord_RDR,
566 noArityDataCon_RDR, arityDataCon_RDR, selName_RDR,
567 prefixDataCon_RDR, infixDataCon_RDR, leftAssocDataCon_RDR,
568 rightAssocDataCon_RDR, notAssocDataCon_RDR :: RdrName
570 u1DataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "U1")
571 par1DataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Par1")
572 rec1DataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Rec1")
573 k1DataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "K1")
574 m1DataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "M1")
576 l1DataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "L1")
577 r1DataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "R1")
579 prodDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit ":*:")
580 comp1DataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Comp1")
582 from_RDR = varQual_RDR gHC_GENERICS (fsLit "from")
583 from1_RDR = varQual_RDR gHC_GENERICS (fsLit "from1")
584 to_RDR = varQual_RDR gHC_GENERICS (fsLit "to")
585 to1_RDR = varQual_RDR gHC_GENERICS (fsLit "to1")
587 datatypeName_RDR = varQual_RDR gHC_GENERICS (fsLit "datatypeName")
588 moduleName_RDR = varQual_RDR gHC_GENERICS (fsLit "moduleName")
589 selName_RDR = varQual_RDR gHC_GENERICS (fsLit "selName")
590 conName_RDR = varQual_RDR gHC_GENERICS (fsLit "conName")
591 conFixity_RDR = varQual_RDR gHC_GENERICS (fsLit "conFixity")
592 conIsRecord_RDR = varQual_RDR gHC_GENERICS (fsLit "conIsRecord")
594 noArityDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "NoArity")
595 arityDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Arity")
596 prefixDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Prefix")
597 infixDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Infix")
598 leftAssocDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "LeftAssociative")
599 rightAssocDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "RightAssociative")
600 notAssocDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "NotAssociative")
603 fmap_RDR, pure_RDR, ap_RDR, foldable_foldr_RDR, traverse_RDR :: RdrName
604 fmap_RDR = varQual_RDR gHC_BASE (fsLit "fmap")
605 pure_RDR = varQual_RDR cONTROL_APPLICATIVE (fsLit "pure")
606 ap_RDR = varQual_RDR cONTROL_APPLICATIVE (fsLit "<*>")
607 foldable_foldr_RDR = varQual_RDR dATA_FOLDABLE (fsLit "foldr")
608 traverse_RDR = varQual_RDR dATA_TRAVERSABLE (fsLit "traverse")
610 ----------------------
611 varQual_RDR, tcQual_RDR, clsQual_RDR, dataQual_RDR
612 :: Module -> FastString -> RdrName
613 varQual_RDR mod str = mkOrig mod (mkOccNameFS varName str)
614 tcQual_RDR mod str = mkOrig mod (mkOccNameFS tcName str)
615 clsQual_RDR mod str = mkOrig mod (mkOccNameFS clsName str)
616 dataQual_RDR mod str = mkOrig mod (mkOccNameFS dataName str)
619 %************************************************************************
621 \subsection{Known-key names}
623 %************************************************************************
625 Many of these Names are not really "built in", but some parts of the
626 compiler (notably the deriving mechanism) need to mention their names,
627 and it's convenient to write them all down in one place.
629 --MetaHaskell Extension add the constrs and the lower case case
630 -- guys as well (perhaps) e.g. see trueDataConName below
635 wildCardName = mkSystemVarName wildCardKey (fsLit "wild")
637 runMainIOName :: Name
638 runMainIOName = varQual gHC_TOP_HANDLER (fsLit "runMainIO") runMainKey
640 orderingTyConName :: Name
641 orderingTyConName = tcQual gHC_ORDERING (fsLit "Ordering") orderingTyConKey
643 eitherTyConName, leftDataConName, rightDataConName :: Name
644 eitherTyConName = tcQual dATA_EITHER (fsLit "Either") eitherTyConKey
645 leftDataConName = conName dATA_EITHER (fsLit "Left") leftDataConKey
646 rightDataConName = conName dATA_EITHER (fsLit "Right") rightDataConKey
649 v1TyConName, u1TyConName, par1TyConName, rec1TyConName,
650 k1TyConName, m1TyConName, sumTyConName, prodTyConName,
651 compTyConName, rTyConName, pTyConName, dTyConName,
652 cTyConName, sTyConName, rec0TyConName, par0TyConName,
653 d1TyConName, c1TyConName, s1TyConName, noSelTyConName,
654 repTyConName, rep1TyConName :: Name
656 v1TyConName = tcQual gHC_GENERICS (fsLit "V1") v1TyConKey
657 u1TyConName = tcQual gHC_GENERICS (fsLit "U1") u1TyConKey
658 par1TyConName = tcQual gHC_GENERICS (fsLit "Par1") par1TyConKey
659 rec1TyConName = tcQual gHC_GENERICS (fsLit "Rec1") rec1TyConKey
660 k1TyConName = tcQual gHC_GENERICS (fsLit "K1") k1TyConKey
661 m1TyConName = tcQual gHC_GENERICS (fsLit "M1") m1TyConKey
663 sumTyConName = tcQual gHC_GENERICS (fsLit ":+:") sumTyConKey
664 prodTyConName = tcQual gHC_GENERICS (fsLit ":*:") prodTyConKey
665 compTyConName = tcQual gHC_GENERICS (fsLit ":.:") compTyConKey
667 rTyConName = tcQual gHC_GENERICS (fsLit "R") rTyConKey
668 pTyConName = tcQual gHC_GENERICS (fsLit "P") pTyConKey
669 dTyConName = tcQual gHC_GENERICS (fsLit "D") dTyConKey
670 cTyConName = tcQual gHC_GENERICS (fsLit "C") cTyConKey
671 sTyConName = tcQual gHC_GENERICS (fsLit "S") sTyConKey
673 rec0TyConName = tcQual gHC_GENERICS (fsLit "Rec0") rec0TyConKey
674 par0TyConName = tcQual gHC_GENERICS (fsLit "Par0") par0TyConKey
675 d1TyConName = tcQual gHC_GENERICS (fsLit "D1") d1TyConKey
676 c1TyConName = tcQual gHC_GENERICS (fsLit "C1") c1TyConKey
677 s1TyConName = tcQual gHC_GENERICS (fsLit "S1") s1TyConKey
678 noSelTyConName = tcQual gHC_GENERICS (fsLit "NoSelector") noSelTyConKey
680 repTyConName = tcQual gHC_GENERICS (fsLit "Rep") repTyConKey
681 rep1TyConName = tcQual gHC_GENERICS (fsLit "Rep1") rep1TyConKey
683 -- Base strings Strings
684 unpackCStringName, unpackCStringAppendName, unpackCStringFoldrName,
685 unpackCStringUtf8Name, eqStringName, stringTyConName :: Name
686 unpackCStringName = varQual gHC_CSTRING (fsLit "unpackCString#") unpackCStringIdKey
687 unpackCStringAppendName = varQual gHC_CSTRING (fsLit "unpackAppendCString#") unpackCStringAppendIdKey
688 unpackCStringFoldrName = varQual gHC_CSTRING (fsLit "unpackFoldrCString#") unpackCStringFoldrIdKey
689 unpackCStringUtf8Name = varQual gHC_CSTRING (fsLit "unpackCStringUtf8#") unpackCStringUtf8IdKey
690 eqStringName = varQual gHC_BASE (fsLit "eqString") eqStringIdKey
691 stringTyConName = tcQual gHC_BASE (fsLit "String") stringTyConKey
693 -- The 'inline' function
695 inlineIdName = varQual gHC_MAGIC (fsLit "inline") inlineIdKey
697 -- Base classes (Eq, Ord, Functor)
698 fmapName, eqClassName, eqName, ordClassName, geName, functorClassName :: Name
699 eqClassName = clsQual gHC_CLASSES (fsLit "Eq") eqClassKey
700 eqName = methName gHC_CLASSES (fsLit "==") eqClassOpKey
701 ordClassName = clsQual gHC_CLASSES (fsLit "Ord") ordClassKey
702 geName = methName gHC_CLASSES (fsLit ">=") geClassOpKey
703 functorClassName = clsQual gHC_BASE (fsLit "Functor") functorClassKey
704 fmapName = methName gHC_BASE (fsLit "fmap") fmapClassOpKey
707 monadClassName, thenMName, bindMName, returnMName, failMName :: Name
708 monadClassName = clsQual gHC_BASE (fsLit "Monad") monadClassKey
709 thenMName = methName gHC_BASE (fsLit ">>") thenMClassOpKey
710 bindMName = methName gHC_BASE (fsLit ">>=") bindMClassOpKey
711 returnMName = methName gHC_BASE (fsLit "return") returnMClassOpKey
712 failMName = methName gHC_BASE (fsLit "fail") failMClassOpKey
714 -- Classes (Applicative, Foldable, Traversable)
715 applicativeClassName, foldableClassName, traversableClassName :: Name
716 applicativeClassName = clsQual cONTROL_APPLICATIVE (fsLit "Applicative") applicativeClassKey
717 foldableClassName = clsQual dATA_FOLDABLE (fsLit "Foldable") foldableClassKey
718 traversableClassName = clsQual dATA_TRAVERSABLE (fsLit "Traversable") traversableClassKey
720 -- Functions for GHC extensions
721 groupWithName :: Name
722 groupWithName = varQual gHC_EXTS (fsLit "groupWith") groupWithIdKey
724 -- Random PrelBase functions
725 fromStringName, otherwiseIdName, foldrName, buildName, augmentName,
726 mapName, appendName, assertName,
727 breakpointName, breakpointCondName, breakpointAutoName,
728 dollarName, opaqueTyConName :: Name
729 fromStringName = methName dATA_STRING (fsLit "fromString") fromStringClassOpKey
730 otherwiseIdName = varQual gHC_BASE (fsLit "otherwise") otherwiseIdKey
731 foldrName = varQual gHC_BASE (fsLit "foldr") foldrIdKey
732 buildName = varQual gHC_BASE (fsLit "build") buildIdKey
733 augmentName = varQual gHC_BASE (fsLit "augment") augmentIdKey
734 mapName = varQual gHC_BASE (fsLit "map") mapIdKey
735 appendName = varQual gHC_BASE (fsLit "++") appendIdKey
736 dollarName = varQual gHC_BASE (fsLit "$") dollarIdKey
737 assertName = varQual gHC_BASE (fsLit "assert") assertIdKey
738 breakpointName = varQual gHC_BASE (fsLit "breakpoint") breakpointIdKey
739 breakpointCondName= varQual gHC_BASE (fsLit "breakpointCond") breakpointCondIdKey
740 breakpointAutoName= varQual gHC_BASE (fsLit "breakpointAuto") breakpointAutoIdKey
741 opaqueTyConName = tcQual gHC_BASE (fsLit "Opaque") opaqueTyConKey
743 breakpointJumpName :: Name
747 (mkOccNameFS varName (fsLit "breakpointJump"))
749 breakpointCondJumpName :: Name
750 breakpointCondJumpName
752 breakpointCondJumpIdKey
753 (mkOccNameFS varName (fsLit "breakpointCondJump"))
755 breakpointAutoJumpName :: Name
756 breakpointAutoJumpName
758 breakpointAutoJumpIdKey
759 (mkOccNameFS varName (fsLit "breakpointAutoJump"))
763 fstName, sndName :: Name
764 fstName = varQual dATA_TUPLE (fsLit "fst") fstIdKey
765 sndName = varQual dATA_TUPLE (fsLit "snd") sndIdKey
768 numClassName, fromIntegerName, minusName, negateName, plusIntegerName,
770 integerTyConName, smallIntegerName :: Name
771 numClassName = clsQual gHC_NUM (fsLit "Num") numClassKey
772 fromIntegerName = methName gHC_NUM (fsLit "fromInteger") fromIntegerClassOpKey
773 minusName = methName gHC_NUM (fsLit "-") minusClassOpKey
774 negateName = methName gHC_NUM (fsLit "negate") negateClassOpKey
775 plusIntegerName = varQual gHC_INTEGER (fsLit "plusInteger") plusIntegerIdKey
776 timesIntegerName = varQual gHC_INTEGER (fsLit "timesInteger") timesIntegerIdKey
777 integerTyConName = tcQual gHC_INTEGER_TYPE (fsLit "Integer") integerTyConKey
778 smallIntegerName = varQual gHC_INTEGER (fsLit "smallInteger") smallIntegerIdKey
780 -- GHC.Real types and classes
781 rationalTyConName, ratioTyConName, ratioDataConName, realClassName,
782 integralClassName, realFracClassName, fractionalClassName,
783 fromRationalName, toIntegerName, toRationalName, fromIntegralName,
784 realToFracName :: Name
785 rationalTyConName = tcQual gHC_REAL (fsLit "Rational") rationalTyConKey
786 ratioTyConName = tcQual gHC_REAL (fsLit "Ratio") ratioTyConKey
787 ratioDataConName = conName gHC_REAL (fsLit ":%") ratioDataConKey
788 realClassName = clsQual gHC_REAL (fsLit "Real") realClassKey
789 integralClassName = clsQual gHC_REAL (fsLit "Integral") integralClassKey
790 realFracClassName = clsQual gHC_REAL (fsLit "RealFrac") realFracClassKey
791 fractionalClassName = clsQual gHC_REAL (fsLit "Fractional") fractionalClassKey
792 fromRationalName = methName gHC_REAL (fsLit "fromRational") fromRationalClassOpKey
793 toIntegerName = methName gHC_REAL (fsLit "toInteger") toIntegerClassOpKey
794 toRationalName = methName gHC_REAL (fsLit "toRational") toRationalClassOpKey
795 fromIntegralName = varQual gHC_REAL (fsLit "fromIntegral") fromIntegralIdKey
796 realToFracName = varQual gHC_REAL (fsLit "realToFrac") realToFracIdKey
799 floatingClassName, realFloatClassName :: Name
800 floatingClassName = clsQual gHC_FLOAT (fsLit "Floating") floatingClassKey
801 realFloatClassName = clsQual gHC_FLOAT (fsLit "RealFloat") realFloatClassKey
805 ixClassName = clsQual gHC_ARR (fsLit "Ix") ixClassKey
808 typeableClassName, typeable1ClassName, typeable2ClassName,
809 typeable3ClassName, typeable4ClassName, typeable5ClassName,
810 typeable6ClassName, typeable7ClassName :: Name
811 typeableClassName = clsQual tYPEABLE (fsLit "Typeable") typeableClassKey
812 typeable1ClassName = clsQual tYPEABLE (fsLit "Typeable1") typeable1ClassKey
813 typeable2ClassName = clsQual tYPEABLE (fsLit "Typeable2") typeable2ClassKey
814 typeable3ClassName = clsQual tYPEABLE (fsLit "Typeable3") typeable3ClassKey
815 typeable4ClassName = clsQual tYPEABLE (fsLit "Typeable4") typeable4ClassKey
816 typeable5ClassName = clsQual tYPEABLE (fsLit "Typeable5") typeable5ClassKey
817 typeable6ClassName = clsQual tYPEABLE (fsLit "Typeable6") typeable6ClassKey
818 typeable7ClassName = clsQual tYPEABLE (fsLit "Typeable7") typeable7ClassKey
820 typeableClassNames :: [Name]
821 typeableClassNames = [ typeableClassName, typeable1ClassName, typeable2ClassName
822 , typeable3ClassName, typeable4ClassName, typeable5ClassName
823 , typeable6ClassName, typeable7ClassName ]
826 dataClassName :: Name
827 dataClassName = clsQual gENERICS (fsLit "Data") dataClassKey
830 assertErrorName :: Name
831 assertErrorName = varQual gHC_IO_Exception (fsLit "assertError") assertErrorIdKey
833 -- Enum module (Enum, Bounded)
834 enumClassName, enumFromName, enumFromToName, enumFromThenName,
835 enumFromThenToName, boundedClassName :: Name
836 enumClassName = clsQual gHC_ENUM (fsLit "Enum") enumClassKey
837 enumFromName = methName gHC_ENUM (fsLit "enumFrom") enumFromClassOpKey
838 enumFromToName = methName gHC_ENUM (fsLit "enumFromTo") enumFromToClassOpKey
839 enumFromThenName = methName gHC_ENUM (fsLit "enumFromThen") enumFromThenClassOpKey
840 enumFromThenToName = methName gHC_ENUM (fsLit "enumFromThenTo") enumFromThenToClassOpKey
841 boundedClassName = clsQual gHC_ENUM (fsLit "Bounded") boundedClassKey
844 concatName, filterName, zipName :: Name
845 concatName = varQual gHC_LIST (fsLit "concat") concatIdKey
846 filterName = varQual gHC_LIST (fsLit "filter") filterIdKey
847 zipName = varQual gHC_LIST (fsLit "zip") zipIdKey
850 showClassName :: Name
851 showClassName = clsQual gHC_SHOW (fsLit "Show") showClassKey
854 readClassName :: Name
855 readClassName = clsQual gHC_READ (fsLit "Read") readClassKey
857 -- Classes Generic and Generic1, Datatype, Constructor and Selector
858 genClassName, gen1ClassName, datatypeClassName, constructorClassName,
859 selectorClassName :: Name
860 genClassName = clsQual gHC_GENERICS (fsLit "Generic") genClassKey
861 gen1ClassName = clsQual gHC_GENERICS (fsLit "Generic1") gen1ClassKey
863 datatypeClassName = clsQual gHC_GENERICS (fsLit "Datatype") datatypeClassKey
864 constructorClassName = clsQual gHC_GENERICS (fsLit "Constructor") constructorClassKey
865 selectorClassName = clsQual gHC_GENERICS (fsLit "Selector") selectorClassKey
867 -- parallel array types and functions
868 enumFromToPName, enumFromThenToPName, nullPName, lengthPName,
869 singletonPName, replicatePName, mapPName, filterPName,
870 zipPName, crossMapPName, indexPName, toPName,
871 emptyPName, appPName :: PackageId -> Name
872 enumFromToPName pkg = varQual (gHC_PARR pkg) (fsLit "enumFromToP") enumFromToPIdKey
873 enumFromThenToPName pkg = varQual (gHC_PARR pkg) (fsLit "enumFromThenToP") enumFromThenToPIdKey
874 nullPName pkg = varQual (gHC_PARR pkg) (fsLit "nullP") nullPIdKey
875 lengthPName pkg = varQual (gHC_PARR pkg) (fsLit "lengthP") lengthPIdKey
876 singletonPName pkg = varQual (gHC_PARR pkg) (fsLit "singletonP") singletonPIdKey
877 replicatePName pkg = varQual (gHC_PARR pkg) (fsLit "replicateP") replicatePIdKey
878 mapPName pkg = varQual (gHC_PARR pkg) (fsLit "mapP") mapPIdKey
879 filterPName pkg = varQual (gHC_PARR pkg) (fsLit "filterP") filterPIdKey
880 zipPName pkg = varQual (gHC_PARR pkg) (fsLit "zipP") zipPIdKey
881 crossMapPName pkg = varQual (gHC_PARR pkg) (fsLit "crossMapP") crossMapPIdKey
882 indexPName pkg = varQual (gHC_PARR pkg) (fsLit "!:") indexPIdKey
883 toPName pkg = varQual (gHC_PARR pkg) (fsLit "toP") toPIdKey
884 emptyPName pkg = varQual (gHC_PARR pkg) (fsLit "emptyP") emptyPIdKey
885 appPName pkg = varQual (gHC_PARR pkg) (fsLit "+:+") appPIdKey
888 ioTyConName, ioDataConName, thenIOName, bindIOName, returnIOName,
890 ioTyConName = tcQual gHC_TYPES (fsLit "IO") ioTyConKey
891 ioDataConName = conName gHC_TYPES (fsLit "IO") ioDataConKey
892 thenIOName = varQual gHC_BASE (fsLit "thenIO") thenIOIdKey
893 bindIOName = varQual gHC_BASE (fsLit "bindIO") bindIOIdKey
894 returnIOName = varQual gHC_BASE (fsLit "returnIO") returnIOIdKey
895 failIOName = varQual gHC_IO (fsLit "failIO") failIOIdKey
899 printName = varQual sYSTEM_IO (fsLit "print") printIdKey
901 -- Int, Word, and Addr things
902 int8TyConName, int16TyConName, int32TyConName, int64TyConName :: Name
903 int8TyConName = tcQual gHC_INT (fsLit "Int8") int8TyConKey
904 int16TyConName = tcQual gHC_INT (fsLit "Int16") int16TyConKey
905 int32TyConName = tcQual gHC_INT (fsLit "Int32") int32TyConKey
906 int64TyConName = tcQual gHC_INT (fsLit "Int64") int64TyConKey
909 word8TyConName, word16TyConName, word32TyConName, word64TyConName,
910 wordTyConName, wordDataConName :: Name
911 word8TyConName = tcQual gHC_WORD (fsLit "Word8") word8TyConKey
912 word16TyConName = tcQual gHC_WORD (fsLit "Word16") word16TyConKey
913 word32TyConName = tcQual gHC_WORD (fsLit "Word32") word32TyConKey
914 word64TyConName = tcQual gHC_WORD (fsLit "Word64") word64TyConKey
915 wordTyConName = tcQual gHC_WORD (fsLit "Word") wordTyConKey
916 wordDataConName = conName gHC_WORD (fsLit "W#") wordDataConKey
919 ptrTyConName, funPtrTyConName :: Name
920 ptrTyConName = tcQual gHC_PTR (fsLit "Ptr") ptrTyConKey
921 funPtrTyConName = tcQual gHC_PTR (fsLit "FunPtr") funPtrTyConKey
923 -- Foreign objects and weak pointers
924 stablePtrTyConName, newStablePtrName :: Name
925 stablePtrTyConName = tcQual gHC_STABLE (fsLit "StablePtr") stablePtrTyConKey
926 newStablePtrName = varQual gHC_STABLE (fsLit "newStablePtr") newStablePtrIdKey
930 runSTRepName = varQual gHC_ST (fsLit "runSTRep") runSTRepIdKey
932 -- Recursive-do notation
933 monadFixClassName, mfixName :: Name
934 monadFixClassName = clsQual mONAD_FIX (fsLit "MonadFix") monadFixClassKey
935 mfixName = methName mONAD_FIX (fsLit "mfix") mfixIdKey
938 arrAName, composeAName, firstAName, appAName, choiceAName, loopAName :: Name
939 arrAName = varQual aRROW (fsLit "arr") arrAIdKey
940 composeAName = varQual gHC_DESUGAR (fsLit ">>>") composeAIdKey
941 firstAName = varQual aRROW (fsLit "first") firstAIdKey
942 appAName = varQual aRROW (fsLit "app") appAIdKey
943 choiceAName = varQual aRROW (fsLit "|||") choiceAIdKey
944 loopAName = varQual aRROW (fsLit "loop") loopAIdKey
946 -- Monad comprehensions
947 guardMName, liftMName, groupMName, mzipName :: Name
948 guardMName = varQual mONAD (fsLit "guard") guardMIdKey
949 liftMName = varQual mONAD (fsLit "liftM") liftMIdKey
950 groupMName = varQual mONAD_GROUP (fsLit "mgroupWith") groupMIdKey
951 mzipName = varQual mONAD_ZIP (fsLit "mzip") mzipIdKey
954 -- Annotation type checking
955 toAnnotationWrapperName :: Name
956 toAnnotationWrapperName = varQual gHC_DESUGAR (fsLit "toAnnotationWrapper") toAnnotationWrapperIdKey
958 -- Other classes, needed for type defaulting
959 monadPlusClassName, randomClassName, randomGenClassName,
960 isStringClassName :: Name
961 monadPlusClassName = clsQual mONAD (fsLit "MonadPlus") monadPlusClassKey
962 randomClassName = clsQual rANDOM (fsLit "Random") randomClassKey
963 randomGenClassName = clsQual rANDOM (fsLit "RandomGen") randomGenClassKey
964 isStringClassName = clsQual dATA_STRING (fsLit "IsString") isStringClassKey
967 objectTyConName :: Name
968 objectTyConName = tcQual dOTNET (fsLit "Object") objectTyConKey
969 -- objectTyConName was "wTcQual", but that's gone now, and
970 -- I can't see why it was wired in anyway...
971 unmarshalObjectName, marshalObjectName, marshalStringName,
972 unmarshalStringName, checkDotnetResName :: Name
973 unmarshalObjectName = varQual dOTNET (fsLit "unmarshalObject") unmarshalObjectIdKey
974 marshalObjectName = varQual dOTNET (fsLit "marshalObject") marshalObjectIdKey
975 marshalStringName = varQual dOTNET (fsLit "marshalString") marshalStringIdKey
976 unmarshalStringName = varQual dOTNET (fsLit "unmarshalString") unmarshalStringIdKey
977 checkDotnetResName = varQual dOTNET (fsLit "checkResult") checkDotnetResNameIdKey
980 %************************************************************************
982 \subsection{Local helpers}
984 %************************************************************************
986 All these are original names; hence mkOrig
989 varQual, tcQual, clsQual :: Module -> FastString -> Unique -> Name
990 varQual = mk_known_key_name varName
991 tcQual = mk_known_key_name tcName
992 clsQual = mk_known_key_name clsName
994 mk_known_key_name :: NameSpace -> Module -> FastString -> Unique -> Name
995 mk_known_key_name space modu str unique
996 = mkExternalName unique modu (mkOccNameFS space str) noSrcSpan
998 conName :: Module -> FastString -> Unique -> Name
999 conName modu occ unique
1000 = mkExternalName unique modu (mkOccNameFS dataName occ) noSrcSpan
1002 methName :: Module -> FastString -> Unique -> Name
1003 methName modu occ unique
1004 = mkExternalName unique modu (mkVarOccFS occ) noSrcSpan
1007 %************************************************************************
1009 \subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@}
1011 %************************************************************************
1012 --MetaHaskell extension hand allocate keys here
1015 boundedClassKey, enumClassKey, eqClassKey, floatingClassKey,
1016 fractionalClassKey, integralClassKey, monadClassKey, dataClassKey,
1017 functorClassKey, numClassKey, ordClassKey, readClassKey, realClassKey,
1018 realFloatClassKey, realFracClassKey, showClassKey, ixClassKey :: Unique
1019 boundedClassKey = mkPreludeClassUnique 1
1020 enumClassKey = mkPreludeClassUnique 2
1021 eqClassKey = mkPreludeClassUnique 3
1022 floatingClassKey = mkPreludeClassUnique 5
1023 fractionalClassKey = mkPreludeClassUnique 6
1024 integralClassKey = mkPreludeClassUnique 7
1025 monadClassKey = mkPreludeClassUnique 8
1026 dataClassKey = mkPreludeClassUnique 9
1027 functorClassKey = mkPreludeClassUnique 10
1028 numClassKey = mkPreludeClassUnique 11
1029 ordClassKey = mkPreludeClassUnique 12
1030 readClassKey = mkPreludeClassUnique 13
1031 realClassKey = mkPreludeClassUnique 14
1032 realFloatClassKey = mkPreludeClassUnique 15
1033 realFracClassKey = mkPreludeClassUnique 16
1034 showClassKey = mkPreludeClassUnique 17
1035 ixClassKey = mkPreludeClassUnique 18
1037 typeableClassKey, typeable1ClassKey, typeable2ClassKey, typeable3ClassKey,
1038 typeable4ClassKey, typeable5ClassKey, typeable6ClassKey, typeable7ClassKey
1040 typeableClassKey = mkPreludeClassUnique 20
1041 typeable1ClassKey = mkPreludeClassUnique 21
1042 typeable2ClassKey = mkPreludeClassUnique 22
1043 typeable3ClassKey = mkPreludeClassUnique 23
1044 typeable4ClassKey = mkPreludeClassUnique 24
1045 typeable5ClassKey = mkPreludeClassUnique 25
1046 typeable6ClassKey = mkPreludeClassUnique 26
1047 typeable7ClassKey = mkPreludeClassUnique 27
1049 monadFixClassKey :: Unique
1050 monadFixClassKey = mkPreludeClassUnique 28
1052 monadPlusClassKey, randomClassKey, randomGenClassKey :: Unique
1053 monadPlusClassKey = mkPreludeClassUnique 30
1054 randomClassKey = mkPreludeClassUnique 31
1055 randomGenClassKey = mkPreludeClassUnique 32
1057 isStringClassKey :: Unique
1058 isStringClassKey = mkPreludeClassUnique 33
1060 applicativeClassKey, foldableClassKey, traversableClassKey :: Unique
1061 applicativeClassKey = mkPreludeClassUnique 34
1062 foldableClassKey = mkPreludeClassUnique 35
1063 traversableClassKey = mkPreludeClassUnique 36
1065 genClassKey, gen1ClassKey, datatypeClassKey, constructorClassKey,
1066 selectorClassKey :: Unique
1067 genClassKey = mkPreludeClassUnique 37
1068 gen1ClassKey = mkPreludeClassUnique 38
1070 datatypeClassKey = mkPreludeClassUnique 39
1071 constructorClassKey = mkPreludeClassUnique 40
1072 selectorClassKey = mkPreludeClassUnique 41
1075 %************************************************************************
1077 \subsubsection[Uniques-prelude-TyCons]{@Uniques@ for wired-in @TyCons@}
1079 %************************************************************************
1082 addrPrimTyConKey, arrayPrimTyConKey, boolTyConKey, byteArrayPrimTyConKey,
1083 charPrimTyConKey, charTyConKey, doublePrimTyConKey, doubleTyConKey,
1084 floatPrimTyConKey, floatTyConKey, funTyConKey, intPrimTyConKey,
1085 intTyConKey, int8TyConKey, int16TyConKey, int32PrimTyConKey,
1086 int32TyConKey, int64PrimTyConKey, int64TyConKey, integerTyConKey,
1087 listTyConKey, foreignObjPrimTyConKey, weakPrimTyConKey,
1088 mutableArrayPrimTyConKey, mutableByteArrayPrimTyConKey,
1089 orderingTyConKey, mVarPrimTyConKey, ratioTyConKey, rationalTyConKey,
1090 realWorldTyConKey, stablePtrPrimTyConKey, stablePtrTyConKey,
1091 anyTyConKey :: Unique
1092 addrPrimTyConKey = mkPreludeTyConUnique 1
1093 arrayPrimTyConKey = mkPreludeTyConUnique 3
1094 boolTyConKey = mkPreludeTyConUnique 4
1095 byteArrayPrimTyConKey = mkPreludeTyConUnique 5
1096 charPrimTyConKey = mkPreludeTyConUnique 7
1097 charTyConKey = mkPreludeTyConUnique 8
1098 doublePrimTyConKey = mkPreludeTyConUnique 9
1099 doubleTyConKey = mkPreludeTyConUnique 10
1100 floatPrimTyConKey = mkPreludeTyConUnique 11
1101 floatTyConKey = mkPreludeTyConUnique 12
1102 funTyConKey = mkPreludeTyConUnique 13
1103 intPrimTyConKey = mkPreludeTyConUnique 14
1104 intTyConKey = mkPreludeTyConUnique 15
1105 int8TyConKey = mkPreludeTyConUnique 16
1106 int16TyConKey = mkPreludeTyConUnique 17
1107 int32PrimTyConKey = mkPreludeTyConUnique 18
1108 int32TyConKey = mkPreludeTyConUnique 19
1109 int64PrimTyConKey = mkPreludeTyConUnique 20
1110 int64TyConKey = mkPreludeTyConUnique 21
1111 integerTyConKey = mkPreludeTyConUnique 22
1112 listTyConKey = mkPreludeTyConUnique 23
1113 foreignObjPrimTyConKey = mkPreludeTyConUnique 24
1114 weakPrimTyConKey = mkPreludeTyConUnique 27
1115 mutableArrayPrimTyConKey = mkPreludeTyConUnique 28
1116 mutableByteArrayPrimTyConKey = mkPreludeTyConUnique 29
1117 orderingTyConKey = mkPreludeTyConUnique 30
1118 mVarPrimTyConKey = mkPreludeTyConUnique 31
1119 ratioTyConKey = mkPreludeTyConUnique 32
1120 rationalTyConKey = mkPreludeTyConUnique 33
1121 realWorldTyConKey = mkPreludeTyConUnique 34
1122 stablePtrPrimTyConKey = mkPreludeTyConUnique 35
1123 stablePtrTyConKey = mkPreludeTyConUnique 36
1124 anyTyConKey = mkPreludeTyConUnique 37
1126 statePrimTyConKey, stableNamePrimTyConKey, stableNameTyConKey,
1127 mutVarPrimTyConKey, ioTyConKey,
1128 wordPrimTyConKey, wordTyConKey, word8TyConKey, word16TyConKey,
1129 word32PrimTyConKey, word32TyConKey, word64PrimTyConKey, word64TyConKey,
1130 liftedConKey, unliftedConKey, anyBoxConKey, kindConKey, boxityConKey,
1131 typeConKey, threadIdPrimTyConKey, bcoPrimTyConKey, ptrTyConKey,
1132 funPtrTyConKey, tVarPrimTyConKey :: Unique
1133 statePrimTyConKey = mkPreludeTyConUnique 50
1134 stableNamePrimTyConKey = mkPreludeTyConUnique 51
1135 stableNameTyConKey = mkPreludeTyConUnique 52
1136 mutVarPrimTyConKey = mkPreludeTyConUnique 55
1137 ioTyConKey = mkPreludeTyConUnique 56
1138 wordPrimTyConKey = mkPreludeTyConUnique 58
1139 wordTyConKey = mkPreludeTyConUnique 59
1140 word8TyConKey = mkPreludeTyConUnique 60
1141 word16TyConKey = mkPreludeTyConUnique 61
1142 word32PrimTyConKey = mkPreludeTyConUnique 62
1143 word32TyConKey = mkPreludeTyConUnique 63
1144 word64PrimTyConKey = mkPreludeTyConUnique 64
1145 word64TyConKey = mkPreludeTyConUnique 65
1146 liftedConKey = mkPreludeTyConUnique 66
1147 unliftedConKey = mkPreludeTyConUnique 67
1148 anyBoxConKey = mkPreludeTyConUnique 68
1149 kindConKey = mkPreludeTyConUnique 69
1150 boxityConKey = mkPreludeTyConUnique 70
1151 typeConKey = mkPreludeTyConUnique 71
1152 threadIdPrimTyConKey = mkPreludeTyConUnique 72
1153 bcoPrimTyConKey = mkPreludeTyConUnique 73
1154 ptrTyConKey = mkPreludeTyConUnique 74
1155 funPtrTyConKey = mkPreludeTyConUnique 75
1156 tVarPrimTyConKey = mkPreludeTyConUnique 76
1158 -- Parallel array type constructor
1159 parrTyConKey :: Unique
1160 parrTyConKey = mkPreludeTyConUnique 82
1163 objectTyConKey :: Unique
1164 objectTyConKey = mkPreludeTyConUnique 83
1166 eitherTyConKey :: Unique
1167 eitherTyConKey = mkPreludeTyConUnique 84
1169 -- Super Kinds constructors
1170 tySuperKindTyConKey, coSuperKindTyConKey :: Unique
1171 tySuperKindTyConKey = mkPreludeTyConUnique 85
1172 coSuperKindTyConKey = mkPreludeTyConUnique 86
1174 -- Kind constructors
1175 liftedTypeKindTyConKey, openTypeKindTyConKey, unliftedTypeKindTyConKey,
1176 ubxTupleKindTyConKey, argTypeKindTyConKey :: Unique
1177 liftedTypeKindTyConKey = mkPreludeTyConUnique 87
1178 openTypeKindTyConKey = mkPreludeTyConUnique 88
1179 unliftedTypeKindTyConKey = mkPreludeTyConUnique 89
1180 ubxTupleKindTyConKey = mkPreludeTyConUnique 90
1181 argTypeKindTyConKey = mkPreludeTyConUnique 91
1183 -- Coercion constructors
1184 symCoercionTyConKey, transCoercionTyConKey, leftCoercionTyConKey,
1185 rightCoercionTyConKey, instCoercionTyConKey, unsafeCoercionTyConKey,
1186 csel1CoercionTyConKey, csel2CoercionTyConKey, cselRCoercionTyConKey
1188 symCoercionTyConKey = mkPreludeTyConUnique 93
1189 transCoercionTyConKey = mkPreludeTyConUnique 94
1190 leftCoercionTyConKey = mkPreludeTyConUnique 95
1191 rightCoercionTyConKey = mkPreludeTyConUnique 96
1192 instCoercionTyConKey = mkPreludeTyConUnique 97
1193 unsafeCoercionTyConKey = mkPreludeTyConUnique 98
1194 csel1CoercionTyConKey = mkPreludeTyConUnique 99
1195 csel2CoercionTyConKey = mkPreludeTyConUnique 100
1196 cselRCoercionTyConKey = mkPreludeTyConUnique 101
1198 unknownTyConKey, unknown1TyConKey, unknown2TyConKey, unknown3TyConKey,
1199 opaqueTyConKey :: Unique
1200 unknownTyConKey = mkPreludeTyConUnique 129
1201 unknown1TyConKey = mkPreludeTyConUnique 130
1202 unknown2TyConKey = mkPreludeTyConUnique 131
1203 unknown3TyConKey = mkPreludeTyConUnique 132
1204 opaqueTyConKey = mkPreludeTyConUnique 133
1206 stringTyConKey :: Unique
1207 stringTyConKey = mkPreludeTyConUnique 134
1209 -- Generics (Unique keys)
1210 v1TyConKey, u1TyConKey, par1TyConKey, rec1TyConKey,
1211 k1TyConKey, m1TyConKey, sumTyConKey, prodTyConKey,
1212 compTyConKey, rTyConKey, pTyConKey, dTyConKey,
1213 cTyConKey, sTyConKey, rec0TyConKey, par0TyConKey,
1214 d1TyConKey, c1TyConKey, s1TyConKey, noSelTyConKey,
1215 repTyConKey, rep1TyConKey :: Unique
1217 v1TyConKey = mkPreludeTyConUnique 135
1218 u1TyConKey = mkPreludeTyConUnique 136
1219 par1TyConKey = mkPreludeTyConUnique 137
1220 rec1TyConKey = mkPreludeTyConUnique 138
1221 k1TyConKey = mkPreludeTyConUnique 139
1222 m1TyConKey = mkPreludeTyConUnique 140
1224 sumTyConKey = mkPreludeTyConUnique 141
1225 prodTyConKey = mkPreludeTyConUnique 142
1226 compTyConKey = mkPreludeTyConUnique 143
1228 rTyConKey = mkPreludeTyConUnique 144
1229 pTyConKey = mkPreludeTyConUnique 145
1230 dTyConKey = mkPreludeTyConUnique 146
1231 cTyConKey = mkPreludeTyConUnique 147
1232 sTyConKey = mkPreludeTyConUnique 148
1234 rec0TyConKey = mkPreludeTyConUnique 149
1235 par0TyConKey = mkPreludeTyConUnique 150
1236 d1TyConKey = mkPreludeTyConUnique 151
1237 c1TyConKey = mkPreludeTyConUnique 152
1238 s1TyConKey = mkPreludeTyConUnique 153
1239 noSelTyConKey = mkPreludeTyConUnique 154
1241 repTyConKey = mkPreludeTyConUnique 155
1242 rep1TyConKey = mkPreludeTyConUnique 156
1244 ---------------- Template Haskell -------------------
1245 -- USES TyConUniques 200-299
1246 -----------------------------------------------------
1248 unitTyConKey :: Unique
1249 unitTyConKey = mkTupleTyConUnique Boxed 0
1252 %************************************************************************
1254 \subsubsection[Uniques-prelude-DataCons]{@Uniques@ for wired-in @DataCons@}
1256 %************************************************************************
1259 charDataConKey, consDataConKey, doubleDataConKey, falseDataConKey,
1260 floatDataConKey, intDataConKey, nilDataConKey, ratioDataConKey,
1261 stableNameDataConKey, trueDataConKey, wordDataConKey,
1262 ioDataConKey, integerDataConKey :: Unique
1263 charDataConKey = mkPreludeDataConUnique 1
1264 consDataConKey = mkPreludeDataConUnique 2
1265 doubleDataConKey = mkPreludeDataConUnique 3
1266 falseDataConKey = mkPreludeDataConUnique 4
1267 floatDataConKey = mkPreludeDataConUnique 5
1268 intDataConKey = mkPreludeDataConUnique 6
1269 nilDataConKey = mkPreludeDataConUnique 11
1270 ratioDataConKey = mkPreludeDataConUnique 12
1271 stableNameDataConKey = mkPreludeDataConUnique 14
1272 trueDataConKey = mkPreludeDataConUnique 15
1273 wordDataConKey = mkPreludeDataConUnique 16
1274 ioDataConKey = mkPreludeDataConUnique 17
1275 integerDataConKey = mkPreludeDataConUnique 18
1277 -- Generic data constructors
1278 crossDataConKey, inlDataConKey, inrDataConKey, genUnitDataConKey :: Unique
1279 crossDataConKey = mkPreludeDataConUnique 20
1280 inlDataConKey = mkPreludeDataConUnique 21
1281 inrDataConKey = mkPreludeDataConUnique 22
1282 genUnitDataConKey = mkPreludeDataConUnique 23
1284 -- Data constructor for parallel arrays
1285 parrDataConKey :: Unique
1286 parrDataConKey = mkPreludeDataConUnique 24
1288 leftDataConKey, rightDataConKey :: Unique
1289 leftDataConKey = mkPreludeDataConUnique 25
1290 rightDataConKey = mkPreludeDataConUnique 26
1293 %************************************************************************
1295 \subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}
1297 %************************************************************************
1300 absentErrorIdKey, augmentIdKey, appendIdKey, buildIdKey, errorIdKey,
1301 foldlIdKey, foldrIdKey, recSelErrorIdKey,
1302 integerMinusOneIdKey, integerPlusOneIdKey,
1303 integerPlusTwoIdKey, integerZeroIdKey,
1304 int2IntegerIdKey, seqIdKey, irrefutPatErrorIdKey, eqStringIdKey,
1305 noMethodBindingErrorIdKey, nonExhaustiveGuardsErrorIdKey,
1306 runtimeErrorIdKey, parErrorIdKey, parIdKey, patErrorIdKey,
1307 realWorldPrimIdKey, recConErrorIdKey, recUpdErrorIdKey,
1308 traceIdKey, wildCardKey,
1309 unpackCStringUtf8IdKey, unpackCStringAppendIdKey,
1310 unpackCStringFoldrIdKey, unpackCStringIdKey :: Unique
1311 wildCardKey = mkPreludeMiscIdUnique 0 -- See Note [WildCard]
1312 absentErrorIdKey = mkPreludeMiscIdUnique 1
1313 augmentIdKey = mkPreludeMiscIdUnique 3
1314 appendIdKey = mkPreludeMiscIdUnique 4
1315 buildIdKey = mkPreludeMiscIdUnique 5
1316 errorIdKey = mkPreludeMiscIdUnique 6
1317 foldlIdKey = mkPreludeMiscIdUnique 7
1318 foldrIdKey = mkPreludeMiscIdUnique 8
1319 recSelErrorIdKey = mkPreludeMiscIdUnique 9
1320 integerMinusOneIdKey = mkPreludeMiscIdUnique 10
1321 integerPlusOneIdKey = mkPreludeMiscIdUnique 11
1322 integerPlusTwoIdKey = mkPreludeMiscIdUnique 12
1323 integerZeroIdKey = mkPreludeMiscIdUnique 13
1324 int2IntegerIdKey = mkPreludeMiscIdUnique 14
1325 seqIdKey = mkPreludeMiscIdUnique 15
1326 irrefutPatErrorIdKey = mkPreludeMiscIdUnique 16
1327 eqStringIdKey = mkPreludeMiscIdUnique 17
1328 noMethodBindingErrorIdKey = mkPreludeMiscIdUnique 18
1329 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 19
1330 runtimeErrorIdKey = mkPreludeMiscIdUnique 20
1331 parErrorIdKey = mkPreludeMiscIdUnique 21
1332 parIdKey = mkPreludeMiscIdUnique 22
1333 patErrorIdKey = mkPreludeMiscIdUnique 23
1334 realWorldPrimIdKey = mkPreludeMiscIdUnique 24
1335 recConErrorIdKey = mkPreludeMiscIdUnique 25
1336 recUpdErrorIdKey = mkPreludeMiscIdUnique 26
1337 traceIdKey = mkPreludeMiscIdUnique 27
1338 unpackCStringUtf8IdKey = mkPreludeMiscIdUnique 28
1339 unpackCStringAppendIdKey = mkPreludeMiscIdUnique 29
1340 unpackCStringFoldrIdKey = mkPreludeMiscIdUnique 30
1341 unpackCStringIdKey = mkPreludeMiscIdUnique 31
1343 unsafeCoerceIdKey, concatIdKey, filterIdKey, zipIdKey, bindIOIdKey,
1344 returnIOIdKey, deRefStablePtrIdKey, newStablePtrIdKey,
1345 smallIntegerIdKey, plusIntegerIdKey, timesIntegerIdKey,
1346 printIdKey, failIOIdKey, nullAddrIdKey, voidArgIdKey,
1347 fstIdKey, sndIdKey, otherwiseIdKey, assertIdKey, runSTRepIdKey :: Unique
1348 unsafeCoerceIdKey = mkPreludeMiscIdUnique 32
1349 concatIdKey = mkPreludeMiscIdUnique 33
1350 filterIdKey = mkPreludeMiscIdUnique 34
1351 zipIdKey = mkPreludeMiscIdUnique 35
1352 bindIOIdKey = mkPreludeMiscIdUnique 36
1353 returnIOIdKey = mkPreludeMiscIdUnique 37
1354 deRefStablePtrIdKey = mkPreludeMiscIdUnique 38
1355 newStablePtrIdKey = mkPreludeMiscIdUnique 39
1356 smallIntegerIdKey = mkPreludeMiscIdUnique 40
1357 plusIntegerIdKey = mkPreludeMiscIdUnique 41
1358 timesIntegerIdKey = mkPreludeMiscIdUnique 42
1359 printIdKey = mkPreludeMiscIdUnique 43
1360 failIOIdKey = mkPreludeMiscIdUnique 44
1361 nullAddrIdKey = mkPreludeMiscIdUnique 46
1362 voidArgIdKey = mkPreludeMiscIdUnique 47
1363 fstIdKey = mkPreludeMiscIdUnique 49
1364 sndIdKey = mkPreludeMiscIdUnique 50
1365 otherwiseIdKey = mkPreludeMiscIdUnique 51
1366 assertIdKey = mkPreludeMiscIdUnique 53
1367 runSTRepIdKey = mkPreludeMiscIdUnique 54
1369 rootMainKey, runMainKey :: Unique
1370 rootMainKey = mkPreludeMiscIdUnique 55
1371 runMainKey = mkPreludeMiscIdUnique 56
1373 thenIOIdKey, lazyIdKey, assertErrorIdKey :: Unique
1374 thenIOIdKey = mkPreludeMiscIdUnique 59
1375 lazyIdKey = mkPreludeMiscIdUnique 60
1376 assertErrorIdKey = mkPreludeMiscIdUnique 61
1378 breakpointIdKey, breakpointCondIdKey, breakpointAutoIdKey,
1379 breakpointJumpIdKey, breakpointCondJumpIdKey,
1380 breakpointAutoJumpIdKey :: Unique
1381 breakpointIdKey = mkPreludeMiscIdUnique 62
1382 breakpointCondIdKey = mkPreludeMiscIdUnique 63
1383 breakpointAutoIdKey = mkPreludeMiscIdUnique 64
1384 breakpointJumpIdKey = mkPreludeMiscIdUnique 65
1385 breakpointCondJumpIdKey = mkPreludeMiscIdUnique 66
1386 breakpointAutoJumpIdKey = mkPreludeMiscIdUnique 67
1388 inlineIdKey :: Unique
1389 inlineIdKey = mkPreludeMiscIdUnique 68
1391 mapIdKey, groupWithIdKey, dollarIdKey :: Unique
1392 mapIdKey = mkPreludeMiscIdUnique 69
1393 groupWithIdKey = mkPreludeMiscIdUnique 70
1394 dollarIdKey = mkPreludeMiscIdUnique 71
1396 -- Parallel array functions
1397 singletonPIdKey, nullPIdKey, lengthPIdKey, replicatePIdKey, mapPIdKey,
1398 filterPIdKey, zipPIdKey, crossMapPIdKey, indexPIdKey, toPIdKey,
1399 enumFromToPIdKey, enumFromThenToPIdKey, emptyPIdKey, appPIdKey :: Unique
1400 singletonPIdKey = mkPreludeMiscIdUnique 79
1401 nullPIdKey = mkPreludeMiscIdUnique 80
1402 lengthPIdKey = mkPreludeMiscIdUnique 81
1403 replicatePIdKey = mkPreludeMiscIdUnique 82
1404 mapPIdKey = mkPreludeMiscIdUnique 83
1405 filterPIdKey = mkPreludeMiscIdUnique 84
1406 zipPIdKey = mkPreludeMiscIdUnique 85
1407 crossMapPIdKey = mkPreludeMiscIdUnique 86
1408 indexPIdKey = mkPreludeMiscIdUnique 87
1409 toPIdKey = mkPreludeMiscIdUnique 88
1410 enumFromToPIdKey = mkPreludeMiscIdUnique 89
1411 enumFromThenToPIdKey = mkPreludeMiscIdUnique 90
1412 emptyPIdKey = mkPreludeMiscIdUnique 91
1413 appPIdKey = mkPreludeMiscIdUnique 92
1416 unmarshalObjectIdKey, marshalObjectIdKey, marshalStringIdKey,
1417 unmarshalStringIdKey, checkDotnetResNameIdKey :: Unique
1418 unmarshalObjectIdKey = mkPreludeMiscIdUnique 94
1419 marshalObjectIdKey = mkPreludeMiscIdUnique 95
1420 marshalStringIdKey = mkPreludeMiscIdUnique 96
1421 unmarshalStringIdKey = mkPreludeMiscIdUnique 97
1422 checkDotnetResNameIdKey = mkPreludeMiscIdUnique 98
1426 Certain class operations from Prelude classes. They get their own
1427 uniques so we can look them up easily when we want to conjure them up
1428 during type checking.
1431 -- Just a place holder for unbound variables produced by the renamer:
1432 unboundKey :: Unique
1433 unboundKey = mkPreludeMiscIdUnique 101
1435 fromIntegerClassOpKey, minusClassOpKey, fromRationalClassOpKey,
1436 enumFromClassOpKey, enumFromThenClassOpKey, enumFromToClassOpKey,
1437 enumFromThenToClassOpKey, eqClassOpKey, geClassOpKey, negateClassOpKey,
1438 failMClassOpKey, bindMClassOpKey, thenMClassOpKey, returnMClassOpKey,
1441 fromIntegerClassOpKey = mkPreludeMiscIdUnique 102
1442 minusClassOpKey = mkPreludeMiscIdUnique 103
1443 fromRationalClassOpKey = mkPreludeMiscIdUnique 104
1444 enumFromClassOpKey = mkPreludeMiscIdUnique 105
1445 enumFromThenClassOpKey = mkPreludeMiscIdUnique 106
1446 enumFromToClassOpKey = mkPreludeMiscIdUnique 107
1447 enumFromThenToClassOpKey = mkPreludeMiscIdUnique 108
1448 eqClassOpKey = mkPreludeMiscIdUnique 109
1449 geClassOpKey = mkPreludeMiscIdUnique 110
1450 negateClassOpKey = mkPreludeMiscIdUnique 111
1451 failMClassOpKey = mkPreludeMiscIdUnique 112
1452 bindMClassOpKey = mkPreludeMiscIdUnique 113 -- (>>=)
1453 thenMClassOpKey = mkPreludeMiscIdUnique 114 -- (>>)
1454 fmapClassOpKey = mkPreludeMiscIdUnique 115
1455 returnMClassOpKey = mkPreludeMiscIdUnique 117
1457 -- Recursive do notation
1459 mfixIdKey = mkPreludeMiscIdUnique 118
1462 arrAIdKey, composeAIdKey, firstAIdKey, appAIdKey, choiceAIdKey,
1463 loopAIdKey :: Unique
1464 arrAIdKey = mkPreludeMiscIdUnique 119
1465 composeAIdKey = mkPreludeMiscIdUnique 120 -- >>>
1466 firstAIdKey = mkPreludeMiscIdUnique 121
1467 appAIdKey = mkPreludeMiscIdUnique 122
1468 choiceAIdKey = mkPreludeMiscIdUnique 123 -- |||
1469 loopAIdKey = mkPreludeMiscIdUnique 124
1471 fromStringClassOpKey :: Unique
1472 fromStringClassOpKey = mkPreludeMiscIdUnique 125
1474 -- Annotation type checking
1475 toAnnotationWrapperIdKey :: Unique
1476 toAnnotationWrapperIdKey = mkPreludeMiscIdUnique 126
1478 -- Conversion functions
1479 fromIntegralIdKey, realToFracIdKey, toIntegerClassOpKey, toRationalClassOpKey :: Unique
1480 fromIntegralIdKey = mkPreludeMiscIdUnique 127
1481 realToFracIdKey = mkPreludeMiscIdUnique 128
1482 toIntegerClassOpKey = mkPreludeMiscIdUnique 129
1483 toRationalClassOpKey = mkPreludeMiscIdUnique 130
1485 -- Monad comprehensions
1486 guardMIdKey, liftMIdKey, groupMIdKey, mzipIdKey :: Unique
1487 guardMIdKey = mkPreludeMiscIdUnique 131
1488 liftMIdKey = mkPreludeMiscIdUnique 132
1489 groupMIdKey = mkPreludeMiscIdUnique 133
1490 mzipIdKey = mkPreludeMiscIdUnique 134
1493 ---------------- Template Haskell -------------------
1494 -- USES IdUniques 200-499
1495 -----------------------------------------------------
1499 %************************************************************************
1501 \subsection{Standard groups of types}
1503 %************************************************************************
1506 numericTyKeys :: [Unique]
1515 kindKeys :: [Unique]
1516 kindKeys = [ liftedTypeKindTyConKey
1517 , openTypeKindTyConKey
1518 , unliftedTypeKindTyConKey
1519 , ubxTupleKindTyConKey
1520 , argTypeKindTyConKey ]
1524 %************************************************************************
1526 \subsection[Class-std-groups]{Standard groups of Prelude classes}
1528 %************************************************************************
1530 NOTE: @Eq@ and @Text@ do need to appear in @standardClasses@
1531 even though every numeric class has these two as a superclass,
1532 because the list of ambiguous dictionaries hasn't been simplified.
1535 numericClassKeys :: [Unique]
1541 ++ fractionalClassKeys
1543 fractionalClassKeys :: [Unique]
1544 fractionalClassKeys =
1545 [ fractionalClassKey
1551 -- the strictness analyser needs to know about numeric types
1552 -- (see SaAbsInt.lhs)
1553 needsDataDeclCtxtClassKeys :: [Unique]
1554 needsDataDeclCtxtClassKeys = -- see comments in TcDeriv
1558 -- The "standard classes" are used in defaulting (Haskell 98 report 4.3.4),
1559 -- and are: "classes defined in the Prelude or a standard library"
1560 standardClassKeys :: [Unique]
1561 standardClassKeys = derivableClassKeys ++ numericClassKeys
1562 ++ [randomClassKey, randomGenClassKey,
1564 monadClassKey, monadPlusClassKey,
1566 applicativeClassKey, foldableClassKey, traversableClassKey
1570 @derivableClassKeys@ is also used in checking \tr{deriving} constructs
1574 derivableClassKeys :: [Unique]
1576 = [ eqClassKey, ordClassKey, enumClassKey, ixClassKey,
1577 boundedClassKey, showClassKey, readClassKey ]