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_CONC, gHC_IO, gHC_IO_Exception,
281 gHC_ST, gHC_ARR, gHC_STABLE, 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_CONC = mkBaseModule (fsLit "GHC.Conc")
311 gHC_IO = mkBaseModule (fsLit "GHC.IO")
312 gHC_IO_Exception = mkBaseModule (fsLit "GHC.IO.Exception")
313 gHC_ST = mkBaseModule (fsLit "GHC.ST")
314 gHC_ARR = mkBaseModule (fsLit "GHC.Arr")
315 gHC_STABLE = mkBaseModule (fsLit "GHC.Stable")
316 gHC_PTR = mkBaseModule (fsLit "GHC.Ptr")
317 gHC_ERR = mkBaseModule (fsLit "GHC.Err")
318 gHC_REAL = mkBaseModule (fsLit "GHC.Real")
319 gHC_FLOAT = mkBaseModule (fsLit "GHC.Float")
320 gHC_TOP_HANDLER = mkBaseModule (fsLit "GHC.TopHandler")
321 sYSTEM_IO = mkBaseModule (fsLit "System.IO")
322 dYNAMIC = mkBaseModule (fsLit "Data.Dynamic")
323 tYPEABLE = mkBaseModule (fsLit "Data.Typeable")
324 gENERICS = mkBaseModule (fsLit "Data.Data")
325 dOTNET = mkBaseModule (fsLit "GHC.Dotnet")
326 rEAD_PREC = mkBaseModule (fsLit "Text.ParserCombinators.ReadPrec")
327 lEX = mkBaseModule (fsLit "Text.Read.Lex")
328 gHC_INT = mkBaseModule (fsLit "GHC.Int")
329 gHC_WORD = mkBaseModule (fsLit "GHC.Word")
330 mONAD = mkBaseModule (fsLit "Control.Monad")
331 mONAD_FIX = mkBaseModule (fsLit "Control.Monad.Fix")
332 mONAD_GROUP = mkBaseModule (fsLit "Control.Monad.Group")
333 mONAD_ZIP = mkBaseModule (fsLit "Control.Monad.Zip")
334 aRROW = mkBaseModule (fsLit "Control.Arrow")
335 cONTROL_APPLICATIVE = mkBaseModule (fsLit "Control.Applicative")
336 gHC_DESUGAR = mkBaseModule (fsLit "GHC.Desugar")
337 rANDOM = mkBaseModule (fsLit "System.Random")
338 gHC_EXTS = mkBaseModule (fsLit "GHC.Exts")
339 cONTROL_EXCEPTION_BASE = mkBaseModule (fsLit "Control.Exception.Base")
341 gHC_PARR :: PackageId -> Module
342 gHC_PARR pkg = mkModule pkg (mkModuleNameFS (fsLit "Data.Array.Parallel"))
345 gHC_PARR' = mkBaseModule (fsLit "GHC.PArr")
347 mAIN, rOOT_MAIN :: Module
348 mAIN = mkMainModule_ mAIN_NAME
349 rOOT_MAIN = mkMainModule (fsLit ":Main") -- Root module for initialisation
351 -- The ':xxx' makes a module name that the user can never
352 -- use himself. The z-encoding for ':' is "ZC", so the z-encoded
353 -- module name still starts with a capital letter, which keeps
354 -- the z-encoded version consistent.
355 iNTERACTIVE :: Module
356 iNTERACTIVE = mkMainModule (fsLit ":Interactive")
358 pRELUDE_NAME, mAIN_NAME :: ModuleName
359 pRELUDE_NAME = mkModuleNameFS (fsLit "Prelude")
360 mAIN_NAME = mkModuleNameFS (fsLit "Main")
362 mkPrimModule :: FastString -> Module
363 mkPrimModule m = mkModule primPackageId (mkModuleNameFS m)
365 mkIntegerModule :: FastString -> Module
366 mkIntegerModule m = mkModule integerPackageId (mkModuleNameFS m)
368 mkBaseModule :: FastString -> Module
369 mkBaseModule m = mkModule basePackageId (mkModuleNameFS m)
371 mkBaseModule_ :: ModuleName -> Module
372 mkBaseModule_ m = mkModule basePackageId m
374 mkMainModule :: FastString -> Module
375 mkMainModule m = mkModule mainPackageId (mkModuleNameFS m)
377 mkMainModule_ :: ModuleName -> Module
378 mkMainModule_ m = mkModule mainPackageId m
381 %************************************************************************
383 \subsection{Constructing the names of tuples
385 %************************************************************************
388 mkTupleModule :: Boxity -> Arity -> Module
389 mkTupleModule Boxed 0 = gHC_UNIT
390 mkTupleModule Boxed _ = gHC_TUPLE
391 mkTupleModule Unboxed _ = gHC_PRIM
395 %************************************************************************
399 %************************************************************************
402 main_RDR_Unqual :: RdrName
403 main_RDR_Unqual = mkUnqual varName (fsLit "main")
404 -- We definitely don't want an Orig RdrName, because
405 -- main might, in principle, be imported into module Main
407 forall_tv_RDR, dot_tv_RDR :: RdrName
408 forall_tv_RDR = mkUnqual tvName (fsLit "forall")
409 dot_tv_RDR = mkUnqual tvName (fsLit ".")
411 eq_RDR, ge_RDR, ne_RDR, le_RDR, lt_RDR, gt_RDR, compare_RDR,
412 ltTag_RDR, eqTag_RDR, gtTag_RDR :: RdrName
413 eq_RDR = nameRdrName eqName
414 ge_RDR = nameRdrName geName
415 ne_RDR = varQual_RDR gHC_CLASSES (fsLit "/=")
416 le_RDR = varQual_RDR gHC_CLASSES (fsLit "<=")
417 lt_RDR = varQual_RDR gHC_CLASSES (fsLit "<")
418 gt_RDR = varQual_RDR gHC_CLASSES (fsLit ">")
419 compare_RDR = varQual_RDR gHC_CLASSES (fsLit "compare")
420 ltTag_RDR = dataQual_RDR gHC_ORDERING (fsLit "LT")
421 eqTag_RDR = dataQual_RDR gHC_ORDERING (fsLit "EQ")
422 gtTag_RDR = dataQual_RDR gHC_ORDERING (fsLit "GT")
424 eqClass_RDR, numClass_RDR, ordClass_RDR, enumClass_RDR, monadClass_RDR
426 eqClass_RDR = nameRdrName eqClassName
427 numClass_RDR = nameRdrName numClassName
428 ordClass_RDR = nameRdrName ordClassName
429 enumClass_RDR = nameRdrName enumClassName
430 monadClass_RDR = nameRdrName monadClassName
432 map_RDR, append_RDR :: RdrName
433 map_RDR = varQual_RDR gHC_BASE (fsLit "map")
434 append_RDR = varQual_RDR gHC_BASE (fsLit "++")
436 foldr_RDR, build_RDR, returnM_RDR, bindM_RDR, failM_RDR :: RdrName
437 foldr_RDR = nameRdrName foldrName
438 build_RDR = nameRdrName buildName
439 returnM_RDR = nameRdrName returnMName
440 bindM_RDR = nameRdrName bindMName
441 failM_RDR = nameRdrName failMName
443 left_RDR, right_RDR :: RdrName
444 left_RDR = nameRdrName leftDataConName
445 right_RDR = nameRdrName rightDataConName
447 fromEnum_RDR, toEnum_RDR :: RdrName
448 fromEnum_RDR = varQual_RDR gHC_ENUM (fsLit "fromEnum")
449 toEnum_RDR = varQual_RDR gHC_ENUM (fsLit "toEnum")
451 enumFrom_RDR, enumFromTo_RDR, enumFromThen_RDR, enumFromThenTo_RDR :: RdrName
452 enumFrom_RDR = nameRdrName enumFromName
453 enumFromTo_RDR = nameRdrName enumFromToName
454 enumFromThen_RDR = nameRdrName enumFromThenName
455 enumFromThenTo_RDR = nameRdrName enumFromThenToName
457 ratioDataCon_RDR, plusInteger_RDR, timesInteger_RDR :: RdrName
458 ratioDataCon_RDR = nameRdrName ratioDataConName
459 plusInteger_RDR = nameRdrName plusIntegerName
460 timesInteger_RDR = nameRdrName timesIntegerName
462 ioDataCon_RDR :: RdrName
463 ioDataCon_RDR = nameRdrName ioDataConName
465 eqString_RDR, unpackCString_RDR, unpackCStringFoldr_RDR,
466 unpackCStringUtf8_RDR :: RdrName
467 eqString_RDR = nameRdrName eqStringName
468 unpackCString_RDR = nameRdrName unpackCStringName
469 unpackCStringFoldr_RDR = nameRdrName unpackCStringFoldrName
470 unpackCStringUtf8_RDR = nameRdrName unpackCStringUtf8Name
472 newStablePtr_RDR, wordDataCon_RDR :: RdrName
473 newStablePtr_RDR = nameRdrName newStablePtrName
474 wordDataCon_RDR = dataQual_RDR gHC_WORD (fsLit "W#")
476 bindIO_RDR, returnIO_RDR :: RdrName
477 bindIO_RDR = nameRdrName bindIOName
478 returnIO_RDR = nameRdrName returnIOName
480 fromInteger_RDR, fromRational_RDR, minus_RDR, times_RDR, plus_RDR :: RdrName
481 fromInteger_RDR = nameRdrName fromIntegerName
482 fromRational_RDR = nameRdrName fromRationalName
483 minus_RDR = nameRdrName minusName
484 times_RDR = varQual_RDR gHC_NUM (fsLit "*")
485 plus_RDR = varQual_RDR gHC_NUM (fsLit "+")
487 fromString_RDR :: RdrName
488 fromString_RDR = nameRdrName fromStringName
490 compose_RDR :: RdrName
491 compose_RDR = varQual_RDR gHC_BASE (fsLit ".")
493 not_RDR, getTag_RDR, succ_RDR, pred_RDR, minBound_RDR, maxBound_RDR,
494 and_RDR, range_RDR, inRange_RDR, index_RDR,
495 unsafeIndex_RDR, unsafeRangeSize_RDR :: RdrName
496 and_RDR = varQual_RDR gHC_CLASSES (fsLit "&&")
497 not_RDR = varQual_RDR gHC_CLASSES (fsLit "not")
498 getTag_RDR = varQual_RDR gHC_BASE (fsLit "getTag")
499 succ_RDR = varQual_RDR gHC_ENUM (fsLit "succ")
500 pred_RDR = varQual_RDR gHC_ENUM (fsLit "pred")
501 minBound_RDR = varQual_RDR gHC_ENUM (fsLit "minBound")
502 maxBound_RDR = varQual_RDR gHC_ENUM (fsLit "maxBound")
503 range_RDR = varQual_RDR gHC_ARR (fsLit "range")
504 inRange_RDR = varQual_RDR gHC_ARR (fsLit "inRange")
505 index_RDR = varQual_RDR gHC_ARR (fsLit "index")
506 unsafeIndex_RDR = varQual_RDR gHC_ARR (fsLit "unsafeIndex")
507 unsafeRangeSize_RDR = varQual_RDR gHC_ARR (fsLit "unsafeRangeSize")
509 readList_RDR, readListDefault_RDR, readListPrec_RDR, readListPrecDefault_RDR,
510 readPrec_RDR, parens_RDR, choose_RDR, lexP_RDR :: RdrName
511 readList_RDR = varQual_RDR gHC_READ (fsLit "readList")
512 readListDefault_RDR = varQual_RDR gHC_READ (fsLit "readListDefault")
513 readListPrec_RDR = varQual_RDR gHC_READ (fsLit "readListPrec")
514 readListPrecDefault_RDR = varQual_RDR gHC_READ (fsLit "readListPrecDefault")
515 readPrec_RDR = varQual_RDR gHC_READ (fsLit "readPrec")
516 parens_RDR = varQual_RDR gHC_READ (fsLit "parens")
517 choose_RDR = varQual_RDR gHC_READ (fsLit "choose")
518 lexP_RDR = varQual_RDR gHC_READ (fsLit "lexP")
520 punc_RDR, ident_RDR, symbol_RDR :: RdrName
521 punc_RDR = dataQual_RDR lEX (fsLit "Punc")
522 ident_RDR = dataQual_RDR lEX (fsLit "Ident")
523 symbol_RDR = dataQual_RDR lEX (fsLit "Symbol")
525 step_RDR, alt_RDR, reset_RDR, prec_RDR :: RdrName
526 step_RDR = varQual_RDR rEAD_PREC (fsLit "step")
527 alt_RDR = varQual_RDR rEAD_PREC (fsLit "+++")
528 reset_RDR = varQual_RDR rEAD_PREC (fsLit "reset")
529 prec_RDR = varQual_RDR rEAD_PREC (fsLit "prec")
531 showList_RDR, showList___RDR, showsPrec_RDR, showString_RDR,
532 showSpace_RDR, showParen_RDR :: RdrName
533 showList_RDR = varQual_RDR gHC_SHOW (fsLit "showList")
534 showList___RDR = varQual_RDR gHC_SHOW (fsLit "showList__")
535 showsPrec_RDR = varQual_RDR gHC_SHOW (fsLit "showsPrec")
536 showString_RDR = varQual_RDR gHC_SHOW (fsLit "showString")
537 showSpace_RDR = varQual_RDR gHC_SHOW (fsLit "showSpace")
538 showParen_RDR = varQual_RDR gHC_SHOW (fsLit "showParen")
540 typeOf_RDR, mkTypeRep_RDR, mkTyConRep_RDR :: RdrName
541 typeOf_RDR = varQual_RDR tYPEABLE (fsLit "typeOf")
542 mkTypeRep_RDR = varQual_RDR tYPEABLE (fsLit "mkTyConApp")
543 mkTyConRep_RDR = varQual_RDR tYPEABLE (fsLit "mkTyCon")
545 undefined_RDR :: RdrName
546 undefined_RDR = varQual_RDR gHC_ERR (fsLit "undefined")
549 error_RDR = varQual_RDR gHC_ERR (fsLit "error")
551 -- Old Generics (constructors and functions)
552 crossDataCon_RDR, inlDataCon_RDR, inrDataCon_RDR, genUnitDataCon_RDR :: RdrName
553 crossDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit ":*:")
554 inlDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Inl")
555 inrDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Inr")
556 genUnitDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Unit")
558 -- Generics (constructors and functions)
559 u1DataCon_RDR, par1DataCon_RDR, rec1DataCon_RDR,
560 k1DataCon_RDR, m1DataCon_RDR, l1DataCon_RDR, r1DataCon_RDR,
561 prodDataCon_RDR, comp1DataCon_RDR, from_RDR, from1_RDR,
562 to_RDR, to1_RDR, datatypeName_RDR, moduleName_RDR, conName_RDR,
563 conFixity_RDR, conIsRecord_RDR,
564 noArityDataCon_RDR, arityDataCon_RDR, selName_RDR,
565 prefixDataCon_RDR, infixDataCon_RDR, leftAssocDataCon_RDR,
566 rightAssocDataCon_RDR, notAssocDataCon_RDR :: RdrName
568 u1DataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "U1")
569 par1DataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Par1")
570 rec1DataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Rec1")
571 k1DataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "K1")
572 m1DataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "M1")
574 l1DataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "L1")
575 r1DataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "R1")
577 prodDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit ":*:")
578 comp1DataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Comp1")
580 from_RDR = varQual_RDR gHC_GENERICS (fsLit "from")
581 from1_RDR = varQual_RDR gHC_GENERICS (fsLit "from1")
582 to_RDR = varQual_RDR gHC_GENERICS (fsLit "to")
583 to1_RDR = varQual_RDR gHC_GENERICS (fsLit "to1")
585 datatypeName_RDR = varQual_RDR gHC_GENERICS (fsLit "datatypeName")
586 moduleName_RDR = varQual_RDR gHC_GENERICS (fsLit "moduleName")
587 selName_RDR = varQual_RDR gHC_GENERICS (fsLit "selName")
588 conName_RDR = varQual_RDR gHC_GENERICS (fsLit "conName")
589 conFixity_RDR = varQual_RDR gHC_GENERICS (fsLit "conFixity")
590 conIsRecord_RDR = varQual_RDR gHC_GENERICS (fsLit "conIsRecord")
592 noArityDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "NoArity")
593 arityDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Arity")
594 prefixDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Prefix")
595 infixDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Infix")
596 leftAssocDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "LeftAssociative")
597 rightAssocDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "RightAssociative")
598 notAssocDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "NotAssociative")
601 fmap_RDR, pure_RDR, ap_RDR, foldable_foldr_RDR, traverse_RDR :: RdrName
602 fmap_RDR = varQual_RDR gHC_BASE (fsLit "fmap")
603 pure_RDR = varQual_RDR cONTROL_APPLICATIVE (fsLit "pure")
604 ap_RDR = varQual_RDR cONTROL_APPLICATIVE (fsLit "<*>")
605 foldable_foldr_RDR = varQual_RDR dATA_FOLDABLE (fsLit "foldr")
606 traverse_RDR = varQual_RDR dATA_TRAVERSABLE (fsLit "traverse")
608 ----------------------
609 varQual_RDR, tcQual_RDR, clsQual_RDR, dataQual_RDR
610 :: Module -> FastString -> RdrName
611 varQual_RDR mod str = mkOrig mod (mkOccNameFS varName str)
612 tcQual_RDR mod str = mkOrig mod (mkOccNameFS tcName str)
613 clsQual_RDR mod str = mkOrig mod (mkOccNameFS clsName str)
614 dataQual_RDR mod str = mkOrig mod (mkOccNameFS dataName str)
617 %************************************************************************
619 \subsection{Known-key names}
621 %************************************************************************
623 Many of these Names are not really "built in", but some parts of the
624 compiler (notably the deriving mechanism) need to mention their names,
625 and it's convenient to write them all down in one place.
627 --MetaHaskell Extension add the constrs and the lower case case
628 -- guys as well (perhaps) e.g. see trueDataConName below
633 wildCardName = mkSystemVarName wildCardKey (fsLit "wild")
635 runMainIOName :: Name
636 runMainIOName = varQual gHC_TOP_HANDLER (fsLit "runMainIO") runMainKey
638 orderingTyConName :: Name
639 orderingTyConName = tcQual gHC_ORDERING (fsLit "Ordering") orderingTyConKey
641 eitherTyConName, leftDataConName, rightDataConName :: Name
642 eitherTyConName = tcQual dATA_EITHER (fsLit "Either") eitherTyConKey
643 leftDataConName = conName dATA_EITHER (fsLit "Left") leftDataConKey
644 rightDataConName = conName dATA_EITHER (fsLit "Right") rightDataConKey
647 v1TyConName, u1TyConName, par1TyConName, rec1TyConName,
648 k1TyConName, m1TyConName, sumTyConName, prodTyConName,
649 compTyConName, rTyConName, pTyConName, dTyConName,
650 cTyConName, sTyConName, rec0TyConName, par0TyConName,
651 d1TyConName, c1TyConName, s1TyConName, noSelTyConName,
652 repTyConName, rep1TyConName :: Name
654 v1TyConName = tcQual gHC_GENERICS (fsLit "V1") v1TyConKey
655 u1TyConName = tcQual gHC_GENERICS (fsLit "U1") u1TyConKey
656 par1TyConName = tcQual gHC_GENERICS (fsLit "Par1") par1TyConKey
657 rec1TyConName = tcQual gHC_GENERICS (fsLit "Rec1") rec1TyConKey
658 k1TyConName = tcQual gHC_GENERICS (fsLit "K1") k1TyConKey
659 m1TyConName = tcQual gHC_GENERICS (fsLit "M1") m1TyConKey
661 sumTyConName = tcQual gHC_GENERICS (fsLit ":+:") sumTyConKey
662 prodTyConName = tcQual gHC_GENERICS (fsLit ":*:") prodTyConKey
663 compTyConName = tcQual gHC_GENERICS (fsLit ":.:") compTyConKey
665 rTyConName = tcQual gHC_GENERICS (fsLit "R") rTyConKey
666 pTyConName = tcQual gHC_GENERICS (fsLit "P") pTyConKey
667 dTyConName = tcQual gHC_GENERICS (fsLit "D") dTyConKey
668 cTyConName = tcQual gHC_GENERICS (fsLit "C") cTyConKey
669 sTyConName = tcQual gHC_GENERICS (fsLit "S") sTyConKey
671 rec0TyConName = tcQual gHC_GENERICS (fsLit "Rec0") rec0TyConKey
672 par0TyConName = tcQual gHC_GENERICS (fsLit "Par0") par0TyConKey
673 d1TyConName = tcQual gHC_GENERICS (fsLit "D1") d1TyConKey
674 c1TyConName = tcQual gHC_GENERICS (fsLit "C1") c1TyConKey
675 s1TyConName = tcQual gHC_GENERICS (fsLit "S1") s1TyConKey
676 noSelTyConName = tcQual gHC_GENERICS (fsLit "NoSelector") noSelTyConKey
678 repTyConName = tcQual gHC_GENERICS (fsLit "Rep") repTyConKey
679 rep1TyConName = tcQual gHC_GENERICS (fsLit "Rep1") rep1TyConKey
681 -- Base strings Strings
682 unpackCStringName, unpackCStringAppendName, unpackCStringFoldrName,
683 unpackCStringUtf8Name, eqStringName, stringTyConName :: Name
684 unpackCStringName = varQual gHC_CSTRING (fsLit "unpackCString#") unpackCStringIdKey
685 unpackCStringAppendName = varQual gHC_CSTRING (fsLit "unpackAppendCString#") unpackCStringAppendIdKey
686 unpackCStringFoldrName = varQual gHC_CSTRING (fsLit "unpackFoldrCString#") unpackCStringFoldrIdKey
687 unpackCStringUtf8Name = varQual gHC_CSTRING (fsLit "unpackCStringUtf8#") unpackCStringUtf8IdKey
688 eqStringName = varQual gHC_BASE (fsLit "eqString") eqStringIdKey
689 stringTyConName = tcQual gHC_BASE (fsLit "String") stringTyConKey
691 -- The 'inline' function
693 inlineIdName = varQual gHC_MAGIC (fsLit "inline") inlineIdKey
695 -- Base classes (Eq, Ord, Functor)
696 fmapName, eqClassName, eqName, ordClassName, geName, functorClassName :: Name
697 eqClassName = clsQual gHC_CLASSES (fsLit "Eq") eqClassKey
698 eqName = methName gHC_CLASSES (fsLit "==") eqClassOpKey
699 ordClassName = clsQual gHC_CLASSES (fsLit "Ord") ordClassKey
700 geName = methName gHC_CLASSES (fsLit ">=") geClassOpKey
701 functorClassName = clsQual gHC_BASE (fsLit "Functor") functorClassKey
702 fmapName = methName gHC_BASE (fsLit "fmap") fmapClassOpKey
705 monadClassName, thenMName, bindMName, returnMName, failMName :: Name
706 monadClassName = clsQual gHC_BASE (fsLit "Monad") monadClassKey
707 thenMName = methName gHC_BASE (fsLit ">>") thenMClassOpKey
708 bindMName = methName gHC_BASE (fsLit ">>=") bindMClassOpKey
709 returnMName = methName gHC_BASE (fsLit "return") returnMClassOpKey
710 failMName = methName gHC_BASE (fsLit "fail") failMClassOpKey
712 -- Classes (Applicative, Foldable, Traversable)
713 applicativeClassName, foldableClassName, traversableClassName :: Name
714 applicativeClassName = clsQual cONTROL_APPLICATIVE (fsLit "Applicative") applicativeClassKey
715 foldableClassName = clsQual dATA_FOLDABLE (fsLit "Foldable") foldableClassKey
716 traversableClassName = clsQual dATA_TRAVERSABLE (fsLit "Traversable") traversableClassKey
718 -- Functions for GHC extensions
719 groupWithName :: Name
720 groupWithName = varQual gHC_EXTS (fsLit "groupWith") groupWithIdKey
722 -- Random PrelBase functions
723 fromStringName, otherwiseIdName, foldrName, buildName, augmentName,
724 mapName, appendName, assertName,
725 breakpointName, breakpointCondName, breakpointAutoName,
726 dollarName, opaqueTyConName :: Name
727 fromStringName = methName dATA_STRING (fsLit "fromString") fromStringClassOpKey
728 otherwiseIdName = varQual gHC_BASE (fsLit "otherwise") otherwiseIdKey
729 foldrName = varQual gHC_BASE (fsLit "foldr") foldrIdKey
730 buildName = varQual gHC_BASE (fsLit "build") buildIdKey
731 augmentName = varQual gHC_BASE (fsLit "augment") augmentIdKey
732 mapName = varQual gHC_BASE (fsLit "map") mapIdKey
733 appendName = varQual gHC_BASE (fsLit "++") appendIdKey
734 dollarName = varQual gHC_BASE (fsLit "$") dollarIdKey
735 assertName = varQual gHC_BASE (fsLit "assert") assertIdKey
736 breakpointName = varQual gHC_BASE (fsLit "breakpoint") breakpointIdKey
737 breakpointCondName= varQual gHC_BASE (fsLit "breakpointCond") breakpointCondIdKey
738 breakpointAutoName= varQual gHC_BASE (fsLit "breakpointAuto") breakpointAutoIdKey
739 opaqueTyConName = tcQual gHC_BASE (fsLit "Opaque") opaqueTyConKey
741 breakpointJumpName :: Name
745 (mkOccNameFS varName (fsLit "breakpointJump"))
747 breakpointCondJumpName :: Name
748 breakpointCondJumpName
750 breakpointCondJumpIdKey
751 (mkOccNameFS varName (fsLit "breakpointCondJump"))
753 breakpointAutoJumpName :: Name
754 breakpointAutoJumpName
756 breakpointAutoJumpIdKey
757 (mkOccNameFS varName (fsLit "breakpointAutoJump"))
761 fstName, sndName :: Name
762 fstName = varQual dATA_TUPLE (fsLit "fst") fstIdKey
763 sndName = varQual dATA_TUPLE (fsLit "snd") sndIdKey
766 numClassName, fromIntegerName, minusName, negateName, plusIntegerName,
768 integerTyConName, smallIntegerName :: Name
769 numClassName = clsQual gHC_NUM (fsLit "Num") numClassKey
770 fromIntegerName = methName gHC_NUM (fsLit "fromInteger") fromIntegerClassOpKey
771 minusName = methName gHC_NUM (fsLit "-") minusClassOpKey
772 negateName = methName gHC_NUM (fsLit "negate") negateClassOpKey
773 plusIntegerName = varQual gHC_INTEGER (fsLit "plusInteger") plusIntegerIdKey
774 timesIntegerName = varQual gHC_INTEGER (fsLit "timesInteger") timesIntegerIdKey
775 integerTyConName = tcQual gHC_INTEGER_TYPE (fsLit "Integer") integerTyConKey
776 smallIntegerName = varQual gHC_INTEGER (fsLit "smallInteger") smallIntegerIdKey
778 -- GHC.Real types and classes
779 rationalTyConName, ratioTyConName, ratioDataConName, realClassName,
780 integralClassName, realFracClassName, fractionalClassName,
781 fromRationalName, toIntegerName, toRationalName, fromIntegralName,
782 realToFracName :: Name
783 rationalTyConName = tcQual gHC_REAL (fsLit "Rational") rationalTyConKey
784 ratioTyConName = tcQual gHC_REAL (fsLit "Ratio") ratioTyConKey
785 ratioDataConName = conName gHC_REAL (fsLit ":%") ratioDataConKey
786 realClassName = clsQual gHC_REAL (fsLit "Real") realClassKey
787 integralClassName = clsQual gHC_REAL (fsLit "Integral") integralClassKey
788 realFracClassName = clsQual gHC_REAL (fsLit "RealFrac") realFracClassKey
789 fractionalClassName = clsQual gHC_REAL (fsLit "Fractional") fractionalClassKey
790 fromRationalName = methName gHC_REAL (fsLit "fromRational") fromRationalClassOpKey
791 toIntegerName = methName gHC_REAL (fsLit "toInteger") toIntegerClassOpKey
792 toRationalName = methName gHC_REAL (fsLit "toRational") toRationalClassOpKey
793 fromIntegralName = varQual gHC_REAL (fsLit "fromIntegral") fromIntegralIdKey
794 realToFracName = varQual gHC_REAL (fsLit "realToFrac") realToFracIdKey
797 floatingClassName, realFloatClassName :: Name
798 floatingClassName = clsQual gHC_FLOAT (fsLit "Floating") floatingClassKey
799 realFloatClassName = clsQual gHC_FLOAT (fsLit "RealFloat") realFloatClassKey
803 ixClassName = clsQual gHC_ARR (fsLit "Ix") ixClassKey
806 typeableClassName, typeable1ClassName, typeable2ClassName,
807 typeable3ClassName, typeable4ClassName, typeable5ClassName,
808 typeable6ClassName, typeable7ClassName :: Name
809 typeableClassName = clsQual tYPEABLE (fsLit "Typeable") typeableClassKey
810 typeable1ClassName = clsQual tYPEABLE (fsLit "Typeable1") typeable1ClassKey
811 typeable2ClassName = clsQual tYPEABLE (fsLit "Typeable2") typeable2ClassKey
812 typeable3ClassName = clsQual tYPEABLE (fsLit "Typeable3") typeable3ClassKey
813 typeable4ClassName = clsQual tYPEABLE (fsLit "Typeable4") typeable4ClassKey
814 typeable5ClassName = clsQual tYPEABLE (fsLit "Typeable5") typeable5ClassKey
815 typeable6ClassName = clsQual tYPEABLE (fsLit "Typeable6") typeable6ClassKey
816 typeable7ClassName = clsQual tYPEABLE (fsLit "Typeable7") typeable7ClassKey
818 typeableClassNames :: [Name]
819 typeableClassNames = [ typeableClassName, typeable1ClassName, typeable2ClassName
820 , typeable3ClassName, typeable4ClassName, typeable5ClassName
821 , typeable6ClassName, typeable7ClassName ]
824 dataClassName :: Name
825 dataClassName = clsQual gENERICS (fsLit "Data") dataClassKey
828 assertErrorName :: Name
829 assertErrorName = varQual gHC_IO_Exception (fsLit "assertError") assertErrorIdKey
831 -- Enum module (Enum, Bounded)
832 enumClassName, enumFromName, enumFromToName, enumFromThenName,
833 enumFromThenToName, boundedClassName :: Name
834 enumClassName = clsQual gHC_ENUM (fsLit "Enum") enumClassKey
835 enumFromName = methName gHC_ENUM (fsLit "enumFrom") enumFromClassOpKey
836 enumFromToName = methName gHC_ENUM (fsLit "enumFromTo") enumFromToClassOpKey
837 enumFromThenName = methName gHC_ENUM (fsLit "enumFromThen") enumFromThenClassOpKey
838 enumFromThenToName = methName gHC_ENUM (fsLit "enumFromThenTo") enumFromThenToClassOpKey
839 boundedClassName = clsQual gHC_ENUM (fsLit "Bounded") boundedClassKey
842 concatName, filterName, zipName :: Name
843 concatName = varQual gHC_LIST (fsLit "concat") concatIdKey
844 filterName = varQual gHC_LIST (fsLit "filter") filterIdKey
845 zipName = varQual gHC_LIST (fsLit "zip") zipIdKey
848 showClassName :: Name
849 showClassName = clsQual gHC_SHOW (fsLit "Show") showClassKey
852 readClassName :: Name
853 readClassName = clsQual gHC_READ (fsLit "Read") readClassKey
855 -- Classes Generic and Generic1, Datatype, Constructor and Selector
856 genClassName, gen1ClassName, datatypeClassName, constructorClassName,
857 selectorClassName :: Name
858 genClassName = clsQual gHC_GENERICS (fsLit "Generic") genClassKey
859 gen1ClassName = clsQual gHC_GENERICS (fsLit "Generic1") gen1ClassKey
861 datatypeClassName = clsQual gHC_GENERICS (fsLit "Datatype") datatypeClassKey
862 constructorClassName = clsQual gHC_GENERICS (fsLit "Constructor") constructorClassKey
863 selectorClassName = clsQual gHC_GENERICS (fsLit "Selector") selectorClassKey
865 -- parallel array types and functions
866 enumFromToPName, enumFromThenToPName, nullPName, lengthPName,
867 singletonPName, replicatePName, mapPName, filterPName,
868 zipPName, crossMapPName, indexPName, toPName,
869 emptyPName, appPName :: PackageId -> Name
870 enumFromToPName pkg = varQual (gHC_PARR pkg) (fsLit "enumFromToP") enumFromToPIdKey
871 enumFromThenToPName pkg = varQual (gHC_PARR pkg) (fsLit "enumFromThenToP") enumFromThenToPIdKey
872 nullPName pkg = varQual (gHC_PARR pkg) (fsLit "nullP") nullPIdKey
873 lengthPName pkg = varQual (gHC_PARR pkg) (fsLit "lengthP") lengthPIdKey
874 singletonPName pkg = varQual (gHC_PARR pkg) (fsLit "singletonP") singletonPIdKey
875 replicatePName pkg = varQual (gHC_PARR pkg) (fsLit "replicateP") replicatePIdKey
876 mapPName pkg = varQual (gHC_PARR pkg) (fsLit "mapP") mapPIdKey
877 filterPName pkg = varQual (gHC_PARR pkg) (fsLit "filterP") filterPIdKey
878 zipPName pkg = varQual (gHC_PARR pkg) (fsLit "zipP") zipPIdKey
879 crossMapPName pkg = varQual (gHC_PARR pkg) (fsLit "crossMapP") crossMapPIdKey
880 indexPName pkg = varQual (gHC_PARR pkg) (fsLit "!:") indexPIdKey
881 toPName pkg = varQual (gHC_PARR pkg) (fsLit "toP") toPIdKey
882 emptyPName pkg = varQual (gHC_PARR pkg) (fsLit "emptyP") emptyPIdKey
883 appPName pkg = varQual (gHC_PARR pkg) (fsLit "+:+") appPIdKey
886 ioTyConName, ioDataConName, thenIOName, bindIOName, returnIOName,
888 ioTyConName = tcQual gHC_TYPES (fsLit "IO") ioTyConKey
889 ioDataConName = conName gHC_TYPES (fsLit "IO") ioDataConKey
890 thenIOName = varQual gHC_BASE (fsLit "thenIO") thenIOIdKey
891 bindIOName = varQual gHC_BASE (fsLit "bindIO") bindIOIdKey
892 returnIOName = varQual gHC_BASE (fsLit "returnIO") returnIOIdKey
893 failIOName = varQual gHC_IO (fsLit "failIO") failIOIdKey
897 printName = varQual sYSTEM_IO (fsLit "print") printIdKey
899 -- Int, Word, and Addr things
900 int8TyConName, int16TyConName, int32TyConName, int64TyConName :: Name
901 int8TyConName = tcQual gHC_INT (fsLit "Int8") int8TyConKey
902 int16TyConName = tcQual gHC_INT (fsLit "Int16") int16TyConKey
903 int32TyConName = tcQual gHC_INT (fsLit "Int32") int32TyConKey
904 int64TyConName = tcQual gHC_INT (fsLit "Int64") int64TyConKey
907 word8TyConName, word16TyConName, word32TyConName, word64TyConName,
908 wordTyConName, wordDataConName :: Name
909 word8TyConName = tcQual gHC_WORD (fsLit "Word8") word8TyConKey
910 word16TyConName = tcQual gHC_WORD (fsLit "Word16") word16TyConKey
911 word32TyConName = tcQual gHC_WORD (fsLit "Word32") word32TyConKey
912 word64TyConName = tcQual gHC_WORD (fsLit "Word64") word64TyConKey
913 wordTyConName = tcQual gHC_WORD (fsLit "Word") wordTyConKey
914 wordDataConName = conName gHC_WORD (fsLit "W#") wordDataConKey
917 ptrTyConName, funPtrTyConName :: Name
918 ptrTyConName = tcQual gHC_PTR (fsLit "Ptr") ptrTyConKey
919 funPtrTyConName = tcQual gHC_PTR (fsLit "FunPtr") funPtrTyConKey
921 -- Foreign objects and weak pointers
922 stablePtrTyConName, newStablePtrName :: Name
923 stablePtrTyConName = tcQual gHC_STABLE (fsLit "StablePtr") stablePtrTyConKey
924 newStablePtrName = varQual gHC_STABLE (fsLit "newStablePtr") newStablePtrIdKey
928 runSTRepName = varQual gHC_ST (fsLit "runSTRep") runSTRepIdKey
930 -- Recursive-do notation
931 monadFixClassName, mfixName :: Name
932 monadFixClassName = clsQual mONAD_FIX (fsLit "MonadFix") monadFixClassKey
933 mfixName = methName mONAD_FIX (fsLit "mfix") mfixIdKey
936 arrAName, composeAName, firstAName, appAName, choiceAName, loopAName :: Name
937 arrAName = varQual aRROW (fsLit "arr") arrAIdKey
938 composeAName = varQual gHC_DESUGAR (fsLit ">>>") composeAIdKey
939 firstAName = varQual aRROW (fsLit "first") firstAIdKey
940 appAName = varQual aRROW (fsLit "app") appAIdKey
941 choiceAName = varQual aRROW (fsLit "|||") choiceAIdKey
942 loopAName = varQual aRROW (fsLit "loop") loopAIdKey
944 -- Monad comprehensions
945 guardMName, liftMName, groupMName, mzipName :: Name
946 guardMName = varQual mONAD (fsLit "guard") guardMIdKey
947 liftMName = varQual mONAD (fsLit "liftM") liftMIdKey
948 groupMName = varQual mONAD_GROUP (fsLit "mgroupWith") groupMIdKey
949 mzipName = varQual mONAD_ZIP (fsLit "mzip") mzipIdKey
952 -- Annotation type checking
953 toAnnotationWrapperName :: Name
954 toAnnotationWrapperName = varQual gHC_DESUGAR (fsLit "toAnnotationWrapper") toAnnotationWrapperIdKey
956 -- Other classes, needed for type defaulting
957 monadPlusClassName, randomClassName, randomGenClassName,
958 isStringClassName :: Name
959 monadPlusClassName = clsQual mONAD (fsLit "MonadPlus") monadPlusClassKey
960 randomClassName = clsQual rANDOM (fsLit "Random") randomClassKey
961 randomGenClassName = clsQual rANDOM (fsLit "RandomGen") randomGenClassKey
962 isStringClassName = clsQual dATA_STRING (fsLit "IsString") isStringClassKey
965 objectTyConName :: Name
966 objectTyConName = tcQual dOTNET (fsLit "Object") objectTyConKey
967 -- objectTyConName was "wTcQual", but that's gone now, and
968 -- I can't see why it was wired in anyway...
969 unmarshalObjectName, marshalObjectName, marshalStringName,
970 unmarshalStringName, checkDotnetResName :: Name
971 unmarshalObjectName = varQual dOTNET (fsLit "unmarshalObject") unmarshalObjectIdKey
972 marshalObjectName = varQual dOTNET (fsLit "marshalObject") marshalObjectIdKey
973 marshalStringName = varQual dOTNET (fsLit "marshalString") marshalStringIdKey
974 unmarshalStringName = varQual dOTNET (fsLit "unmarshalString") unmarshalStringIdKey
975 checkDotnetResName = varQual dOTNET (fsLit "checkResult") checkDotnetResNameIdKey
978 %************************************************************************
980 \subsection{Local helpers}
982 %************************************************************************
984 All these are original names; hence mkOrig
987 varQual, tcQual, clsQual :: Module -> FastString -> Unique -> Name
988 varQual = mk_known_key_name varName
989 tcQual = mk_known_key_name tcName
990 clsQual = mk_known_key_name clsName
992 mk_known_key_name :: NameSpace -> Module -> FastString -> Unique -> Name
993 mk_known_key_name space modu str unique
994 = mkExternalName unique modu (mkOccNameFS space str) noSrcSpan
996 conName :: Module -> FastString -> Unique -> Name
997 conName modu occ unique
998 = mkExternalName unique modu (mkOccNameFS dataName occ) noSrcSpan
1000 methName :: Module -> FastString -> Unique -> Name
1001 methName modu occ unique
1002 = mkExternalName unique modu (mkVarOccFS occ) noSrcSpan
1005 %************************************************************************
1007 \subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@}
1009 %************************************************************************
1010 --MetaHaskell extension hand allocate keys here
1013 boundedClassKey, enumClassKey, eqClassKey, floatingClassKey,
1014 fractionalClassKey, integralClassKey, monadClassKey, dataClassKey,
1015 functorClassKey, numClassKey, ordClassKey, readClassKey, realClassKey,
1016 realFloatClassKey, realFracClassKey, showClassKey, ixClassKey :: Unique
1017 boundedClassKey = mkPreludeClassUnique 1
1018 enumClassKey = mkPreludeClassUnique 2
1019 eqClassKey = mkPreludeClassUnique 3
1020 floatingClassKey = mkPreludeClassUnique 5
1021 fractionalClassKey = mkPreludeClassUnique 6
1022 integralClassKey = mkPreludeClassUnique 7
1023 monadClassKey = mkPreludeClassUnique 8
1024 dataClassKey = mkPreludeClassUnique 9
1025 functorClassKey = mkPreludeClassUnique 10
1026 numClassKey = mkPreludeClassUnique 11
1027 ordClassKey = mkPreludeClassUnique 12
1028 readClassKey = mkPreludeClassUnique 13
1029 realClassKey = mkPreludeClassUnique 14
1030 realFloatClassKey = mkPreludeClassUnique 15
1031 realFracClassKey = mkPreludeClassUnique 16
1032 showClassKey = mkPreludeClassUnique 17
1033 ixClassKey = mkPreludeClassUnique 18
1035 typeableClassKey, typeable1ClassKey, typeable2ClassKey, typeable3ClassKey,
1036 typeable4ClassKey, typeable5ClassKey, typeable6ClassKey, typeable7ClassKey
1038 typeableClassKey = mkPreludeClassUnique 20
1039 typeable1ClassKey = mkPreludeClassUnique 21
1040 typeable2ClassKey = mkPreludeClassUnique 22
1041 typeable3ClassKey = mkPreludeClassUnique 23
1042 typeable4ClassKey = mkPreludeClassUnique 24
1043 typeable5ClassKey = mkPreludeClassUnique 25
1044 typeable6ClassKey = mkPreludeClassUnique 26
1045 typeable7ClassKey = mkPreludeClassUnique 27
1047 monadFixClassKey :: Unique
1048 monadFixClassKey = mkPreludeClassUnique 28
1050 monadPlusClassKey, randomClassKey, randomGenClassKey :: Unique
1051 monadPlusClassKey = mkPreludeClassUnique 30
1052 randomClassKey = mkPreludeClassUnique 31
1053 randomGenClassKey = mkPreludeClassUnique 32
1055 isStringClassKey :: Unique
1056 isStringClassKey = mkPreludeClassUnique 33
1058 applicativeClassKey, foldableClassKey, traversableClassKey :: Unique
1059 applicativeClassKey = mkPreludeClassUnique 34
1060 foldableClassKey = mkPreludeClassUnique 35
1061 traversableClassKey = mkPreludeClassUnique 36
1063 genClassKey, gen1ClassKey, datatypeClassKey, constructorClassKey,
1064 selectorClassKey :: Unique
1065 genClassKey = mkPreludeClassUnique 37
1066 gen1ClassKey = mkPreludeClassUnique 38
1068 datatypeClassKey = mkPreludeClassUnique 39
1069 constructorClassKey = mkPreludeClassUnique 40
1070 selectorClassKey = mkPreludeClassUnique 41
1073 %************************************************************************
1075 \subsubsection[Uniques-prelude-TyCons]{@Uniques@ for wired-in @TyCons@}
1077 %************************************************************************
1080 addrPrimTyConKey, arrayPrimTyConKey, boolTyConKey, byteArrayPrimTyConKey,
1081 charPrimTyConKey, charTyConKey, doublePrimTyConKey, doubleTyConKey,
1082 floatPrimTyConKey, floatTyConKey, funTyConKey, intPrimTyConKey,
1083 intTyConKey, int8TyConKey, int16TyConKey, int32PrimTyConKey,
1084 int32TyConKey, int64PrimTyConKey, int64TyConKey, integerTyConKey,
1085 listTyConKey, foreignObjPrimTyConKey, weakPrimTyConKey,
1086 mutableArrayPrimTyConKey, mutableByteArrayPrimTyConKey,
1087 orderingTyConKey, mVarPrimTyConKey, ratioTyConKey, rationalTyConKey,
1088 realWorldTyConKey, stablePtrPrimTyConKey, stablePtrTyConKey,
1089 anyTyConKey :: Unique
1090 addrPrimTyConKey = mkPreludeTyConUnique 1
1091 arrayPrimTyConKey = mkPreludeTyConUnique 3
1092 boolTyConKey = mkPreludeTyConUnique 4
1093 byteArrayPrimTyConKey = mkPreludeTyConUnique 5
1094 charPrimTyConKey = mkPreludeTyConUnique 7
1095 charTyConKey = mkPreludeTyConUnique 8
1096 doublePrimTyConKey = mkPreludeTyConUnique 9
1097 doubleTyConKey = mkPreludeTyConUnique 10
1098 floatPrimTyConKey = mkPreludeTyConUnique 11
1099 floatTyConKey = mkPreludeTyConUnique 12
1100 funTyConKey = mkPreludeTyConUnique 13
1101 intPrimTyConKey = mkPreludeTyConUnique 14
1102 intTyConKey = mkPreludeTyConUnique 15
1103 int8TyConKey = mkPreludeTyConUnique 16
1104 int16TyConKey = mkPreludeTyConUnique 17
1105 int32PrimTyConKey = mkPreludeTyConUnique 18
1106 int32TyConKey = mkPreludeTyConUnique 19
1107 int64PrimTyConKey = mkPreludeTyConUnique 20
1108 int64TyConKey = mkPreludeTyConUnique 21
1109 integerTyConKey = mkPreludeTyConUnique 22
1110 listTyConKey = mkPreludeTyConUnique 23
1111 foreignObjPrimTyConKey = mkPreludeTyConUnique 24
1112 weakPrimTyConKey = mkPreludeTyConUnique 27
1113 mutableArrayPrimTyConKey = mkPreludeTyConUnique 28
1114 mutableByteArrayPrimTyConKey = mkPreludeTyConUnique 29
1115 orderingTyConKey = mkPreludeTyConUnique 30
1116 mVarPrimTyConKey = mkPreludeTyConUnique 31
1117 ratioTyConKey = mkPreludeTyConUnique 32
1118 rationalTyConKey = mkPreludeTyConUnique 33
1119 realWorldTyConKey = mkPreludeTyConUnique 34
1120 stablePtrPrimTyConKey = mkPreludeTyConUnique 35
1121 stablePtrTyConKey = mkPreludeTyConUnique 36
1122 anyTyConKey = mkPreludeTyConUnique 37
1124 statePrimTyConKey, stableNamePrimTyConKey, stableNameTyConKey,
1125 mutVarPrimTyConKey, ioTyConKey,
1126 wordPrimTyConKey, wordTyConKey, word8TyConKey, word16TyConKey,
1127 word32PrimTyConKey, word32TyConKey, word64PrimTyConKey, word64TyConKey,
1128 liftedConKey, unliftedConKey, anyBoxConKey, kindConKey, boxityConKey,
1129 typeConKey, threadIdPrimTyConKey, bcoPrimTyConKey, ptrTyConKey,
1130 funPtrTyConKey, tVarPrimTyConKey, eqPredPrimTyConKey :: Unique
1131 statePrimTyConKey = mkPreludeTyConUnique 50
1132 stableNamePrimTyConKey = mkPreludeTyConUnique 51
1133 stableNameTyConKey = mkPreludeTyConUnique 52
1134 eqPredPrimTyConKey = mkPreludeTyConUnique 53
1135 mutVarPrimTyConKey = mkPreludeTyConUnique 55
1136 ioTyConKey = mkPreludeTyConUnique 56
1137 wordPrimTyConKey = mkPreludeTyConUnique 58
1138 wordTyConKey = mkPreludeTyConUnique 59
1139 word8TyConKey = mkPreludeTyConUnique 60
1140 word16TyConKey = mkPreludeTyConUnique 61
1141 word32PrimTyConKey = mkPreludeTyConUnique 62
1142 word32TyConKey = mkPreludeTyConUnique 63
1143 word64PrimTyConKey = mkPreludeTyConUnique 64
1144 word64TyConKey = mkPreludeTyConUnique 65
1145 liftedConKey = mkPreludeTyConUnique 66
1146 unliftedConKey = mkPreludeTyConUnique 67
1147 anyBoxConKey = mkPreludeTyConUnique 68
1148 kindConKey = mkPreludeTyConUnique 69
1149 boxityConKey = mkPreludeTyConUnique 70
1150 typeConKey = mkPreludeTyConUnique 71
1151 threadIdPrimTyConKey = mkPreludeTyConUnique 72
1152 bcoPrimTyConKey = mkPreludeTyConUnique 73
1153 ptrTyConKey = mkPreludeTyConUnique 74
1154 funPtrTyConKey = mkPreludeTyConUnique 75
1155 tVarPrimTyConKey = mkPreludeTyConUnique 76
1157 -- Parallel array type constructor
1158 parrTyConKey :: Unique
1159 parrTyConKey = mkPreludeTyConUnique 82
1162 objectTyConKey :: Unique
1163 objectTyConKey = mkPreludeTyConUnique 83
1165 eitherTyConKey :: Unique
1166 eitherTyConKey = mkPreludeTyConUnique 84
1168 -- Super Kinds constructors
1169 tySuperKindTyConKey :: Unique
1170 tySuperKindTyConKey = mkPreludeTyConUnique 85
1172 -- Kind constructors
1173 liftedTypeKindTyConKey, openTypeKindTyConKey, unliftedTypeKindTyConKey,
1174 ubxTupleKindTyConKey, argTypeKindTyConKey :: Unique
1175 liftedTypeKindTyConKey = mkPreludeTyConUnique 87
1176 openTypeKindTyConKey = mkPreludeTyConUnique 88
1177 unliftedTypeKindTyConKey = mkPreludeTyConUnique 89
1178 ubxTupleKindTyConKey = mkPreludeTyConUnique 90
1179 argTypeKindTyConKey = mkPreludeTyConUnique 91
1181 -- Coercion constructors
1182 symCoercionTyConKey, transCoercionTyConKey, leftCoercionTyConKey,
1183 rightCoercionTyConKey, instCoercionTyConKey, unsafeCoercionTyConKey,
1184 csel1CoercionTyConKey, csel2CoercionTyConKey, cselRCoercionTyConKey
1186 symCoercionTyConKey = mkPreludeTyConUnique 93
1187 transCoercionTyConKey = mkPreludeTyConUnique 94
1188 leftCoercionTyConKey = mkPreludeTyConUnique 95
1189 rightCoercionTyConKey = mkPreludeTyConUnique 96
1190 instCoercionTyConKey = mkPreludeTyConUnique 97
1191 unsafeCoercionTyConKey = mkPreludeTyConUnique 98
1192 csel1CoercionTyConKey = mkPreludeTyConUnique 99
1193 csel2CoercionTyConKey = mkPreludeTyConUnique 100
1194 cselRCoercionTyConKey = mkPreludeTyConUnique 101
1196 unknownTyConKey, unknown1TyConKey, unknown2TyConKey, unknown3TyConKey,
1197 opaqueTyConKey :: Unique
1198 unknownTyConKey = mkPreludeTyConUnique 129
1199 unknown1TyConKey = mkPreludeTyConUnique 130
1200 unknown2TyConKey = mkPreludeTyConUnique 131
1201 unknown3TyConKey = mkPreludeTyConUnique 132
1202 opaqueTyConKey = mkPreludeTyConUnique 133
1204 stringTyConKey :: Unique
1205 stringTyConKey = mkPreludeTyConUnique 134
1207 -- Generics (Unique keys)
1208 v1TyConKey, u1TyConKey, par1TyConKey, rec1TyConKey,
1209 k1TyConKey, m1TyConKey, sumTyConKey, prodTyConKey,
1210 compTyConKey, rTyConKey, pTyConKey, dTyConKey,
1211 cTyConKey, sTyConKey, rec0TyConKey, par0TyConKey,
1212 d1TyConKey, c1TyConKey, s1TyConKey, noSelTyConKey,
1213 repTyConKey, rep1TyConKey :: Unique
1215 v1TyConKey = mkPreludeTyConUnique 135
1216 u1TyConKey = mkPreludeTyConUnique 136
1217 par1TyConKey = mkPreludeTyConUnique 137
1218 rec1TyConKey = mkPreludeTyConUnique 138
1219 k1TyConKey = mkPreludeTyConUnique 139
1220 m1TyConKey = mkPreludeTyConUnique 140
1222 sumTyConKey = mkPreludeTyConUnique 141
1223 prodTyConKey = mkPreludeTyConUnique 142
1224 compTyConKey = mkPreludeTyConUnique 143
1226 rTyConKey = mkPreludeTyConUnique 144
1227 pTyConKey = mkPreludeTyConUnique 145
1228 dTyConKey = mkPreludeTyConUnique 146
1229 cTyConKey = mkPreludeTyConUnique 147
1230 sTyConKey = mkPreludeTyConUnique 148
1232 rec0TyConKey = mkPreludeTyConUnique 149
1233 par0TyConKey = mkPreludeTyConUnique 150
1234 d1TyConKey = mkPreludeTyConUnique 151
1235 c1TyConKey = mkPreludeTyConUnique 152
1236 s1TyConKey = mkPreludeTyConUnique 153
1237 noSelTyConKey = mkPreludeTyConUnique 154
1239 repTyConKey = mkPreludeTyConUnique 155
1240 rep1TyConKey = mkPreludeTyConUnique 156
1242 ---------------- Template Haskell -------------------
1243 -- USES TyConUniques 200-299
1244 -----------------------------------------------------
1246 unitTyConKey :: Unique
1247 unitTyConKey = mkTupleTyConUnique Boxed 0
1250 %************************************************************************
1252 \subsubsection[Uniques-prelude-DataCons]{@Uniques@ for wired-in @DataCons@}
1254 %************************************************************************
1257 charDataConKey, consDataConKey, doubleDataConKey, falseDataConKey,
1258 floatDataConKey, intDataConKey, nilDataConKey, ratioDataConKey,
1259 stableNameDataConKey, trueDataConKey, wordDataConKey,
1260 ioDataConKey, integerDataConKey :: Unique
1261 charDataConKey = mkPreludeDataConUnique 1
1262 consDataConKey = mkPreludeDataConUnique 2
1263 doubleDataConKey = mkPreludeDataConUnique 3
1264 falseDataConKey = mkPreludeDataConUnique 4
1265 floatDataConKey = mkPreludeDataConUnique 5
1266 intDataConKey = mkPreludeDataConUnique 6
1267 nilDataConKey = mkPreludeDataConUnique 11
1268 ratioDataConKey = mkPreludeDataConUnique 12
1269 stableNameDataConKey = mkPreludeDataConUnique 14
1270 trueDataConKey = mkPreludeDataConUnique 15
1271 wordDataConKey = mkPreludeDataConUnique 16
1272 ioDataConKey = mkPreludeDataConUnique 17
1273 integerDataConKey = mkPreludeDataConUnique 18
1275 -- Generic data constructors
1276 crossDataConKey, inlDataConKey, inrDataConKey, genUnitDataConKey :: Unique
1277 crossDataConKey = mkPreludeDataConUnique 20
1278 inlDataConKey = mkPreludeDataConUnique 21
1279 inrDataConKey = mkPreludeDataConUnique 22
1280 genUnitDataConKey = mkPreludeDataConUnique 23
1282 -- Data constructor for parallel arrays
1283 parrDataConKey :: Unique
1284 parrDataConKey = mkPreludeDataConUnique 24
1286 leftDataConKey, rightDataConKey :: Unique
1287 leftDataConKey = mkPreludeDataConUnique 25
1288 rightDataConKey = mkPreludeDataConUnique 26
1291 %************************************************************************
1293 \subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}
1295 %************************************************************************
1298 absentErrorIdKey, augmentIdKey, appendIdKey, buildIdKey, errorIdKey,
1299 foldlIdKey, foldrIdKey, recSelErrorIdKey,
1300 integerMinusOneIdKey, integerPlusOneIdKey,
1301 integerPlusTwoIdKey, integerZeroIdKey,
1302 int2IntegerIdKey, seqIdKey, irrefutPatErrorIdKey, eqStringIdKey,
1303 noMethodBindingErrorIdKey, nonExhaustiveGuardsErrorIdKey,
1304 runtimeErrorIdKey, parErrorIdKey, parIdKey, patErrorIdKey,
1305 realWorldPrimIdKey, recConErrorIdKey, recUpdErrorIdKey,
1306 traceIdKey, wildCardKey,
1307 unpackCStringUtf8IdKey, unpackCStringAppendIdKey,
1308 unpackCStringFoldrIdKey, unpackCStringIdKey :: Unique
1309 wildCardKey = mkPreludeMiscIdUnique 0 -- See Note [WildCard]
1310 absentErrorIdKey = mkPreludeMiscIdUnique 1
1311 augmentIdKey = mkPreludeMiscIdUnique 3
1312 appendIdKey = mkPreludeMiscIdUnique 4
1313 buildIdKey = mkPreludeMiscIdUnique 5
1314 errorIdKey = mkPreludeMiscIdUnique 6
1315 foldlIdKey = mkPreludeMiscIdUnique 7
1316 foldrIdKey = mkPreludeMiscIdUnique 8
1317 recSelErrorIdKey = mkPreludeMiscIdUnique 9
1318 integerMinusOneIdKey = mkPreludeMiscIdUnique 10
1319 integerPlusOneIdKey = mkPreludeMiscIdUnique 11
1320 integerPlusTwoIdKey = mkPreludeMiscIdUnique 12
1321 integerZeroIdKey = mkPreludeMiscIdUnique 13
1322 int2IntegerIdKey = mkPreludeMiscIdUnique 14
1323 seqIdKey = mkPreludeMiscIdUnique 15
1324 irrefutPatErrorIdKey = mkPreludeMiscIdUnique 16
1325 eqStringIdKey = mkPreludeMiscIdUnique 17
1326 noMethodBindingErrorIdKey = mkPreludeMiscIdUnique 18
1327 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 19
1328 runtimeErrorIdKey = mkPreludeMiscIdUnique 20
1329 parErrorIdKey = mkPreludeMiscIdUnique 21
1330 parIdKey = mkPreludeMiscIdUnique 22
1331 patErrorIdKey = mkPreludeMiscIdUnique 23
1332 realWorldPrimIdKey = mkPreludeMiscIdUnique 24
1333 recConErrorIdKey = mkPreludeMiscIdUnique 25
1334 recUpdErrorIdKey = mkPreludeMiscIdUnique 26
1335 traceIdKey = mkPreludeMiscIdUnique 27
1336 unpackCStringUtf8IdKey = mkPreludeMiscIdUnique 28
1337 unpackCStringAppendIdKey = mkPreludeMiscIdUnique 29
1338 unpackCStringFoldrIdKey = mkPreludeMiscIdUnique 30
1339 unpackCStringIdKey = mkPreludeMiscIdUnique 31
1341 unsafeCoerceIdKey, concatIdKey, filterIdKey, zipIdKey, bindIOIdKey,
1342 returnIOIdKey, deRefStablePtrIdKey, newStablePtrIdKey,
1343 smallIntegerIdKey, plusIntegerIdKey, timesIntegerIdKey,
1344 printIdKey, failIOIdKey, nullAddrIdKey, voidArgIdKey,
1345 fstIdKey, sndIdKey, otherwiseIdKey, assertIdKey, runSTRepIdKey :: Unique
1346 unsafeCoerceIdKey = mkPreludeMiscIdUnique 32
1347 concatIdKey = mkPreludeMiscIdUnique 33
1348 filterIdKey = mkPreludeMiscIdUnique 34
1349 zipIdKey = mkPreludeMiscIdUnique 35
1350 bindIOIdKey = mkPreludeMiscIdUnique 36
1351 returnIOIdKey = mkPreludeMiscIdUnique 37
1352 deRefStablePtrIdKey = mkPreludeMiscIdUnique 38
1353 newStablePtrIdKey = mkPreludeMiscIdUnique 39
1354 smallIntegerIdKey = mkPreludeMiscIdUnique 40
1355 plusIntegerIdKey = mkPreludeMiscIdUnique 41
1356 timesIntegerIdKey = mkPreludeMiscIdUnique 42
1357 printIdKey = mkPreludeMiscIdUnique 43
1358 failIOIdKey = mkPreludeMiscIdUnique 44
1359 nullAddrIdKey = mkPreludeMiscIdUnique 46
1360 voidArgIdKey = mkPreludeMiscIdUnique 47
1361 fstIdKey = mkPreludeMiscIdUnique 49
1362 sndIdKey = mkPreludeMiscIdUnique 50
1363 otherwiseIdKey = mkPreludeMiscIdUnique 51
1364 assertIdKey = mkPreludeMiscIdUnique 53
1365 runSTRepIdKey = mkPreludeMiscIdUnique 54
1367 rootMainKey, runMainKey :: Unique
1368 rootMainKey = mkPreludeMiscIdUnique 55
1369 runMainKey = mkPreludeMiscIdUnique 56
1371 thenIOIdKey, lazyIdKey, assertErrorIdKey :: Unique
1372 thenIOIdKey = mkPreludeMiscIdUnique 59
1373 lazyIdKey = mkPreludeMiscIdUnique 60
1374 assertErrorIdKey = mkPreludeMiscIdUnique 61
1376 breakpointIdKey, breakpointCondIdKey, breakpointAutoIdKey,
1377 breakpointJumpIdKey, breakpointCondJumpIdKey,
1378 breakpointAutoJumpIdKey :: Unique
1379 breakpointIdKey = mkPreludeMiscIdUnique 62
1380 breakpointCondIdKey = mkPreludeMiscIdUnique 63
1381 breakpointAutoIdKey = mkPreludeMiscIdUnique 64
1382 breakpointJumpIdKey = mkPreludeMiscIdUnique 65
1383 breakpointCondJumpIdKey = mkPreludeMiscIdUnique 66
1384 breakpointAutoJumpIdKey = mkPreludeMiscIdUnique 67
1386 inlineIdKey :: Unique
1387 inlineIdKey = mkPreludeMiscIdUnique 68
1389 mapIdKey, groupWithIdKey, dollarIdKey :: Unique
1390 mapIdKey = mkPreludeMiscIdUnique 69
1391 groupWithIdKey = mkPreludeMiscIdUnique 70
1392 dollarIdKey = mkPreludeMiscIdUnique 71
1394 coercionTokenIdKey :: Unique
1395 coercionTokenIdKey = mkPreludeMiscIdUnique 72
1397 -- Parallel array functions
1398 singletonPIdKey, nullPIdKey, lengthPIdKey, replicatePIdKey, mapPIdKey,
1399 filterPIdKey, zipPIdKey, crossMapPIdKey, indexPIdKey, toPIdKey,
1400 enumFromToPIdKey, enumFromThenToPIdKey, emptyPIdKey, appPIdKey :: Unique
1401 singletonPIdKey = mkPreludeMiscIdUnique 79
1402 nullPIdKey = mkPreludeMiscIdUnique 80
1403 lengthPIdKey = mkPreludeMiscIdUnique 81
1404 replicatePIdKey = mkPreludeMiscIdUnique 82
1405 mapPIdKey = mkPreludeMiscIdUnique 83
1406 filterPIdKey = mkPreludeMiscIdUnique 84
1407 zipPIdKey = mkPreludeMiscIdUnique 85
1408 crossMapPIdKey = mkPreludeMiscIdUnique 86
1409 indexPIdKey = mkPreludeMiscIdUnique 87
1410 toPIdKey = mkPreludeMiscIdUnique 88
1411 enumFromToPIdKey = mkPreludeMiscIdUnique 89
1412 enumFromThenToPIdKey = mkPreludeMiscIdUnique 90
1413 emptyPIdKey = mkPreludeMiscIdUnique 91
1414 appPIdKey = mkPreludeMiscIdUnique 92
1417 unmarshalObjectIdKey, marshalObjectIdKey, marshalStringIdKey,
1418 unmarshalStringIdKey, checkDotnetResNameIdKey :: Unique
1419 unmarshalObjectIdKey = mkPreludeMiscIdUnique 94
1420 marshalObjectIdKey = mkPreludeMiscIdUnique 95
1421 marshalStringIdKey = mkPreludeMiscIdUnique 96
1422 unmarshalStringIdKey = mkPreludeMiscIdUnique 97
1423 checkDotnetResNameIdKey = mkPreludeMiscIdUnique 98
1427 Certain class operations from Prelude classes. They get their own
1428 uniques so we can look them up easily when we want to conjure them up
1429 during type checking.
1432 -- Just a place holder for unbound variables produced by the renamer:
1433 unboundKey :: Unique
1434 unboundKey = mkPreludeMiscIdUnique 101
1436 fromIntegerClassOpKey, minusClassOpKey, fromRationalClassOpKey,
1437 enumFromClassOpKey, enumFromThenClassOpKey, enumFromToClassOpKey,
1438 enumFromThenToClassOpKey, eqClassOpKey, geClassOpKey, negateClassOpKey,
1439 failMClassOpKey, bindMClassOpKey, thenMClassOpKey, returnMClassOpKey,
1442 fromIntegerClassOpKey = mkPreludeMiscIdUnique 102
1443 minusClassOpKey = mkPreludeMiscIdUnique 103
1444 fromRationalClassOpKey = mkPreludeMiscIdUnique 104
1445 enumFromClassOpKey = mkPreludeMiscIdUnique 105
1446 enumFromThenClassOpKey = mkPreludeMiscIdUnique 106
1447 enumFromToClassOpKey = mkPreludeMiscIdUnique 107
1448 enumFromThenToClassOpKey = mkPreludeMiscIdUnique 108
1449 eqClassOpKey = mkPreludeMiscIdUnique 109
1450 geClassOpKey = mkPreludeMiscIdUnique 110
1451 negateClassOpKey = mkPreludeMiscIdUnique 111
1452 failMClassOpKey = mkPreludeMiscIdUnique 112
1453 bindMClassOpKey = mkPreludeMiscIdUnique 113 -- (>>=)
1454 thenMClassOpKey = mkPreludeMiscIdUnique 114 -- (>>)
1455 fmapClassOpKey = mkPreludeMiscIdUnique 115
1456 returnMClassOpKey = mkPreludeMiscIdUnique 117
1458 -- Recursive do notation
1460 mfixIdKey = mkPreludeMiscIdUnique 118
1463 arrAIdKey, composeAIdKey, firstAIdKey, appAIdKey, choiceAIdKey,
1464 loopAIdKey :: Unique
1465 arrAIdKey = mkPreludeMiscIdUnique 119
1466 composeAIdKey = mkPreludeMiscIdUnique 120 -- >>>
1467 firstAIdKey = mkPreludeMiscIdUnique 121
1468 appAIdKey = mkPreludeMiscIdUnique 122
1469 choiceAIdKey = mkPreludeMiscIdUnique 123 -- |||
1470 loopAIdKey = mkPreludeMiscIdUnique 124
1472 fromStringClassOpKey :: Unique
1473 fromStringClassOpKey = mkPreludeMiscIdUnique 125
1475 -- Annotation type checking
1476 toAnnotationWrapperIdKey :: Unique
1477 toAnnotationWrapperIdKey = mkPreludeMiscIdUnique 126
1479 -- Conversion functions
1480 fromIntegralIdKey, realToFracIdKey, toIntegerClassOpKey, toRationalClassOpKey :: Unique
1481 fromIntegralIdKey = mkPreludeMiscIdUnique 127
1482 realToFracIdKey = mkPreludeMiscIdUnique 128
1483 toIntegerClassOpKey = mkPreludeMiscIdUnique 129
1484 toRationalClassOpKey = mkPreludeMiscIdUnique 130
1486 -- Monad comprehensions
1487 guardMIdKey, liftMIdKey, groupMIdKey, mzipIdKey :: Unique
1488 guardMIdKey = mkPreludeMiscIdUnique 131
1489 liftMIdKey = mkPreludeMiscIdUnique 132
1490 groupMIdKey = mkPreludeMiscIdUnique 133
1491 mzipIdKey = mkPreludeMiscIdUnique 134
1494 ---------------- Template Haskell -------------------
1495 -- USES IdUniques 200-499
1496 -----------------------------------------------------
1500 %************************************************************************
1502 \subsection{Standard groups of types}
1504 %************************************************************************
1507 numericTyKeys :: [Unique]
1516 kindKeys :: [Unique]
1517 kindKeys = [ liftedTypeKindTyConKey
1518 , openTypeKindTyConKey
1519 , unliftedTypeKindTyConKey
1520 , ubxTupleKindTyConKey
1521 , argTypeKindTyConKey ]
1525 %************************************************************************
1527 \subsection[Class-std-groups]{Standard groups of Prelude classes}
1529 %************************************************************************
1531 NOTE: @Eq@ and @Text@ do need to appear in @standardClasses@
1532 even though every numeric class has these two as a superclass,
1533 because the list of ambiguous dictionaries hasn't been simplified.
1536 numericClassKeys :: [Unique]
1542 ++ fractionalClassKeys
1544 fractionalClassKeys :: [Unique]
1545 fractionalClassKeys =
1546 [ fractionalClassKey
1552 -- the strictness analyser needs to know about numeric types
1553 -- (see SaAbsInt.lhs)
1554 needsDataDeclCtxtClassKeys :: [Unique]
1555 needsDataDeclCtxtClassKeys = -- see comments in TcDeriv
1559 -- The "standard classes" are used in defaulting (Haskell 98 report 4.3.4),
1560 -- and are: "classes defined in the Prelude or a standard library"
1561 standardClassKeys :: [Unique]
1562 standardClassKeys = derivableClassKeys ++ numericClassKeys
1563 ++ [randomClassKey, randomGenClassKey,
1565 monadClassKey, monadPlusClassKey,
1567 applicativeClassKey, foldableClassKey, traversableClassKey
1571 @derivableClassKeys@ is also used in checking \tr{deriving} constructs
1575 derivableClassKeys :: [Unique]
1577 = [ eqClassKey, ordClassKey, enumClassKey, ixClassKey,
1578 boundedClassKey, showClassKey, readClassKey ]