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