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,
168 arrAName, composeAName, firstAName,
169 appAName, choiceAName, loopAName,
187 unpackCStringName, unpackCStringAppendName,
188 unpackCStringFoldrName, unpackCStringUtf8Name,
191 concatName, filterName, mapName,
192 zipName, foldrName, buildName, augmentName, appendName,
194 dollarName, -- The ($) apply function
196 -- FFI primitive types that are not wired-in.
197 stablePtrTyConName, ptrTyConName, funPtrTyConName,
198 int8TyConName, int16TyConName, int32TyConName, int64TyConName,
199 wordTyConName, word8TyConName, word16TyConName, word32TyConName, word64TyConName,
202 otherwiseIdName, inlineIdName,
203 plusIntegerName, timesIntegerName,
204 eqStringName, assertName, breakpointName, breakpointCondName,
205 breakpointAutoName, opaqueTyConName,
206 assertErrorName, runSTRepName,
207 printName, fstName, sndName,
210 monadFixClassName, mfixName,
213 randomClassName, randomGenClassName, monadPlusClassName,
215 -- Annotation type checking
216 toAnnotationWrapperName
219 , eitherTyConName, leftDataConName, rightDataConName
222 , objectTyConName, marshalObjectName, unmarshalObjectName
223 , marshalStringName, unmarshalStringName, checkDotnetResName
226 , rep0ClassName, rep1ClassName
227 , datatypeClassName, constructorClassName, selectorClassName
231 genericTyConNames :: [Name]
232 genericTyConNames = [
234 crossTyConName, plusTyConName, genUnitTyConName,
236 v1TyConName, u1TyConName, par1TyConName, rec1TyConName,
237 k1TyConName, m1TyConName, sumTyConName, prodTyConName,
238 compTyConName, rTyConName, pTyConName, dTyConName,
239 cTyConName, sTyConName, rec0TyConName, par0TyConName,
240 d1TyConName, c1TyConName, s1TyConName, noSelTyConName,
241 rep0TyConName, rep1TyConName
244 -- Know names from the DPH package which vary depending on the selected DPH backend.
246 dphKnownKeyNames :: PackageId -> [Name]
247 dphKnownKeyNames dphPkg
250 -- Parallel array operations
251 nullPName, lengthPName, replicatePName, singletonPName, mapPName,
252 filterPName, zipPName, crossMapPName, indexPName,
253 toPName, emptyPName, appPName,
254 enumFromToPName, enumFromThenToPName
260 %************************************************************************
262 \subsection{Module names}
264 %************************************************************************
267 --MetaHaskell Extension Add a new module here
270 pRELUDE = mkBaseModule_ pRELUDE_NAME
272 gHC_PRIM, gHC_TYPES, gHC_UNIT, gHC_ORDERING, gHC_GENERICS,
274 gHC_CLASSES, gHC_BASE, gHC_ENUM, gHC_CSTRING,
275 gHC_SHOW, gHC_READ, gHC_NUM, gHC_INTEGER, gHC_INTEGER_TYPE, gHC_LIST,
276 gHC_TUPLE, dATA_TUPLE, dATA_EITHER, dATA_STRING, dATA_FOLDABLE, dATA_TRAVERSABLE,
277 gHC_PACK, gHC_CONC, gHC_IO, gHC_IO_Exception,
278 gHC_ST, gHC_ARR, gHC_STABLE, gHC_ADDR, gHC_PTR, gHC_ERR, gHC_REAL,
279 gHC_FLOAT, gHC_TOP_HANDLER, sYSTEM_IO, dYNAMIC, tYPEABLE, gENERICS,
280 dOTNET, rEAD_PREC, lEX, gHC_INT, gHC_WORD, mONAD, mONAD_FIX, aRROW, cONTROL_APPLICATIVE,
281 gHC_DESUGAR, rANDOM, gHC_EXTS, cONTROL_EXCEPTION_BASE :: Module
283 gHC_PRIM = mkPrimModule (fsLit "GHC.Prim") -- Primitive types and values
284 gHC_TYPES = mkPrimModule (fsLit "GHC.Types")
285 gHC_UNIT = mkPrimModule (fsLit "GHC.Unit")
286 gHC_ORDERING = mkPrimModule (fsLit "GHC.Ordering")
287 gHC_GENERICS = mkPrimModule (fsLit "GHC.Generics")
288 gHC_MAGIC = mkPrimModule (fsLit "GHC.Magic")
289 gHC_CSTRING = mkPrimModule (fsLit "GHC.CString")
291 gHC_CLASSES = mkBaseModule (fsLit "GHC.Classes")
292 gHC_BASE = mkBaseModule (fsLit "GHC.Base")
293 gHC_ENUM = mkBaseModule (fsLit "GHC.Enum")
294 gHC_SHOW = mkBaseModule (fsLit "GHC.Show")
295 gHC_READ = mkBaseModule (fsLit "GHC.Read")
296 gHC_NUM = mkBaseModule (fsLit "GHC.Num")
297 gHC_INTEGER = mkIntegerModule (fsLit "GHC.Integer")
298 gHC_INTEGER_TYPE= mkIntegerModule (fsLit "GHC.Integer.Type")
299 gHC_LIST = mkBaseModule (fsLit "GHC.List")
300 gHC_TUPLE = mkPrimModule (fsLit "GHC.Tuple")
301 dATA_TUPLE = mkBaseModule (fsLit "Data.Tuple")
302 dATA_EITHER = mkBaseModule (fsLit "Data.Either")
303 dATA_STRING = mkBaseModule (fsLit "Data.String")
304 dATA_FOLDABLE = mkBaseModule (fsLit "Data.Foldable")
305 dATA_TRAVERSABLE= mkBaseModule (fsLit "Data.Traversable")
306 gHC_PACK = mkBaseModule (fsLit "GHC.Pack")
307 gHC_CONC = mkBaseModule (fsLit "GHC.Conc")
308 gHC_IO = mkBaseModule (fsLit "GHC.IO")
309 gHC_IO_Exception = mkBaseModule (fsLit "GHC.IO.Exception")
310 gHC_ST = mkBaseModule (fsLit "GHC.ST")
311 gHC_ARR = mkBaseModule (fsLit "GHC.Arr")
312 gHC_STABLE = mkBaseModule (fsLit "GHC.Stable")
313 gHC_ADDR = mkBaseModule (fsLit "GHC.Addr")
314 gHC_PTR = mkBaseModule (fsLit "GHC.Ptr")
315 gHC_ERR = mkBaseModule (fsLit "GHC.Err")
316 gHC_REAL = mkBaseModule (fsLit "GHC.Real")
317 gHC_FLOAT = mkBaseModule (fsLit "GHC.Float")
318 gHC_TOP_HANDLER = mkBaseModule (fsLit "GHC.TopHandler")
319 sYSTEM_IO = mkBaseModule (fsLit "System.IO")
320 dYNAMIC = mkBaseModule (fsLit "Data.Dynamic")
321 tYPEABLE = mkBaseModule (fsLit "Data.Typeable")
322 gENERICS = mkBaseModule (fsLit "Data.Data")
323 dOTNET = mkBaseModule (fsLit "GHC.Dotnet")
324 rEAD_PREC = mkBaseModule (fsLit "Text.ParserCombinators.ReadPrec")
325 lEX = mkBaseModule (fsLit "Text.Read.Lex")
326 gHC_INT = mkBaseModule (fsLit "GHC.Int")
327 gHC_WORD = mkBaseModule (fsLit "GHC.Word")
328 mONAD = mkBaseModule (fsLit "Control.Monad")
329 mONAD_FIX = mkBaseModule (fsLit "Control.Monad.Fix")
330 aRROW = mkBaseModule (fsLit "Control.Arrow")
331 cONTROL_APPLICATIVE = mkBaseModule (fsLit "Control.Applicative")
332 gHC_DESUGAR = mkBaseModule (fsLit "GHC.Desugar")
333 rANDOM = mkBaseModule (fsLit "System.Random")
334 gHC_EXTS = mkBaseModule (fsLit "GHC.Exts")
335 cONTROL_EXCEPTION_BASE = mkBaseModule (fsLit "Control.Exception.Base")
337 gHC_PARR :: PackageId -> Module
338 gHC_PARR pkg = mkModule pkg (mkModuleNameFS (fsLit "Data.Array.Parallel"))
341 gHC_PARR' = mkBaseModule (fsLit "GHC.PArr")
343 mAIN, rOOT_MAIN :: Module
344 mAIN = mkMainModule_ mAIN_NAME
345 rOOT_MAIN = mkMainModule (fsLit ":Main") -- Root module for initialisation
347 -- The ':xxx' makes a module name that the user can never
348 -- use himself. The z-encoding for ':' is "ZC", so the z-encoded
349 -- module name still starts with a capital letter, which keeps
350 -- the z-encoded version consistent.
351 iNTERACTIVE :: Module
352 iNTERACTIVE = mkMainModule (fsLit ":Interactive")
354 pRELUDE_NAME, mAIN_NAME :: ModuleName
355 pRELUDE_NAME = mkModuleNameFS (fsLit "Prelude")
356 mAIN_NAME = mkModuleNameFS (fsLit "Main")
358 mkPrimModule :: FastString -> Module
359 mkPrimModule m = mkModule primPackageId (mkModuleNameFS m)
361 mkIntegerModule :: FastString -> Module
362 mkIntegerModule m = mkModule integerPackageId (mkModuleNameFS m)
364 mkBaseModule :: FastString -> Module
365 mkBaseModule m = mkModule basePackageId (mkModuleNameFS m)
367 mkBaseModule_ :: ModuleName -> Module
368 mkBaseModule_ m = mkModule basePackageId m
370 mkMainModule :: FastString -> Module
371 mkMainModule m = mkModule mainPackageId (mkModuleNameFS m)
373 mkMainModule_ :: ModuleName -> Module
374 mkMainModule_ m = mkModule mainPackageId m
377 %************************************************************************
379 \subsection{Constructing the names of tuples
381 %************************************************************************
384 mkTupleModule :: Boxity -> Arity -> Module
385 mkTupleModule Boxed 0 = gHC_UNIT
386 mkTupleModule Boxed _ = gHC_TUPLE
387 mkTupleModule Unboxed _ = gHC_PRIM
391 %************************************************************************
395 %************************************************************************
398 main_RDR_Unqual :: RdrName
399 main_RDR_Unqual = mkUnqual varName (fsLit "main")
400 -- We definitely don't want an Orig RdrName, because
401 -- main might, in principle, be imported into module Main
403 forall_tv_RDR, dot_tv_RDR :: RdrName
404 forall_tv_RDR = mkUnqual tvName (fsLit "forall")
405 dot_tv_RDR = mkUnqual tvName (fsLit ".")
407 eq_RDR, ge_RDR, ne_RDR, le_RDR, lt_RDR, gt_RDR, compare_RDR,
408 ltTag_RDR, eqTag_RDR, gtTag_RDR :: RdrName
409 eq_RDR = nameRdrName eqName
410 ge_RDR = nameRdrName geName
411 ne_RDR = varQual_RDR gHC_CLASSES (fsLit "/=")
412 le_RDR = varQual_RDR gHC_CLASSES (fsLit "<=")
413 lt_RDR = varQual_RDR gHC_CLASSES (fsLit "<")
414 gt_RDR = varQual_RDR gHC_CLASSES (fsLit ">")
415 compare_RDR = varQual_RDR gHC_CLASSES (fsLit "compare")
416 ltTag_RDR = dataQual_RDR gHC_ORDERING (fsLit "LT")
417 eqTag_RDR = dataQual_RDR gHC_ORDERING (fsLit "EQ")
418 gtTag_RDR = dataQual_RDR gHC_ORDERING (fsLit "GT")
420 eqClass_RDR, numClass_RDR, ordClass_RDR, enumClass_RDR, monadClass_RDR
422 eqClass_RDR = nameRdrName eqClassName
423 numClass_RDR = nameRdrName numClassName
424 ordClass_RDR = nameRdrName ordClassName
425 enumClass_RDR = nameRdrName enumClassName
426 monadClass_RDR = nameRdrName monadClassName
428 map_RDR, append_RDR :: RdrName
429 map_RDR = varQual_RDR gHC_BASE (fsLit "map")
430 append_RDR = varQual_RDR gHC_BASE (fsLit "++")
432 foldr_RDR, build_RDR, returnM_RDR, bindM_RDR, failM_RDR :: RdrName
433 foldr_RDR = nameRdrName foldrName
434 build_RDR = nameRdrName buildName
435 returnM_RDR = nameRdrName returnMName
436 bindM_RDR = nameRdrName bindMName
437 failM_RDR = nameRdrName failMName
439 left_RDR, right_RDR :: RdrName
440 left_RDR = nameRdrName leftDataConName
441 right_RDR = nameRdrName rightDataConName
443 fromEnum_RDR, toEnum_RDR :: RdrName
444 fromEnum_RDR = varQual_RDR gHC_ENUM (fsLit "fromEnum")
445 toEnum_RDR = varQual_RDR gHC_ENUM (fsLit "toEnum")
447 enumFrom_RDR, enumFromTo_RDR, enumFromThen_RDR, enumFromThenTo_RDR :: RdrName
448 enumFrom_RDR = nameRdrName enumFromName
449 enumFromTo_RDR = nameRdrName enumFromToName
450 enumFromThen_RDR = nameRdrName enumFromThenName
451 enumFromThenTo_RDR = nameRdrName enumFromThenToName
453 ratioDataCon_RDR, plusInteger_RDR, timesInteger_RDR :: RdrName
454 ratioDataCon_RDR = nameRdrName ratioDataConName
455 plusInteger_RDR = nameRdrName plusIntegerName
456 timesInteger_RDR = nameRdrName timesIntegerName
458 ioDataCon_RDR :: RdrName
459 ioDataCon_RDR = nameRdrName ioDataConName
461 eqString_RDR, unpackCString_RDR, unpackCStringFoldr_RDR,
462 unpackCStringUtf8_RDR :: RdrName
463 eqString_RDR = nameRdrName eqStringName
464 unpackCString_RDR = nameRdrName unpackCStringName
465 unpackCStringFoldr_RDR = nameRdrName unpackCStringFoldrName
466 unpackCStringUtf8_RDR = nameRdrName unpackCStringUtf8Name
468 newStablePtr_RDR, wordDataCon_RDR :: RdrName
469 newStablePtr_RDR = nameRdrName newStablePtrName
470 wordDataCon_RDR = dataQual_RDR gHC_WORD (fsLit "W#")
472 bindIO_RDR, returnIO_RDR :: RdrName
473 bindIO_RDR = nameRdrName bindIOName
474 returnIO_RDR = nameRdrName returnIOName
476 fromInteger_RDR, fromRational_RDR, minus_RDR, times_RDR, plus_RDR :: RdrName
477 fromInteger_RDR = nameRdrName fromIntegerName
478 fromRational_RDR = nameRdrName fromRationalName
479 minus_RDR = nameRdrName minusName
480 times_RDR = varQual_RDR gHC_NUM (fsLit "*")
481 plus_RDR = varQual_RDR gHC_NUM (fsLit "+")
483 fromString_RDR :: RdrName
484 fromString_RDR = nameRdrName fromStringName
486 compose_RDR :: RdrName
487 compose_RDR = varQual_RDR gHC_BASE (fsLit ".")
489 not_RDR, getTag_RDR, succ_RDR, pred_RDR, minBound_RDR, maxBound_RDR,
490 and_RDR, range_RDR, inRange_RDR, index_RDR,
491 unsafeIndex_RDR, unsafeRangeSize_RDR :: RdrName
492 and_RDR = varQual_RDR gHC_CLASSES (fsLit "&&")
493 not_RDR = varQual_RDR gHC_CLASSES (fsLit "not")
494 getTag_RDR = varQual_RDR gHC_BASE (fsLit "getTag")
495 succ_RDR = varQual_RDR gHC_ENUM (fsLit "succ")
496 pred_RDR = varQual_RDR gHC_ENUM (fsLit "pred")
497 minBound_RDR = varQual_RDR gHC_ENUM (fsLit "minBound")
498 maxBound_RDR = varQual_RDR gHC_ENUM (fsLit "maxBound")
499 range_RDR = varQual_RDR gHC_ARR (fsLit "range")
500 inRange_RDR = varQual_RDR gHC_ARR (fsLit "inRange")
501 index_RDR = varQual_RDR gHC_ARR (fsLit "index")
502 unsafeIndex_RDR = varQual_RDR gHC_ARR (fsLit "unsafeIndex")
503 unsafeRangeSize_RDR = varQual_RDR gHC_ARR (fsLit "unsafeRangeSize")
505 readList_RDR, readListDefault_RDR, readListPrec_RDR, readListPrecDefault_RDR,
506 readPrec_RDR, parens_RDR, choose_RDR, lexP_RDR :: RdrName
507 readList_RDR = varQual_RDR gHC_READ (fsLit "readList")
508 readListDefault_RDR = varQual_RDR gHC_READ (fsLit "readListDefault")
509 readListPrec_RDR = varQual_RDR gHC_READ (fsLit "readListPrec")
510 readListPrecDefault_RDR = varQual_RDR gHC_READ (fsLit "readListPrecDefault")
511 readPrec_RDR = varQual_RDR gHC_READ (fsLit "readPrec")
512 parens_RDR = varQual_RDR gHC_READ (fsLit "parens")
513 choose_RDR = varQual_RDR gHC_READ (fsLit "choose")
514 lexP_RDR = varQual_RDR gHC_READ (fsLit "lexP")
516 punc_RDR, ident_RDR, symbol_RDR :: RdrName
517 punc_RDR = dataQual_RDR lEX (fsLit "Punc")
518 ident_RDR = dataQual_RDR lEX (fsLit "Ident")
519 symbol_RDR = dataQual_RDR lEX (fsLit "Symbol")
521 step_RDR, alt_RDR, reset_RDR, prec_RDR :: RdrName
522 step_RDR = varQual_RDR rEAD_PREC (fsLit "step")
523 alt_RDR = varQual_RDR rEAD_PREC (fsLit "+++")
524 reset_RDR = varQual_RDR rEAD_PREC (fsLit "reset")
525 prec_RDR = varQual_RDR rEAD_PREC (fsLit "prec")
527 showList_RDR, showList___RDR, showsPrec_RDR, showString_RDR,
528 showSpace_RDR, showParen_RDR :: RdrName
529 showList_RDR = varQual_RDR gHC_SHOW (fsLit "showList")
530 showList___RDR = varQual_RDR gHC_SHOW (fsLit "showList__")
531 showsPrec_RDR = varQual_RDR gHC_SHOW (fsLit "showsPrec")
532 showString_RDR = varQual_RDR gHC_SHOW (fsLit "showString")
533 showSpace_RDR = varQual_RDR gHC_SHOW (fsLit "showSpace")
534 showParen_RDR = varQual_RDR gHC_SHOW (fsLit "showParen")
536 typeOf_RDR, mkTypeRep_RDR, mkTyConRep_RDR :: RdrName
537 typeOf_RDR = varQual_RDR tYPEABLE (fsLit "typeOf")
538 mkTypeRep_RDR = varQual_RDR tYPEABLE (fsLit "mkTyConApp")
539 mkTyConRep_RDR = varQual_RDR tYPEABLE (fsLit "mkTyCon")
541 undefined_RDR :: RdrName
542 undefined_RDR = varQual_RDR gHC_ERR (fsLit "undefined")
545 error_RDR = varQual_RDR gHC_ERR (fsLit "error")
547 -- Old Generics (constructors and functions)
548 crossDataCon_RDR, inlDataCon_RDR, inrDataCon_RDR, genUnitDataCon_RDR :: RdrName
549 crossDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit ":*:")
550 inlDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Inl")
551 inrDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Inr")
552 genUnitDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Unit")
554 -- Generics (constructors and functions)
555 u1DataCon_RDR, par1DataCon_RDR, rec1DataCon_RDR,
556 k1DataCon_RDR, m1DataCon_RDR, l1DataCon_RDR, r1DataCon_RDR,
557 prodDataCon_RDR, comp1DataCon_RDR, from0_RDR, from1_RDR,
558 to0_RDR, to1_RDR, datatypeName_RDR, moduleName_RDR, conName_RDR,
559 conFixity_RDR, conIsRecord_RDR,
560 noArityDataCon_RDR, arityDataCon_RDR, selName_RDR,
561 prefixDataCon_RDR, infixDataCon_RDR, leftAssocDataCon_RDR,
562 rightAssocDataCon_RDR, notAssocDataCon_RDR :: RdrName
564 --v1DataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "V1")
565 u1DataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "U1")
566 par1DataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Par1")
567 rec1DataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Rec1")
568 k1DataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "K1")
569 m1DataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "M1")
571 l1DataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "L1")
572 r1DataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "R1")
574 prodDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit ":*:")
575 comp1DataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Comp1")
577 from0_RDR = varQual_RDR gHC_GENERICS (fsLit "from0")
578 from1_RDR = varQual_RDR gHC_GENERICS (fsLit "from1")
579 to0_RDR = varQual_RDR gHC_GENERICS (fsLit "to0")
580 to1_RDR = varQual_RDR gHC_GENERICS (fsLit "to1")
582 datatypeName_RDR = varQual_RDR gHC_GENERICS (fsLit "datatypeName")
583 moduleName_RDR = varQual_RDR gHC_GENERICS (fsLit "moduleName")
584 selName_RDR = varQual_RDR gHC_GENERICS (fsLit "selName")
585 conName_RDR = varQual_RDR gHC_GENERICS (fsLit "conName")
586 conFixity_RDR = varQual_RDR gHC_GENERICS (fsLit "conFixity")
587 conIsRecord_RDR = varQual_RDR gHC_GENERICS (fsLit "conIsRecord")
589 noArityDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "NoArity")
590 arityDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Arity")
591 prefixDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Prefix")
592 infixDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Infix")
593 leftAssocDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "LeftAssociative")
594 rightAssocDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "RightAssociative")
595 notAssocDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "NotAssociative")
598 fmap_RDR, pure_RDR, ap_RDR, foldable_foldr_RDR, traverse_RDR :: RdrName
599 fmap_RDR = varQual_RDR gHC_BASE (fsLit "fmap")
600 pure_RDR = varQual_RDR cONTROL_APPLICATIVE (fsLit "pure")
601 ap_RDR = varQual_RDR cONTROL_APPLICATIVE (fsLit "<*>")
602 foldable_foldr_RDR = varQual_RDR dATA_FOLDABLE (fsLit "foldr")
603 traverse_RDR = varQual_RDR dATA_TRAVERSABLE (fsLit "traverse")
605 ----------------------
606 varQual_RDR, tcQual_RDR, clsQual_RDR, dataQual_RDR
607 :: Module -> FastString -> RdrName
608 varQual_RDR mod str = mkOrig mod (mkOccNameFS varName str)
609 tcQual_RDR mod str = mkOrig mod (mkOccNameFS tcName str)
610 clsQual_RDR mod str = mkOrig mod (mkOccNameFS clsName str)
611 dataQual_RDR mod str = mkOrig mod (mkOccNameFS dataName str)
614 %************************************************************************
616 \subsection{Known-key names}
618 %************************************************************************
620 Many of these Names are not really "built in", but some parts of the
621 compiler (notably the deriving mechanism) need to mention their names,
622 and it's convenient to write them all down in one place.
624 --MetaHaskell Extension add the constrs and the lower case case
625 -- guys as well (perhaps) e.g. see trueDataConName below
630 wildCardName = mkSystemVarName wildCardKey (fsLit "wild")
632 runMainIOName :: Name
633 runMainIOName = varQual gHC_TOP_HANDLER (fsLit "runMainIO") runMainKey
635 orderingTyConName :: Name
636 orderingTyConName = tcQual gHC_ORDERING (fsLit "Ordering") orderingTyConKey
638 eitherTyConName, leftDataConName, rightDataConName :: Name
639 eitherTyConName = tcQual dATA_EITHER (fsLit "Either") eitherTyConKey
640 leftDataConName = conName dATA_EITHER (fsLit "Left") leftDataConKey
641 rightDataConName = conName dATA_EITHER (fsLit "Right") rightDataConKey
643 -- Old Generics (types)
644 crossTyConName, plusTyConName, genUnitTyConName :: Name
645 crossTyConName = tcQual gHC_GENERICS (fsLit ":*:") crossTyConKey
646 plusTyConName = tcQual gHC_GENERICS (fsLit ":+:") plusTyConKey
647 genUnitTyConName = tcQual gHC_GENERICS (fsLit "Unit") genUnitTyConKey
650 v1TyConName, u1TyConName, par1TyConName, rec1TyConName,
651 k1TyConName, m1TyConName, sumTyConName, prodTyConName,
652 compTyConName, rTyConName, pTyConName, dTyConName,
653 cTyConName, sTyConName, rec0TyConName, par0TyConName,
654 d1TyConName, c1TyConName, s1TyConName, noSelTyConName,
655 rep0TyConName, rep1TyConName :: Name
657 v1TyConName = tcQual gHC_GENERICS (fsLit "V1") v1TyConKey
658 u1TyConName = tcQual gHC_GENERICS (fsLit "U1") u1TyConKey
659 par1TyConName = tcQual gHC_GENERICS (fsLit "Par1") par1TyConKey
660 rec1TyConName = tcQual gHC_GENERICS (fsLit "Rec1") rec1TyConKey
661 k1TyConName = tcQual gHC_GENERICS (fsLit "K1") k1TyConKey
662 m1TyConName = tcQual gHC_GENERICS (fsLit "M1") m1TyConKey
664 sumTyConName = tcQual gHC_GENERICS (fsLit ":+:") sumTyConKey
665 prodTyConName = tcQual gHC_GENERICS (fsLit ":*:") prodTyConKey
666 compTyConName = tcQual gHC_GENERICS (fsLit ":.:") compTyConKey
668 rTyConName = tcQual gHC_GENERICS (fsLit "R") rTyConKey
669 pTyConName = tcQual gHC_GENERICS (fsLit "P") pTyConKey
670 dTyConName = tcQual gHC_GENERICS (fsLit "D") dTyConKey
671 cTyConName = tcQual gHC_GENERICS (fsLit "C") cTyConKey
672 sTyConName = tcQual gHC_GENERICS (fsLit "S") sTyConKey
674 rec0TyConName = tcQual gHC_GENERICS (fsLit "Rec0") rec0TyConKey
675 par0TyConName = tcQual gHC_GENERICS (fsLit "Par0") par0TyConKey
676 d1TyConName = tcQual gHC_GENERICS (fsLit "D1") d1TyConKey
677 c1TyConName = tcQual gHC_GENERICS (fsLit "C1") c1TyConKey
678 s1TyConName = tcQual gHC_GENERICS (fsLit "S1") s1TyConKey
679 noSelTyConName = tcQual gHC_GENERICS (fsLit "NoSelector") noSelTyConKey
681 rep0TyConName = tcQual gHC_GENERICS (fsLit "Rep0") rep0TyConKey
682 rep1TyConName = tcQual gHC_GENERICS (fsLit "Rep1") rep1TyConKey
684 -- Base strings Strings
685 unpackCStringName, unpackCStringAppendName, unpackCStringFoldrName,
686 unpackCStringUtf8Name, eqStringName, stringTyConName :: Name
687 unpackCStringName = varQual gHC_CSTRING (fsLit "unpackCString#") unpackCStringIdKey
688 unpackCStringAppendName = varQual gHC_CSTRING (fsLit "unpackAppendCString#") unpackCStringAppendIdKey
689 unpackCStringFoldrName = varQual gHC_CSTRING (fsLit "unpackFoldrCString#") unpackCStringFoldrIdKey
690 unpackCStringUtf8Name = varQual gHC_CSTRING (fsLit "unpackCStringUtf8#") unpackCStringUtf8IdKey
691 eqStringName = varQual gHC_BASE (fsLit "eqString") eqStringIdKey
692 stringTyConName = tcQual gHC_BASE (fsLit "String") stringTyConKey
694 -- The 'inline' function
696 inlineIdName = varQual gHC_MAGIC (fsLit "inline") inlineIdKey
698 -- Base classes (Eq, Ord, Functor)
699 eqClassName, eqName, ordClassName, geName, functorClassName :: Name
700 eqClassName = clsQual gHC_CLASSES (fsLit "Eq") eqClassKey
701 eqName = methName gHC_CLASSES (fsLit "==") eqClassOpKey
702 ordClassName = clsQual gHC_CLASSES (fsLit "Ord") ordClassKey
703 geName = methName gHC_CLASSES (fsLit ">=") geClassOpKey
704 functorClassName = clsQual gHC_BASE (fsLit "Functor") functorClassKey
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 Representable0 and Representable1, Datatype, Constructor and Selector
858 rep0ClassName, rep1ClassName, datatypeClassName, constructorClassName,
859 selectorClassName :: Name
860 rep0ClassName = clsQual gHC_GENERICS (fsLit "Representable0") rep0ClassKey
861 rep1ClassName = clsQual gHC_GENERICS (fsLit "Representable1") rep1ClassKey
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 -- Annotation type checking
947 toAnnotationWrapperName :: Name
948 toAnnotationWrapperName = varQual gHC_DESUGAR (fsLit "toAnnotationWrapper") toAnnotationWrapperIdKey
950 -- Other classes, needed for type defaulting
951 monadPlusClassName, randomClassName, randomGenClassName,
952 isStringClassName :: Name
953 monadPlusClassName = clsQual mONAD (fsLit "MonadPlus") monadPlusClassKey
954 randomClassName = clsQual rANDOM (fsLit "Random") randomClassKey
955 randomGenClassName = clsQual rANDOM (fsLit "RandomGen") randomGenClassKey
956 isStringClassName = clsQual dATA_STRING (fsLit "IsString") isStringClassKey
959 objectTyConName :: Name
960 objectTyConName = tcQual dOTNET (fsLit "Object") objectTyConKey
961 -- objectTyConName was "wTcQual", but that's gone now, and
962 -- I can't see why it was wired in anyway...
963 unmarshalObjectName, marshalObjectName, marshalStringName,
964 unmarshalStringName, checkDotnetResName :: Name
965 unmarshalObjectName = varQual dOTNET (fsLit "unmarshalObject") unmarshalObjectIdKey
966 marshalObjectName = varQual dOTNET (fsLit "marshalObject") marshalObjectIdKey
967 marshalStringName = varQual dOTNET (fsLit "marshalString") marshalStringIdKey
968 unmarshalStringName = varQual dOTNET (fsLit "unmarshalString") unmarshalStringIdKey
969 checkDotnetResName = varQual dOTNET (fsLit "checkResult") checkDotnetResNameIdKey
972 %************************************************************************
974 \subsection{Local helpers}
976 %************************************************************************
978 All these are original names; hence mkOrig
981 varQual, tcQual, clsQual :: Module -> FastString -> Unique -> Name
982 varQual = mk_known_key_name varName
983 tcQual = mk_known_key_name tcName
984 clsQual = mk_known_key_name clsName
986 mk_known_key_name :: NameSpace -> Module -> FastString -> Unique -> Name
987 mk_known_key_name space modu str unique
988 = mkExternalName unique modu (mkOccNameFS space str) noSrcSpan
990 conName :: Module -> FastString -> Unique -> Name
991 conName modu occ unique
992 = mkExternalName unique modu (mkOccNameFS dataName occ) noSrcSpan
994 methName :: Module -> FastString -> Unique -> Name
995 methName modu occ unique
996 = mkExternalName unique modu (mkVarOccFS occ) noSrcSpan
999 %************************************************************************
1001 \subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@}
1003 %************************************************************************
1004 --MetaHaskell extension hand allocate keys here
1007 boundedClassKey, enumClassKey, eqClassKey, floatingClassKey,
1008 fractionalClassKey, integralClassKey, monadClassKey, dataClassKey,
1009 functorClassKey, numClassKey, ordClassKey, readClassKey, realClassKey,
1010 realFloatClassKey, realFracClassKey, showClassKey, ixClassKey :: Unique
1011 boundedClassKey = mkPreludeClassUnique 1
1012 enumClassKey = mkPreludeClassUnique 2
1013 eqClassKey = mkPreludeClassUnique 3
1014 floatingClassKey = mkPreludeClassUnique 5
1015 fractionalClassKey = mkPreludeClassUnique 6
1016 integralClassKey = mkPreludeClassUnique 7
1017 monadClassKey = mkPreludeClassUnique 8
1018 dataClassKey = mkPreludeClassUnique 9
1019 functorClassKey = mkPreludeClassUnique 10
1020 numClassKey = mkPreludeClassUnique 11
1021 ordClassKey = mkPreludeClassUnique 12
1022 readClassKey = mkPreludeClassUnique 13
1023 realClassKey = mkPreludeClassUnique 14
1024 realFloatClassKey = mkPreludeClassUnique 15
1025 realFracClassKey = mkPreludeClassUnique 16
1026 showClassKey = mkPreludeClassUnique 17
1027 ixClassKey = mkPreludeClassUnique 18
1029 typeableClassKey, typeable1ClassKey, typeable2ClassKey, typeable3ClassKey,
1030 typeable4ClassKey, typeable5ClassKey, typeable6ClassKey, typeable7ClassKey
1032 typeableClassKey = mkPreludeClassUnique 20
1033 typeable1ClassKey = mkPreludeClassUnique 21
1034 typeable2ClassKey = mkPreludeClassUnique 22
1035 typeable3ClassKey = mkPreludeClassUnique 23
1036 typeable4ClassKey = mkPreludeClassUnique 24
1037 typeable5ClassKey = mkPreludeClassUnique 25
1038 typeable6ClassKey = mkPreludeClassUnique 26
1039 typeable7ClassKey = mkPreludeClassUnique 27
1041 monadFixClassKey :: Unique
1042 monadFixClassKey = mkPreludeClassUnique 28
1044 monadPlusClassKey, randomClassKey, randomGenClassKey :: Unique
1045 monadPlusClassKey = mkPreludeClassUnique 30
1046 randomClassKey = mkPreludeClassUnique 31
1047 randomGenClassKey = mkPreludeClassUnique 32
1049 isStringClassKey :: Unique
1050 isStringClassKey = mkPreludeClassUnique 33
1052 applicativeClassKey, foldableClassKey, traversableClassKey :: Unique
1053 applicativeClassKey = mkPreludeClassUnique 34
1054 foldableClassKey = mkPreludeClassUnique 35
1055 traversableClassKey = mkPreludeClassUnique 36
1057 rep0ClassKey, rep1ClassKey, datatypeClassKey, constructorClassKey,
1058 selectorClassKey :: Unique
1059 rep0ClassKey = mkPreludeClassUnique 37
1060 rep1ClassKey = mkPreludeClassUnique 38
1062 datatypeClassKey = mkPreludeClassUnique 39
1063 constructorClassKey = mkPreludeClassUnique 40
1064 selectorClassKey = mkPreludeClassUnique 41
1067 %************************************************************************
1069 \subsubsection[Uniques-prelude-TyCons]{@Uniques@ for wired-in @TyCons@}
1071 %************************************************************************
1074 addrPrimTyConKey, arrayPrimTyConKey, boolTyConKey, byteArrayPrimTyConKey,
1075 charPrimTyConKey, charTyConKey, doublePrimTyConKey, doubleTyConKey,
1076 floatPrimTyConKey, floatTyConKey, funTyConKey, intPrimTyConKey,
1077 intTyConKey, int8TyConKey, int16TyConKey, int32PrimTyConKey,
1078 int32TyConKey, int64PrimTyConKey, int64TyConKey, integerTyConKey,
1079 listTyConKey, foreignObjPrimTyConKey, weakPrimTyConKey,
1080 mutableArrayPrimTyConKey, mutableByteArrayPrimTyConKey,
1081 orderingTyConKey, mVarPrimTyConKey, ratioTyConKey, rationalTyConKey,
1082 realWorldTyConKey, stablePtrPrimTyConKey, stablePtrTyConKey,
1083 anyTyConKey :: Unique
1084 addrPrimTyConKey = mkPreludeTyConUnique 1
1085 arrayPrimTyConKey = mkPreludeTyConUnique 3
1086 boolTyConKey = mkPreludeTyConUnique 4
1087 byteArrayPrimTyConKey = mkPreludeTyConUnique 5
1088 charPrimTyConKey = mkPreludeTyConUnique 7
1089 charTyConKey = mkPreludeTyConUnique 8
1090 doublePrimTyConKey = mkPreludeTyConUnique 9
1091 doubleTyConKey = mkPreludeTyConUnique 10
1092 floatPrimTyConKey = mkPreludeTyConUnique 11
1093 floatTyConKey = mkPreludeTyConUnique 12
1094 funTyConKey = mkPreludeTyConUnique 13
1095 intPrimTyConKey = mkPreludeTyConUnique 14
1096 intTyConKey = mkPreludeTyConUnique 15
1097 int8TyConKey = mkPreludeTyConUnique 16
1098 int16TyConKey = mkPreludeTyConUnique 17
1099 int32PrimTyConKey = mkPreludeTyConUnique 18
1100 int32TyConKey = mkPreludeTyConUnique 19
1101 int64PrimTyConKey = mkPreludeTyConUnique 20
1102 int64TyConKey = mkPreludeTyConUnique 21
1103 integerTyConKey = mkPreludeTyConUnique 22
1104 listTyConKey = mkPreludeTyConUnique 23
1105 foreignObjPrimTyConKey = mkPreludeTyConUnique 24
1106 weakPrimTyConKey = mkPreludeTyConUnique 27
1107 mutableArrayPrimTyConKey = mkPreludeTyConUnique 28
1108 mutableByteArrayPrimTyConKey = mkPreludeTyConUnique 29
1109 orderingTyConKey = mkPreludeTyConUnique 30
1110 mVarPrimTyConKey = mkPreludeTyConUnique 31
1111 ratioTyConKey = mkPreludeTyConUnique 32
1112 rationalTyConKey = mkPreludeTyConUnique 33
1113 realWorldTyConKey = mkPreludeTyConUnique 34
1114 stablePtrPrimTyConKey = mkPreludeTyConUnique 35
1115 stablePtrTyConKey = mkPreludeTyConUnique 36
1116 anyTyConKey = mkPreludeTyConUnique 37
1118 statePrimTyConKey, stableNamePrimTyConKey, stableNameTyConKey,
1119 mutVarPrimTyConKey, ioTyConKey,
1120 wordPrimTyConKey, wordTyConKey, word8TyConKey, word16TyConKey,
1121 word32PrimTyConKey, word32TyConKey, word64PrimTyConKey, word64TyConKey,
1122 liftedConKey, unliftedConKey, anyBoxConKey, kindConKey, boxityConKey,
1123 typeConKey, threadIdPrimTyConKey, bcoPrimTyConKey, ptrTyConKey,
1124 funPtrTyConKey, tVarPrimTyConKey :: Unique
1125 statePrimTyConKey = mkPreludeTyConUnique 50
1126 stableNamePrimTyConKey = mkPreludeTyConUnique 51
1127 stableNameTyConKey = mkPreludeTyConUnique 52
1128 mutVarPrimTyConKey = mkPreludeTyConUnique 55
1129 ioTyConKey = mkPreludeTyConUnique 56
1130 wordPrimTyConKey = mkPreludeTyConUnique 58
1131 wordTyConKey = mkPreludeTyConUnique 59
1132 word8TyConKey = mkPreludeTyConUnique 60
1133 word16TyConKey = mkPreludeTyConUnique 61
1134 word32PrimTyConKey = mkPreludeTyConUnique 62
1135 word32TyConKey = mkPreludeTyConUnique 63
1136 word64PrimTyConKey = mkPreludeTyConUnique 64
1137 word64TyConKey = mkPreludeTyConUnique 65
1138 liftedConKey = mkPreludeTyConUnique 66
1139 unliftedConKey = mkPreludeTyConUnique 67
1140 anyBoxConKey = mkPreludeTyConUnique 68
1141 kindConKey = mkPreludeTyConUnique 69
1142 boxityConKey = mkPreludeTyConUnique 70
1143 typeConKey = mkPreludeTyConUnique 71
1144 threadIdPrimTyConKey = mkPreludeTyConUnique 72
1145 bcoPrimTyConKey = mkPreludeTyConUnique 73
1146 ptrTyConKey = mkPreludeTyConUnique 74
1147 funPtrTyConKey = mkPreludeTyConUnique 75
1148 tVarPrimTyConKey = mkPreludeTyConUnique 76
1150 -- Old Generic Type Constructors
1151 crossTyConKey, plusTyConKey, genUnitTyConKey :: Unique
1152 crossTyConKey = mkPreludeTyConUnique 79
1153 plusTyConKey = mkPreludeTyConUnique 80
1154 genUnitTyConKey = mkPreludeTyConUnique 81
1156 -- Parallel array type constructor
1157 parrTyConKey :: Unique
1158 parrTyConKey = mkPreludeTyConUnique 82
1161 objectTyConKey :: Unique
1162 objectTyConKey = mkPreludeTyConUnique 83
1164 eitherTyConKey :: Unique
1165 eitherTyConKey = mkPreludeTyConUnique 84
1167 -- Super Kinds constructors
1168 tySuperKindTyConKey, coSuperKindTyConKey :: Unique
1169 tySuperKindTyConKey = mkPreludeTyConUnique 85
1170 coSuperKindTyConKey = mkPreludeTyConUnique 86
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 rep0TyConKey, 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 rep0TyConKey = 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 -- Parallel array functions
1395 singletonPIdKey, nullPIdKey, lengthPIdKey, replicatePIdKey, mapPIdKey,
1396 filterPIdKey, zipPIdKey, crossMapPIdKey, indexPIdKey, toPIdKey,
1397 enumFromToPIdKey, enumFromThenToPIdKey, emptyPIdKey, appPIdKey :: Unique
1398 singletonPIdKey = mkPreludeMiscIdUnique 79
1399 nullPIdKey = mkPreludeMiscIdUnique 80
1400 lengthPIdKey = mkPreludeMiscIdUnique 81
1401 replicatePIdKey = mkPreludeMiscIdUnique 82
1402 mapPIdKey = mkPreludeMiscIdUnique 83
1403 filterPIdKey = mkPreludeMiscIdUnique 84
1404 zipPIdKey = mkPreludeMiscIdUnique 85
1405 crossMapPIdKey = mkPreludeMiscIdUnique 86
1406 indexPIdKey = mkPreludeMiscIdUnique 87
1407 toPIdKey = mkPreludeMiscIdUnique 88
1408 enumFromToPIdKey = mkPreludeMiscIdUnique 89
1409 enumFromThenToPIdKey = mkPreludeMiscIdUnique 90
1410 emptyPIdKey = mkPreludeMiscIdUnique 91
1411 appPIdKey = mkPreludeMiscIdUnique 92
1414 unmarshalObjectIdKey, marshalObjectIdKey, marshalStringIdKey,
1415 unmarshalStringIdKey, checkDotnetResNameIdKey :: Unique
1416 unmarshalObjectIdKey = mkPreludeMiscIdUnique 94
1417 marshalObjectIdKey = mkPreludeMiscIdUnique 95
1418 marshalStringIdKey = mkPreludeMiscIdUnique 96
1419 unmarshalStringIdKey = mkPreludeMiscIdUnique 97
1420 checkDotnetResNameIdKey = mkPreludeMiscIdUnique 98
1424 Certain class operations from Prelude classes. They get their own
1425 uniques so we can look them up easily when we want to conjure them up
1426 during type checking.
1429 -- Just a place holder for unbound variables produced by the renamer:
1430 unboundKey :: Unique
1431 unboundKey = mkPreludeMiscIdUnique 101
1433 fromIntegerClassOpKey, minusClassOpKey, fromRationalClassOpKey,
1434 enumFromClassOpKey, enumFromThenClassOpKey, enumFromToClassOpKey,
1435 enumFromThenToClassOpKey, eqClassOpKey, geClassOpKey, negateClassOpKey,
1436 failMClassOpKey, bindMClassOpKey, thenMClassOpKey, returnMClassOpKey
1438 fromIntegerClassOpKey = mkPreludeMiscIdUnique 102
1439 minusClassOpKey = mkPreludeMiscIdUnique 103
1440 fromRationalClassOpKey = mkPreludeMiscIdUnique 104
1441 enumFromClassOpKey = mkPreludeMiscIdUnique 105
1442 enumFromThenClassOpKey = mkPreludeMiscIdUnique 106
1443 enumFromToClassOpKey = mkPreludeMiscIdUnique 107
1444 enumFromThenToClassOpKey = mkPreludeMiscIdUnique 108
1445 eqClassOpKey = mkPreludeMiscIdUnique 109
1446 geClassOpKey = mkPreludeMiscIdUnique 110
1447 negateClassOpKey = mkPreludeMiscIdUnique 111
1448 failMClassOpKey = mkPreludeMiscIdUnique 112
1449 bindMClassOpKey = mkPreludeMiscIdUnique 113 -- (>>=)
1450 thenMClassOpKey = mkPreludeMiscIdUnique 114 -- (>>)
1451 returnMClassOpKey = mkPreludeMiscIdUnique 117
1453 -- Recursive do notation
1455 mfixIdKey = mkPreludeMiscIdUnique 118
1458 arrAIdKey, composeAIdKey, firstAIdKey, appAIdKey, choiceAIdKey,
1459 loopAIdKey :: Unique
1460 arrAIdKey = mkPreludeMiscIdUnique 119
1461 composeAIdKey = mkPreludeMiscIdUnique 120 -- >>>
1462 firstAIdKey = mkPreludeMiscIdUnique 121
1463 appAIdKey = mkPreludeMiscIdUnique 122
1464 choiceAIdKey = mkPreludeMiscIdUnique 123 -- |||
1465 loopAIdKey = mkPreludeMiscIdUnique 124
1467 fromStringClassOpKey :: Unique
1468 fromStringClassOpKey = mkPreludeMiscIdUnique 125
1470 -- Annotation type checking
1471 toAnnotationWrapperIdKey :: Unique
1472 toAnnotationWrapperIdKey = mkPreludeMiscIdUnique 126
1474 -- Conversion functions
1475 fromIntegralIdKey, realToFracIdKey, toIntegerClassOpKey, toRationalClassOpKey :: Unique
1476 fromIntegralIdKey = mkPreludeMiscIdUnique 127
1477 realToFracIdKey = mkPreludeMiscIdUnique 128
1478 toIntegerClassOpKey = mkPreludeMiscIdUnique 129
1479 toRationalClassOpKey = mkPreludeMiscIdUnique 130
1481 ---------------- Template Haskell -------------------
1482 -- USES IdUniques 200-499
1483 -----------------------------------------------------
1487 %************************************************************************
1489 \subsection{Standard groups of types}
1491 %************************************************************************
1494 numericTyKeys :: [Unique]
1503 kindKeys :: [Unique]
1504 kindKeys = [ liftedTypeKindTyConKey
1505 , openTypeKindTyConKey
1506 , unliftedTypeKindTyConKey
1507 , ubxTupleKindTyConKey
1508 , argTypeKindTyConKey ]
1512 %************************************************************************
1514 \subsection[Class-std-groups]{Standard groups of Prelude classes}
1516 %************************************************************************
1518 NOTE: @Eq@ and @Text@ do need to appear in @standardClasses@
1519 even though every numeric class has these two as a superclass,
1520 because the list of ambiguous dictionaries hasn't been simplified.
1523 numericClassKeys :: [Unique]
1529 ++ fractionalClassKeys
1531 fractionalClassKeys :: [Unique]
1532 fractionalClassKeys =
1533 [ fractionalClassKey
1539 -- the strictness analyser needs to know about numeric types
1540 -- (see SaAbsInt.lhs)
1541 needsDataDeclCtxtClassKeys :: [Unique]
1542 needsDataDeclCtxtClassKeys = -- see comments in TcDeriv
1546 -- The "standard classes" are used in defaulting (Haskell 98 report 4.3.4),
1547 -- and are: "classes defined in the Prelude or a standard library"
1548 standardClassKeys :: [Unique]
1549 standardClassKeys = derivableClassKeys ++ numericClassKeys
1550 ++ [randomClassKey, randomGenClassKey,
1552 monadClassKey, monadPlusClassKey,
1554 applicativeClassKey, foldableClassKey, traversableClassKey
1558 @derivableClassKeys@ is also used in checking \tr{deriving} constructs
1562 derivableClassKeys :: [Unique]
1564 = [ eqClassKey, ordClassKey, enumClassKey, ixClassKey,
1565 boundedClassKey, showClassKey, readClassKey ]