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