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 assocation of
98 names with uniques. These ones are the *non* wired-in ones. The
99 wired in ones are defined in TysWiredIn etc.
101 The names for DPH can come from one of multiple backend packages. At the point where
102 'basicKnownKeyNames' is used, we don't know which backend it will be. Hence, we list
103 the names for multiple backends. That works out fine, although they use the same uniques,
104 as we are guaranteed to only load one backend; hence, only one of the different names
105 sharing a unique will be used.
108 basicKnownKeyNames :: [Name]
111 ++ typeableClassNames
112 ++ dphKnownKeyNames dphSeqPackageId ++ dphKnownKeyNames dphParPackageId
113 ++ [ -- Type constructors (synonyms especially)
114 ioTyConName, ioDataConName,
121 integerTyConName, smallIntegerName,
123 -- Classes. *Must* include:
124 -- classes that are grabbed by key (e.g., eqClassKey)
125 -- classes in "Class.standardClassKeys" (quite a few)
126 eqClassName, -- mentioned, derivable
127 ordClassName, -- derivable
128 boundedClassName, -- derivable
129 numClassName, -- mentioned, numeric
130 enumClassName, -- derivable
133 realClassName, -- numeric
134 integralClassName, -- numeric
135 fractionalClassName, -- numeric
136 floatingClassName, -- numeric
137 realFracClassName, -- numeric
138 realFloatClassName, -- numeric
141 applicativeClassName,
143 traversableClassName,
146 negateName, minusName, geName, eqName,
148 -- Conversion functions
149 fromRationalName, fromIntegerName,
150 toIntegerName, toRationalName,
151 fromIntegralName, realToFracName,
157 enumFromName, enumFromThenName,
158 enumFromThenToName, enumFromToName,
161 thenIOName, bindIOName, returnIOName, failIOName,
162 failMName, bindMName, thenMName, returnMName,
168 arrAName, composeAName, firstAName,
169 appAName, choiceAName, loopAName,
187 unpackCStringName, unpackCStringAppendName,
188 unpackCStringFoldrName, unpackCStringUtf8Name,
191 concatName, filterName, mapName,
192 zipName, foldrName, buildName, augmentName, appendName,
194 dollarName, -- The ($) apply function
196 -- FFI primitive types that are not wired-in.
197 stablePtrTyConName, ptrTyConName, funPtrTyConName,
198 int8TyConName, int16TyConName, int32TyConName, int64TyConName,
199 wordTyConName, word8TyConName, word16TyConName, word32TyConName, word64TyConName,
202 otherwiseIdName, inlineIdName,
203 plusIntegerName, timesIntegerName,
204 eqStringName, assertName, breakpointName, breakpointCondName,
205 breakpointAutoName, opaqueTyConName,
206 assertErrorName, runSTRepName,
207 printName, fstName, sndName,
210 monadFixClassName, mfixName,
213 randomClassName, randomGenClassName, monadPlusClassName,
216 hetmet_brak_name, hetmet_esc_name, hetmet_csp_name, hetmet_flatten_name, hetmet_unflatten_name, hetmet_flattened_id_name,
217 hetmet_guest_integer_literal_name, hetmet_guest_string_literal_name,
218 hetmet_guest_char_literal_name,
221 hetmet_pga_comp_name,
222 hetmet_pga_first_name,
223 hetmet_pga_second_name,
224 hetmet_pga_cancell_name,
225 hetmet_pga_cancelr_name,
226 hetmet_pga_uncancell_name,
227 hetmet_pga_uncancelr_name,
228 hetmet_pga_assoc_name,
229 hetmet_pga_unassoc_name,
230 hetmet_pga_copy_name,
231 hetmet_pga_drop_name,
232 hetmet_pga_swap_name,
233 hetmet_pga_applyl_name,
234 hetmet_pga_applyr_name,
235 hetmet_pga_curryl_name,
236 hetmet_pga_curryr_name,
238 -- Annotation type checking
239 toAnnotationWrapperName
242 , eitherTyConName, leftDataConName, rightDataConName
245 , objectTyConName, marshalObjectName, unmarshalObjectName
246 , marshalStringName, unmarshalStringName, checkDotnetResName
249 genericTyConNames :: [Name]
250 genericTyConNames = [crossTyConName, plusTyConName, genUnitTyConName]
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,
283 gHC_SHOW, gHC_READ, gHC_NUM, gHC_INTEGER, gHC_INTEGER_TYPE, gHC_LIST,
284 gHC_HETMET_CODETYPES,
286 gHC_TUPLE, dATA_TUPLE, dATA_EITHER, dATA_STRING, dATA_FOLDABLE, dATA_TRAVERSABLE,
287 gHC_PACK, gHC_CONC, gHC_IO, gHC_IO_Exception,
288 gHC_ST, gHC_ARR, gHC_STABLE, gHC_ADDR, gHC_PTR, gHC_ERR, gHC_REAL,
289 gHC_FLOAT, gHC_TOP_HANDLER, sYSTEM_IO, dYNAMIC, tYPEABLE, gENERICS,
290 dOTNET, rEAD_PREC, lEX, gHC_INT, gHC_WORD, mONAD, mONAD_FIX, aRROW, cONTROL_APPLICATIVE,
291 gHC_DESUGAR, rANDOM, gHC_EXTS, cONTROL_EXCEPTION_BASE :: Module
293 gHC_PRIM = mkPrimModule (fsLit "GHC.Prim") -- Primitive types and values
294 gHC_TYPES = mkPrimModule (fsLit "GHC.Types")
295 gHC_UNIT = mkPrimModule (fsLit "GHC.Unit")
296 gHC_ORDERING = mkPrimModule (fsLit "GHC.Ordering")
297 gHC_GENERICS = mkPrimModule (fsLit "GHC.Generics")
298 gHC_MAGIC = mkPrimModule (fsLit "GHC.Magic")
300 gHC_CLASSES = mkBaseModule (fsLit "GHC.Classes")
301 gHC_BASE = mkBaseModule (fsLit "GHC.Base")
302 gHC_ENUM = mkBaseModule (fsLit "GHC.Enum")
303 gHC_SHOW = mkBaseModule (fsLit "GHC.Show")
304 gHC_READ = mkBaseModule (fsLit "GHC.Read")
305 gHC_NUM = mkBaseModule (fsLit "GHC.Num")
306 gHC_INTEGER = mkIntegerModule (fsLit "GHC.Integer")
307 gHC_INTEGER_TYPE= mkIntegerModule (fsLit "GHC.Integer.Type")
308 gHC_HETMET_CODETYPES = mkBaseModule (fsLit "GHC.HetMet.CodeTypes")
309 gHC_HETMET_PRIVATE = mkBaseModule (fsLit "GHC.HetMet.Private")
310 gHC_LIST = mkBaseModule (fsLit "GHC.List")
311 gHC_TUPLE = mkPrimModule (fsLit "GHC.Tuple")
312 dATA_TUPLE = mkBaseModule (fsLit "Data.Tuple")
313 dATA_EITHER = mkBaseModule (fsLit "Data.Either")
314 dATA_STRING = mkBaseModule (fsLit "Data.String")
315 dATA_FOLDABLE = mkBaseModule (fsLit "Data.Foldable")
316 dATA_TRAVERSABLE= mkBaseModule (fsLit "Data.Traversable")
317 gHC_PACK = mkBaseModule (fsLit "GHC.Pack")
318 gHC_CONC = mkBaseModule (fsLit "GHC.Conc")
319 gHC_IO = mkBaseModule (fsLit "GHC.IO")
320 gHC_IO_Exception = mkBaseModule (fsLit "GHC.IO.Exception")
321 gHC_ST = mkBaseModule (fsLit "GHC.ST")
322 gHC_ARR = mkBaseModule (fsLit "GHC.Arr")
323 gHC_STABLE = mkBaseModule (fsLit "GHC.Stable")
324 gHC_ADDR = mkBaseModule (fsLit "GHC.Addr")
325 gHC_PTR = mkBaseModule (fsLit "GHC.Ptr")
326 gHC_ERR = mkBaseModule (fsLit "GHC.Err")
327 gHC_REAL = mkBaseModule (fsLit "GHC.Real")
328 gHC_FLOAT = mkBaseModule (fsLit "GHC.Float")
329 gHC_TOP_HANDLER = mkBaseModule (fsLit "GHC.TopHandler")
330 sYSTEM_IO = mkBaseModule (fsLit "System.IO")
331 dYNAMIC = mkBaseModule (fsLit "Data.Dynamic")
332 tYPEABLE = mkBaseModule (fsLit "Data.Typeable")
333 gENERICS = mkBaseModule (fsLit "Data.Data")
334 dOTNET = mkBaseModule (fsLit "GHC.Dotnet")
335 rEAD_PREC = mkBaseModule (fsLit "Text.ParserCombinators.ReadPrec")
336 lEX = mkBaseModule (fsLit "Text.Read.Lex")
337 gHC_INT = mkBaseModule (fsLit "GHC.Int")
338 gHC_WORD = mkBaseModule (fsLit "GHC.Word")
339 mONAD = mkBaseModule (fsLit "Control.Monad")
340 mONAD_FIX = mkBaseModule (fsLit "Control.Monad.Fix")
341 aRROW = mkBaseModule (fsLit "Control.Arrow")
342 cONTROL_APPLICATIVE = mkBaseModule (fsLit "Control.Applicative")
343 gHC_DESUGAR = mkBaseModule (fsLit "GHC.Desugar")
344 rANDOM = mkBaseModule (fsLit "System.Random")
345 gHC_EXTS = mkBaseModule (fsLit "GHC.Exts")
346 cONTROL_EXCEPTION_BASE = mkBaseModule (fsLit "Control.Exception.Base")
348 gHC_PARR :: PackageId -> Module
349 gHC_PARR pkg = mkModule pkg (mkModuleNameFS (fsLit "Data.Array.Parallel"))
352 gHC_PARR' = mkBaseModule (fsLit "GHC.PArr")
354 mAIN, rOOT_MAIN :: Module
355 mAIN = mkMainModule_ mAIN_NAME
356 rOOT_MAIN = mkMainModule (fsLit ":Main") -- Root module for initialisation
358 -- The ':xxx' makes a module name that the user can never
359 -- use himself. The z-encoding for ':' is "ZC", so the z-encoded
360 -- module name still starts with a capital letter, which keeps
361 -- the z-encoded version consistent.
362 iNTERACTIVE :: Module
363 iNTERACTIVE = mkMainModule (fsLit ":Interactive")
365 pRELUDE_NAME, mAIN_NAME :: ModuleName
366 pRELUDE_NAME = mkModuleNameFS (fsLit "Prelude")
367 mAIN_NAME = mkModuleNameFS (fsLit "Main")
369 mkPrimModule :: FastString -> Module
370 mkPrimModule m = mkModule primPackageId (mkModuleNameFS m)
372 mkIntegerModule :: FastString -> Module
373 mkIntegerModule m = mkModule integerPackageId (mkModuleNameFS m)
375 mkBaseModule :: FastString -> Module
376 mkBaseModule m = mkModule basePackageId (mkModuleNameFS m)
378 mkBaseModule_ :: ModuleName -> Module
379 mkBaseModule_ m = mkModule basePackageId m
381 mkMainModule :: FastString -> Module
382 mkMainModule m = mkModule mainPackageId (mkModuleNameFS m)
384 mkMainModule_ :: ModuleName -> Module
385 mkMainModule_ m = mkModule mainPackageId m
388 %************************************************************************
390 \subsection{Constructing the names of tuples
392 %************************************************************************
395 mkTupleModule :: Boxity -> Arity -> Module
396 mkTupleModule Boxed 0 = gHC_UNIT
397 mkTupleModule Boxed _ = gHC_TUPLE
398 mkTupleModule Unboxed _ = gHC_PRIM
402 %************************************************************************
406 %************************************************************************
409 main_RDR_Unqual :: RdrName
410 main_RDR_Unqual = mkUnqual varName (fsLit "main")
411 -- We definitely don't want an Orig RdrName, because
412 -- main might, in principle, be imported into module Main
414 forall_tv_RDR, dot_tv_RDR :: RdrName
415 forall_tv_RDR = mkUnqual tvName (fsLit "forall")
416 dot_tv_RDR = mkUnqual tvName (fsLit ".")
418 eq_RDR, ge_RDR, ne_RDR, le_RDR, lt_RDR, gt_RDR, compare_RDR,
419 ltTag_RDR, eqTag_RDR, gtTag_RDR :: RdrName
420 eq_RDR = nameRdrName eqName
421 ge_RDR = nameRdrName geName
422 ne_RDR = varQual_RDR gHC_CLASSES (fsLit "/=")
423 le_RDR = varQual_RDR gHC_CLASSES (fsLit "<=")
424 lt_RDR = varQual_RDR gHC_CLASSES (fsLit "<")
425 gt_RDR = varQual_RDR gHC_CLASSES (fsLit ">")
426 compare_RDR = varQual_RDR gHC_CLASSES (fsLit "compare")
427 ltTag_RDR = dataQual_RDR gHC_ORDERING (fsLit "LT")
428 eqTag_RDR = dataQual_RDR gHC_ORDERING (fsLit "EQ")
429 gtTag_RDR = dataQual_RDR gHC_ORDERING (fsLit "GT")
431 eqClass_RDR, numClass_RDR, ordClass_RDR, enumClass_RDR, monadClass_RDR
433 eqClass_RDR = nameRdrName eqClassName
434 numClass_RDR = nameRdrName numClassName
435 ordClass_RDR = nameRdrName ordClassName
436 enumClass_RDR = nameRdrName enumClassName
437 monadClass_RDR = nameRdrName monadClassName
439 map_RDR, append_RDR :: RdrName
440 map_RDR = varQual_RDR gHC_BASE (fsLit "map")
441 append_RDR = varQual_RDR gHC_BASE (fsLit "++")
443 foldr_RDR, build_RDR, returnM_RDR, bindM_RDR, failM_RDR :: RdrName
444 foldr_RDR = nameRdrName foldrName
445 build_RDR = nameRdrName buildName
446 returnM_RDR = nameRdrName returnMName
447 bindM_RDR = nameRdrName bindMName
448 failM_RDR = nameRdrName failMName
450 left_RDR, right_RDR :: RdrName
451 left_RDR = nameRdrName leftDataConName
452 right_RDR = nameRdrName rightDataConName
454 fromEnum_RDR, toEnum_RDR :: RdrName
455 fromEnum_RDR = varQual_RDR gHC_ENUM (fsLit "fromEnum")
456 toEnum_RDR = varQual_RDR gHC_ENUM (fsLit "toEnum")
458 enumFrom_RDR, enumFromTo_RDR, enumFromThen_RDR, enumFromThenTo_RDR :: RdrName
459 enumFrom_RDR = nameRdrName enumFromName
460 enumFromTo_RDR = nameRdrName enumFromToName
461 enumFromThen_RDR = nameRdrName enumFromThenName
462 enumFromThenTo_RDR = nameRdrName enumFromThenToName
464 ratioDataCon_RDR, plusInteger_RDR, timesInteger_RDR :: RdrName
465 ratioDataCon_RDR = nameRdrName ratioDataConName
466 plusInteger_RDR = nameRdrName plusIntegerName
467 timesInteger_RDR = nameRdrName timesIntegerName
469 ioDataCon_RDR :: RdrName
470 ioDataCon_RDR = nameRdrName ioDataConName
472 eqString_RDR, unpackCString_RDR, unpackCStringFoldr_RDR,
473 unpackCStringUtf8_RDR :: RdrName
474 eqString_RDR = nameRdrName eqStringName
475 unpackCString_RDR = nameRdrName unpackCStringName
476 unpackCStringFoldr_RDR = nameRdrName unpackCStringFoldrName
477 unpackCStringUtf8_RDR = nameRdrName unpackCStringUtf8Name
479 newStablePtr_RDR, wordDataCon_RDR :: RdrName
480 newStablePtr_RDR = nameRdrName newStablePtrName
481 wordDataCon_RDR = dataQual_RDR gHC_WORD (fsLit "W#")
483 bindIO_RDR, returnIO_RDR :: RdrName
484 bindIO_RDR = nameRdrName bindIOName
485 returnIO_RDR = nameRdrName returnIOName
487 fromInteger_RDR, fromRational_RDR, minus_RDR, times_RDR, plus_RDR :: RdrName
488 fromInteger_RDR = nameRdrName fromIntegerName
489 fromRational_RDR = nameRdrName fromRationalName
490 minus_RDR = nameRdrName minusName
491 times_RDR = varQual_RDR gHC_NUM (fsLit "*")
492 plus_RDR = varQual_RDR gHC_NUM (fsLit "+")
494 fromString_RDR :: RdrName
495 fromString_RDR = nameRdrName fromStringName
497 compose_RDR :: RdrName
498 compose_RDR = varQual_RDR gHC_BASE (fsLit ".")
500 not_RDR, getTag_RDR, succ_RDR, pred_RDR, minBound_RDR, maxBound_RDR,
501 and_RDR, range_RDR, inRange_RDR, index_RDR,
502 unsafeIndex_RDR, unsafeRangeSize_RDR :: RdrName
503 and_RDR = varQual_RDR gHC_CLASSES (fsLit "&&")
504 not_RDR = varQual_RDR gHC_CLASSES (fsLit "not")
505 getTag_RDR = varQual_RDR gHC_BASE (fsLit "getTag")
506 succ_RDR = varQual_RDR gHC_ENUM (fsLit "succ")
507 pred_RDR = varQual_RDR gHC_ENUM (fsLit "pred")
508 minBound_RDR = varQual_RDR gHC_ENUM (fsLit "minBound")
509 maxBound_RDR = varQual_RDR gHC_ENUM (fsLit "maxBound")
510 range_RDR = varQual_RDR gHC_ARR (fsLit "range")
511 inRange_RDR = varQual_RDR gHC_ARR (fsLit "inRange")
512 index_RDR = varQual_RDR gHC_ARR (fsLit "index")
513 unsafeIndex_RDR = varQual_RDR gHC_ARR (fsLit "unsafeIndex")
514 unsafeRangeSize_RDR = varQual_RDR gHC_ARR (fsLit "unsafeRangeSize")
516 readList_RDR, readListDefault_RDR, readListPrec_RDR, readListPrecDefault_RDR,
517 readPrec_RDR, parens_RDR, choose_RDR, lexP_RDR :: RdrName
518 readList_RDR = varQual_RDR gHC_READ (fsLit "readList")
519 readListDefault_RDR = varQual_RDR gHC_READ (fsLit "readListDefault")
520 readListPrec_RDR = varQual_RDR gHC_READ (fsLit "readListPrec")
521 readListPrecDefault_RDR = varQual_RDR gHC_READ (fsLit "readListPrecDefault")
522 readPrec_RDR = varQual_RDR gHC_READ (fsLit "readPrec")
523 parens_RDR = varQual_RDR gHC_READ (fsLit "parens")
524 choose_RDR = varQual_RDR gHC_READ (fsLit "choose")
525 lexP_RDR = varQual_RDR gHC_READ (fsLit "lexP")
527 punc_RDR, ident_RDR, symbol_RDR :: RdrName
528 punc_RDR = dataQual_RDR lEX (fsLit "Punc")
529 ident_RDR = dataQual_RDR lEX (fsLit "Ident")
530 symbol_RDR = dataQual_RDR lEX (fsLit "Symbol")
532 step_RDR, alt_RDR, reset_RDR, prec_RDR :: RdrName
533 step_RDR = varQual_RDR rEAD_PREC (fsLit "step")
534 alt_RDR = varQual_RDR rEAD_PREC (fsLit "+++")
535 reset_RDR = varQual_RDR rEAD_PREC (fsLit "reset")
536 prec_RDR = varQual_RDR rEAD_PREC (fsLit "prec")
538 showList_RDR, showList___RDR, showsPrec_RDR, showString_RDR,
539 showSpace_RDR, showParen_RDR :: RdrName
540 showList_RDR = varQual_RDR gHC_SHOW (fsLit "showList")
541 showList___RDR = varQual_RDR gHC_SHOW (fsLit "showList__")
542 showsPrec_RDR = varQual_RDR gHC_SHOW (fsLit "showsPrec")
543 showString_RDR = varQual_RDR gHC_SHOW (fsLit "showString")
544 showSpace_RDR = varQual_RDR gHC_SHOW (fsLit "showSpace")
545 showParen_RDR = varQual_RDR gHC_SHOW (fsLit "showParen")
547 typeOf_RDR, mkTypeRep_RDR, mkTyConRep_RDR :: RdrName
548 typeOf_RDR = varQual_RDR tYPEABLE (fsLit "typeOf")
549 mkTypeRep_RDR = varQual_RDR tYPEABLE (fsLit "mkTyConApp")
550 mkTyConRep_RDR = varQual_RDR tYPEABLE (fsLit "mkTyCon")
552 undefined_RDR :: RdrName
553 undefined_RDR = varQual_RDR gHC_ERR (fsLit "undefined")
555 crossDataCon_RDR, inlDataCon_RDR, inrDataCon_RDR, genUnitDataCon_RDR :: RdrName
556 crossDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit ":*:")
557 inlDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Inl")
558 inrDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Inr")
559 genUnitDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Unit")
561 fmap_RDR, pure_RDR, ap_RDR, foldable_foldr_RDR, traverse_RDR :: RdrName
562 fmap_RDR = varQual_RDR gHC_BASE (fsLit "fmap")
563 pure_RDR = varQual_RDR cONTROL_APPLICATIVE (fsLit "pure")
564 ap_RDR = varQual_RDR cONTROL_APPLICATIVE (fsLit "<*>")
565 foldable_foldr_RDR = varQual_RDR dATA_FOLDABLE (fsLit "foldr")
566 traverse_RDR = varQual_RDR dATA_TRAVERSABLE (fsLit "traverse")
568 ----------------------
569 varQual_RDR, tcQual_RDR, clsQual_RDR, dataQual_RDR
570 :: Module -> FastString -> RdrName
571 varQual_RDR mod str = mkOrig mod (mkOccNameFS varName str)
572 tcQual_RDR mod str = mkOrig mod (mkOccNameFS tcName str)
573 clsQual_RDR mod str = mkOrig mod (mkOccNameFS clsName str)
574 dataQual_RDR mod str = mkOrig mod (mkOccNameFS dataName str)
577 %************************************************************************
579 \subsection{Known-key names}
581 %************************************************************************
583 Many of these Names are not really "built in", but some parts of the
584 compiler (notably the deriving mechanism) need to mention their names,
585 and it's convenient to write them all down in one place.
587 --MetaHaskell Extension add the constrs and the lower case case
588 -- guys as well (perhaps) e.g. see trueDataConName below
593 wildCardName = mkSystemVarName wildCardKey (fsLit "wild")
595 runMainIOName :: Name
596 runMainIOName = varQual gHC_TOP_HANDLER (fsLit "runMainIO") runMainKey
598 orderingTyConName :: Name
599 orderingTyConName = tcQual gHC_ORDERING (fsLit "Ordering") orderingTyConKey
601 eitherTyConName, leftDataConName, rightDataConName :: Name
602 eitherTyConName = tcQual dATA_EITHER (fsLit "Either") eitherTyConKey
603 leftDataConName = conName dATA_EITHER (fsLit "Left") leftDataConKey
604 rightDataConName = conName dATA_EITHER (fsLit "Right") rightDataConKey
607 crossTyConName, plusTyConName, genUnitTyConName :: Name
608 crossTyConName = tcQual gHC_GENERICS (fsLit ":*:") crossTyConKey
609 plusTyConName = tcQual gHC_GENERICS (fsLit ":+:") plusTyConKey
610 genUnitTyConName = tcQual gHC_GENERICS (fsLit "Unit") genUnitTyConKey
612 -- Base strings Strings
613 unpackCStringName, unpackCStringAppendName, unpackCStringFoldrName,
614 unpackCStringUtf8Name, eqStringName, stringTyConName :: Name
615 unpackCStringName = varQual gHC_BASE (fsLit "unpackCString#") unpackCStringIdKey
616 unpackCStringAppendName = varQual gHC_BASE (fsLit "unpackAppendCString#") unpackCStringAppendIdKey
617 unpackCStringFoldrName = varQual gHC_BASE (fsLit "unpackFoldrCString#") unpackCStringFoldrIdKey
618 unpackCStringUtf8Name = varQual gHC_BASE (fsLit "unpackCStringUtf8#") unpackCStringUtf8IdKey
619 eqStringName = varQual gHC_BASE (fsLit "eqString") eqStringIdKey
620 stringTyConName = tcQual gHC_BASE (fsLit "String") stringTyConKey
622 -- The 'inline' function
624 inlineIdName = varQual gHC_MAGIC (fsLit "inline") inlineIdKey
626 -- Base classes (Eq, Ord, Functor)
627 eqClassName, eqName, ordClassName, geName, functorClassName :: Name
628 eqClassName = clsQual gHC_CLASSES (fsLit "Eq") eqClassKey
629 eqName = methName gHC_CLASSES (fsLit "==") eqClassOpKey
630 ordClassName = clsQual gHC_CLASSES (fsLit "Ord") ordClassKey
631 geName = methName gHC_CLASSES (fsLit ">=") geClassOpKey
632 functorClassName = clsQual gHC_BASE (fsLit "Functor") functorClassKey
635 monadClassName, thenMName, bindMName, returnMName, failMName :: Name
636 monadClassName = clsQual gHC_BASE (fsLit "Monad") monadClassKey
637 thenMName = methName gHC_BASE (fsLit ">>") thenMClassOpKey
638 bindMName = methName gHC_BASE (fsLit ">>=") bindMClassOpKey
639 returnMName = methName gHC_BASE (fsLit "return") returnMClassOpKey
640 failMName = methName gHC_BASE (fsLit "fail") failMClassOpKey
642 -- Classes (Applicative, Foldable, Traversable)
643 applicativeClassName, foldableClassName, traversableClassName :: Name
644 applicativeClassName = clsQual cONTROL_APPLICATIVE (fsLit "Applicative") applicativeClassKey
645 foldableClassName = clsQual dATA_FOLDABLE (fsLit "Foldable") foldableClassKey
646 traversableClassName = clsQual dATA_TRAVERSABLE (fsLit "Traversable") traversableClassKey
648 -- Functions for GHC extensions
649 groupWithName :: Name
650 groupWithName = varQual gHC_EXTS (fsLit "groupWith") groupWithIdKey
652 -- Random PrelBase functions
653 fromStringName, otherwiseIdName, foldrName, buildName, augmentName,
654 mapName, appendName, assertName,
655 breakpointName, breakpointCondName, breakpointAutoName,
656 dollarName, opaqueTyConName :: Name
657 fromStringName = methName dATA_STRING (fsLit "fromString") fromStringClassOpKey
658 otherwiseIdName = varQual gHC_BASE (fsLit "otherwise") otherwiseIdKey
659 foldrName = varQual gHC_BASE (fsLit "foldr") foldrIdKey
660 buildName = varQual gHC_BASE (fsLit "build") buildIdKey
661 augmentName = varQual gHC_BASE (fsLit "augment") augmentIdKey
662 mapName = varQual gHC_BASE (fsLit "map") mapIdKey
663 appendName = varQual gHC_BASE (fsLit "++") appendIdKey
664 dollarName = varQual gHC_BASE (fsLit "$") dollarIdKey
665 assertName = varQual gHC_BASE (fsLit "assert") assertIdKey
666 breakpointName = varQual gHC_BASE (fsLit "breakpoint") breakpointIdKey
667 breakpointCondName= varQual gHC_BASE (fsLit "breakpointCond") breakpointCondIdKey
668 breakpointAutoName= varQual gHC_BASE (fsLit "breakpointAuto") breakpointAutoIdKey
669 opaqueTyConName = tcQual gHC_BASE (fsLit "Opaque") opaqueTyConKey
671 breakpointJumpName :: Name
675 (mkOccNameFS varName (fsLit "breakpointJump"))
677 breakpointCondJumpName :: Name
678 breakpointCondJumpName
680 breakpointCondJumpIdKey
681 (mkOccNameFS varName (fsLit "breakpointCondJump"))
683 breakpointAutoJumpName :: Name
684 breakpointAutoJumpName
686 breakpointAutoJumpIdKey
687 (mkOccNameFS varName (fsLit "breakpointAutoJump"))
691 fstName, sndName :: Name
692 fstName = varQual dATA_TUPLE (fsLit "fst") fstIdKey
693 sndName = varQual dATA_TUPLE (fsLit "snd") sndIdKey
696 numClassName, fromIntegerName, minusName, negateName, plusIntegerName,
698 integerTyConName, smallIntegerName :: Name
699 numClassName = clsQual gHC_NUM (fsLit "Num") numClassKey
700 fromIntegerName = methName gHC_NUM (fsLit "fromInteger") fromIntegerClassOpKey
701 minusName = methName gHC_NUM (fsLit "-") minusClassOpKey
702 negateName = methName gHC_NUM (fsLit "negate") negateClassOpKey
703 plusIntegerName = varQual gHC_INTEGER (fsLit "plusInteger") plusIntegerIdKey
704 timesIntegerName = varQual gHC_INTEGER (fsLit "timesInteger") timesIntegerIdKey
705 integerTyConName = tcQual gHC_INTEGER_TYPE (fsLit "Integer") integerTyConKey
706 smallIntegerName = varQual gHC_INTEGER (fsLit "smallInteger") smallIntegerIdKey
708 -- GHC.Real types and classes
709 rationalTyConName, ratioTyConName, ratioDataConName, realClassName,
710 integralClassName, realFracClassName, fractionalClassName,
711 fromRationalName, toIntegerName, toRationalName, fromIntegralName,
712 realToFracName :: Name
713 rationalTyConName = tcQual gHC_REAL (fsLit "Rational") rationalTyConKey
714 ratioTyConName = tcQual gHC_REAL (fsLit "Ratio") ratioTyConKey
715 ratioDataConName = conName gHC_REAL (fsLit ":%") ratioDataConKey
716 realClassName = clsQual gHC_REAL (fsLit "Real") realClassKey
717 integralClassName = clsQual gHC_REAL (fsLit "Integral") integralClassKey
718 realFracClassName = clsQual gHC_REAL (fsLit "RealFrac") realFracClassKey
719 fractionalClassName = clsQual gHC_REAL (fsLit "Fractional") fractionalClassKey
720 fromRationalName = methName gHC_REAL (fsLit "fromRational") fromRationalClassOpKey
721 toIntegerName = methName gHC_REAL (fsLit "toInteger") toIntegerClassOpKey
722 toRationalName = methName gHC_REAL (fsLit "toRational") toRationalClassOpKey
723 fromIntegralName = varQual gHC_REAL (fsLit "fromIntegral") fromIntegralIdKey
724 realToFracName = varQual gHC_REAL (fsLit "realToFrac") realToFracIdKey
727 floatingClassName, realFloatClassName :: Name
728 floatingClassName = clsQual gHC_FLOAT (fsLit "Floating") floatingClassKey
729 realFloatClassName = clsQual gHC_FLOAT (fsLit "RealFloat") realFloatClassKey
733 ixClassName = clsQual gHC_ARR (fsLit "Ix") ixClassKey
736 typeableClassName, typeable1ClassName, typeable2ClassName,
737 typeable3ClassName, typeable4ClassName, typeable5ClassName,
738 typeable6ClassName, typeable7ClassName :: Name
739 typeableClassName = clsQual tYPEABLE (fsLit "Typeable") typeableClassKey
740 typeable1ClassName = clsQual tYPEABLE (fsLit "Typeable1") typeable1ClassKey
741 typeable2ClassName = clsQual tYPEABLE (fsLit "Typeable2") typeable2ClassKey
742 typeable3ClassName = clsQual tYPEABLE (fsLit "Typeable3") typeable3ClassKey
743 typeable4ClassName = clsQual tYPEABLE (fsLit "Typeable4") typeable4ClassKey
744 typeable5ClassName = clsQual tYPEABLE (fsLit "Typeable5") typeable5ClassKey
745 typeable6ClassName = clsQual tYPEABLE (fsLit "Typeable6") typeable6ClassKey
746 typeable7ClassName = clsQual tYPEABLE (fsLit "Typeable7") typeable7ClassKey
748 typeableClassNames :: [Name]
749 typeableClassNames = [ typeableClassName, typeable1ClassName, typeable2ClassName
750 , typeable3ClassName, typeable4ClassName, typeable5ClassName
751 , typeable6ClassName, typeable7ClassName ]
754 dataClassName :: Name
755 dataClassName = clsQual gENERICS (fsLit "Data") dataClassKey
758 assertErrorName :: Name
759 assertErrorName = varQual gHC_IO_Exception (fsLit "assertError") assertErrorIdKey
761 -- Enum module (Enum, Bounded)
762 enumClassName, enumFromName, enumFromToName, enumFromThenName,
763 enumFromThenToName, boundedClassName :: Name
764 enumClassName = clsQual gHC_ENUM (fsLit "Enum") enumClassKey
765 enumFromName = methName gHC_ENUM (fsLit "enumFrom") enumFromClassOpKey
766 enumFromToName = methName gHC_ENUM (fsLit "enumFromTo") enumFromToClassOpKey
767 enumFromThenName = methName gHC_ENUM (fsLit "enumFromThen") enumFromThenClassOpKey
768 enumFromThenToName = methName gHC_ENUM (fsLit "enumFromThenTo") enumFromThenToClassOpKey
769 boundedClassName = clsQual gHC_ENUM (fsLit "Bounded") boundedClassKey
772 concatName, filterName, zipName :: Name
773 concatName = varQual gHC_LIST (fsLit "concat") concatIdKey
774 filterName = varQual gHC_LIST (fsLit "filter") filterIdKey
775 zipName = varQual gHC_LIST (fsLit "zip") zipIdKey
778 showClassName :: Name
779 showClassName = clsQual gHC_SHOW (fsLit "Show") showClassKey
782 readClassName :: Name
783 readClassName = clsQual gHC_READ (fsLit "Read") readClassKey
785 -- parallel array types and functions
786 enumFromToPName, enumFromThenToPName, nullPName, lengthPName,
787 singletonPName, replicatePName, mapPName, filterPName,
788 zipPName, crossMapPName, indexPName, toPName,
789 emptyPName, appPName :: PackageId -> Name
790 enumFromToPName pkg = varQual (gHC_PARR pkg) (fsLit "enumFromToP") enumFromToPIdKey
791 enumFromThenToPName pkg = varQual (gHC_PARR pkg) (fsLit "enumFromThenToP") enumFromThenToPIdKey
792 nullPName pkg = varQual (gHC_PARR pkg) (fsLit "nullP") nullPIdKey
793 lengthPName pkg = varQual (gHC_PARR pkg) (fsLit "lengthP") lengthPIdKey
794 singletonPName pkg = varQual (gHC_PARR pkg) (fsLit "singletonP") singletonPIdKey
795 replicatePName pkg = varQual (gHC_PARR pkg) (fsLit "replicateP") replicatePIdKey
796 mapPName pkg = varQual (gHC_PARR pkg) (fsLit "mapP") mapPIdKey
797 filterPName pkg = varQual (gHC_PARR pkg) (fsLit "filterP") filterPIdKey
798 zipPName pkg = varQual (gHC_PARR pkg) (fsLit "zipP") zipPIdKey
799 crossMapPName pkg = varQual (gHC_PARR pkg) (fsLit "crossMapP") crossMapPIdKey
800 indexPName pkg = varQual (gHC_PARR pkg) (fsLit "!:") indexPIdKey
801 toPName pkg = varQual (gHC_PARR pkg) (fsLit "toP") toPIdKey
802 emptyPName pkg = varQual (gHC_PARR pkg) (fsLit "emptyP") emptyPIdKey
803 appPName pkg = varQual (gHC_PARR pkg) (fsLit "+:+") appPIdKey
806 hetmet_brak_name, hetmet_esc_name, hetmet_csp_name, hetmet_flatten_name, hetmet_unflatten_name, hetmet_flattened_id_name :: Name
807 hetmet_guest_integer_literal_name, hetmet_guest_string_literal_name, hetmet_guest_char_literal_name :: Name
808 hetmet_brak_name = varQual gHC_HETMET_CODETYPES (fsLit "hetmet_brak") hetmet_brak_key
809 hetmet_esc_name = varQual gHC_HETMET_CODETYPES (fsLit "hetmet_esc") hetmet_esc_key
810 hetmet_csp_name = varQual gHC_HETMET_CODETYPES (fsLit "hetmet_csp") hetmet_csp_key
811 hetmet_flatten_name = varQual gHC_HETMET_CODETYPES (fsLit "pga_flatten") hetmet_flatten_key
812 hetmet_unflatten_name = varQual gHC_HETMET_CODETYPES (fsLit "pga_unflatten") hetmet_unflatten_key
813 hetmet_flattened_id_name = varQual gHC_HETMET_CODETYPES (fsLit "pga_flattened_id") hetmet_flattened_id_key
814 hetmet_guest_integer_literal_name = varQual gHC_HETMET_CODETYPES (fsLit "guestIntegerLiteral") hetmet_guest_integer_literal_key
815 hetmet_guest_string_literal_name = varQual gHC_HETMET_CODETYPES (fsLit "guestStringLiteral") hetmet_guest_string_literal_key
816 hetmet_guest_char_literal_name = varQual gHC_HETMET_CODETYPES (fsLit "guestCharLiteral") hetmet_guest_char_literal_key
818 hetmet_PGArrow_name :: Name
819 hetmet_PGArrow_name = tcQual gHC_HETMET_PRIVATE (fsLit "PGArrow") hetmet_PGArrow_key
820 hetmet_pga_id_name :: Name
821 hetmet_pga_id_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_id") hetmet_pga_id_key
822 hetmet_pga_comp_name :: Name
823 hetmet_pga_comp_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_comp") hetmet_pga_comp_key
824 hetmet_pga_first_name :: Name
825 hetmet_pga_first_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_first") hetmet_pga_first_key
826 hetmet_pga_second_name :: Name
827 hetmet_pga_second_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_second") hetmet_pga_second_key
828 hetmet_pga_cancell_name :: Name
829 hetmet_pga_cancell_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_cancell") hetmet_pga_cancell_key
830 hetmet_pga_cancelr_name :: Name
831 hetmet_pga_cancelr_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_cancelr") hetmet_pga_cancelr_key
832 hetmet_pga_uncancell_name :: Name
833 hetmet_pga_uncancell_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_uncancell") hetmet_pga_uncancell_key
834 hetmet_pga_uncancelr_name :: Name
835 hetmet_pga_uncancelr_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_uncancelr") hetmet_pga_uncancelr_key
836 hetmet_pga_assoc_name :: Name
837 hetmet_pga_assoc_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_assoc") hetmet_pga_assoc_key
838 hetmet_pga_unassoc_name :: Name
839 hetmet_pga_unassoc_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_unassoc") hetmet_pga_unassoc_key
840 hetmet_pga_copy_name :: Name
841 hetmet_pga_copy_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_copy") hetmet_pga_copy_key
842 hetmet_pga_drop_name :: Name
843 hetmet_pga_drop_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_drop") hetmet_pga_drop_key
844 hetmet_pga_swap_name :: Name
845 hetmet_pga_swap_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_swap") hetmet_pga_swap_key
846 hetmet_pga_applyl_name :: Name
847 hetmet_pga_applyl_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_applyl") hetmet_pga_applyl_key
848 hetmet_pga_applyr_name :: Name
849 hetmet_pga_applyr_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_applyr") hetmet_pga_applyr_key
850 hetmet_pga_curryl_name :: Name
851 hetmet_pga_curryl_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_curryl") hetmet_pga_curryl_key
852 hetmet_pga_curryr_name :: Name
853 hetmet_pga_curryr_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_curryr") hetmet_pga_curryr_key
856 ioTyConName, ioDataConName, thenIOName, bindIOName, returnIOName,
858 ioTyConName = tcQual gHC_TYPES (fsLit "IO") ioTyConKey
859 ioDataConName = conName gHC_TYPES (fsLit "IO") ioDataConKey
860 thenIOName = varQual gHC_BASE (fsLit "thenIO") thenIOIdKey
861 bindIOName = varQual gHC_BASE (fsLit "bindIO") bindIOIdKey
862 returnIOName = varQual gHC_BASE (fsLit "returnIO") returnIOIdKey
863 failIOName = varQual gHC_IO (fsLit "failIO") failIOIdKey
867 printName = varQual sYSTEM_IO (fsLit "print") printIdKey
869 -- Int, Word, and Addr things
870 int8TyConName, int16TyConName, int32TyConName, int64TyConName :: Name
871 int8TyConName = tcQual gHC_INT (fsLit "Int8") int8TyConKey
872 int16TyConName = tcQual gHC_INT (fsLit "Int16") int16TyConKey
873 int32TyConName = tcQual gHC_INT (fsLit "Int32") int32TyConKey
874 int64TyConName = tcQual gHC_INT (fsLit "Int64") int64TyConKey
877 word8TyConName, word16TyConName, word32TyConName, word64TyConName,
878 wordTyConName, wordDataConName :: Name
879 word8TyConName = tcQual gHC_WORD (fsLit "Word8") word8TyConKey
880 word16TyConName = tcQual gHC_WORD (fsLit "Word16") word16TyConKey
881 word32TyConName = tcQual gHC_WORD (fsLit "Word32") word32TyConKey
882 word64TyConName = tcQual gHC_WORD (fsLit "Word64") word64TyConKey
883 wordTyConName = tcQual gHC_WORD (fsLit "Word") wordTyConKey
884 wordDataConName = conName gHC_WORD (fsLit "W#") wordDataConKey
887 ptrTyConName, funPtrTyConName :: Name
888 ptrTyConName = tcQual gHC_PTR (fsLit "Ptr") ptrTyConKey
889 funPtrTyConName = tcQual gHC_PTR (fsLit "FunPtr") funPtrTyConKey
891 -- Foreign objects and weak pointers
892 stablePtrTyConName, newStablePtrName :: Name
893 stablePtrTyConName = tcQual gHC_STABLE (fsLit "StablePtr") stablePtrTyConKey
894 newStablePtrName = varQual gHC_STABLE (fsLit "newStablePtr") newStablePtrIdKey
898 runSTRepName = varQual gHC_ST (fsLit "runSTRep") runSTRepIdKey
900 -- Recursive-do notation
901 monadFixClassName, mfixName :: Name
902 monadFixClassName = clsQual mONAD_FIX (fsLit "MonadFix") monadFixClassKey
903 mfixName = methName mONAD_FIX (fsLit "mfix") mfixIdKey
906 arrAName, composeAName, firstAName, appAName, choiceAName, loopAName :: Name
907 arrAName = varQual aRROW (fsLit "arr") arrAIdKey
908 composeAName = varQual gHC_DESUGAR (fsLit ">>>") composeAIdKey
909 firstAName = varQual aRROW (fsLit "first") firstAIdKey
910 appAName = varQual aRROW (fsLit "app") appAIdKey
911 choiceAName = varQual aRROW (fsLit "|||") choiceAIdKey
912 loopAName = varQual aRROW (fsLit "loop") loopAIdKey
914 -- Annotation type checking
915 toAnnotationWrapperName :: Name
916 toAnnotationWrapperName = varQual gHC_DESUGAR (fsLit "toAnnotationWrapper") toAnnotationWrapperIdKey
918 -- Other classes, needed for type defaulting
919 monadPlusClassName, randomClassName, randomGenClassName,
920 isStringClassName :: Name
921 monadPlusClassName = clsQual mONAD (fsLit "MonadPlus") monadPlusClassKey
922 randomClassName = clsQual rANDOM (fsLit "Random") randomClassKey
923 randomGenClassName = clsQual rANDOM (fsLit "RandomGen") randomGenClassKey
924 isStringClassName = clsQual dATA_STRING (fsLit "IsString") isStringClassKey
927 objectTyConName :: Name
928 objectTyConName = tcQual dOTNET (fsLit "Object") objectTyConKey
929 -- objectTyConName was "wTcQual", but that's gone now, and
930 -- I can't see why it was wired in anyway...
931 unmarshalObjectName, marshalObjectName, marshalStringName,
932 unmarshalStringName, checkDotnetResName :: Name
933 unmarshalObjectName = varQual dOTNET (fsLit "unmarshalObject") unmarshalObjectIdKey
934 marshalObjectName = varQual dOTNET (fsLit "marshalObject") marshalObjectIdKey
935 marshalStringName = varQual dOTNET (fsLit "marshalString") marshalStringIdKey
936 unmarshalStringName = varQual dOTNET (fsLit "unmarshalString") unmarshalStringIdKey
937 checkDotnetResName = varQual dOTNET (fsLit "checkResult") checkDotnetResNameIdKey
940 %************************************************************************
942 \subsection{Local helpers}
944 %************************************************************************
946 All these are original names; hence mkOrig
949 varQual, tcQual, clsQual :: Module -> FastString -> Unique -> Name
950 varQual = mk_known_key_name varName
951 tcQual = mk_known_key_name tcName
952 clsQual = mk_known_key_name clsName
954 mk_known_key_name :: NameSpace -> Module -> FastString -> Unique -> Name
955 mk_known_key_name space modu str unique
956 = mkExternalName unique modu (mkOccNameFS space str) noSrcSpan
958 conName :: Module -> FastString -> Unique -> Name
959 conName modu occ unique
960 = mkExternalName unique modu (mkOccNameFS dataName occ) noSrcSpan
962 methName :: Module -> FastString -> Unique -> Name
963 methName modu occ unique
964 = mkExternalName unique modu (mkVarOccFS occ) noSrcSpan
967 %************************************************************************
969 \subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@}
971 %************************************************************************
972 --MetaHaskell extension hand allocate keys here
975 boundedClassKey, enumClassKey, eqClassKey, floatingClassKey,
976 fractionalClassKey, integralClassKey, monadClassKey, dataClassKey,
977 functorClassKey, numClassKey, ordClassKey, readClassKey, realClassKey,
978 realFloatClassKey, realFracClassKey, showClassKey, ixClassKey :: Unique
979 boundedClassKey = mkPreludeClassUnique 1
980 enumClassKey = mkPreludeClassUnique 2
981 eqClassKey = mkPreludeClassUnique 3
982 floatingClassKey = mkPreludeClassUnique 5
983 fractionalClassKey = mkPreludeClassUnique 6
984 integralClassKey = mkPreludeClassUnique 7
985 monadClassKey = mkPreludeClassUnique 8
986 dataClassKey = mkPreludeClassUnique 9
987 functorClassKey = mkPreludeClassUnique 10
988 numClassKey = mkPreludeClassUnique 11
989 ordClassKey = mkPreludeClassUnique 12
990 readClassKey = mkPreludeClassUnique 13
991 realClassKey = mkPreludeClassUnique 14
992 realFloatClassKey = mkPreludeClassUnique 15
993 realFracClassKey = mkPreludeClassUnique 16
994 showClassKey = mkPreludeClassUnique 17
995 ixClassKey = mkPreludeClassUnique 18
997 typeableClassKey, typeable1ClassKey, typeable2ClassKey, typeable3ClassKey,
998 typeable4ClassKey, typeable5ClassKey, typeable6ClassKey, typeable7ClassKey
1000 typeableClassKey = mkPreludeClassUnique 20
1001 typeable1ClassKey = mkPreludeClassUnique 21
1002 typeable2ClassKey = mkPreludeClassUnique 22
1003 typeable3ClassKey = mkPreludeClassUnique 23
1004 typeable4ClassKey = mkPreludeClassUnique 24
1005 typeable5ClassKey = mkPreludeClassUnique 25
1006 typeable6ClassKey = mkPreludeClassUnique 26
1007 typeable7ClassKey = mkPreludeClassUnique 27
1009 monadFixClassKey :: Unique
1010 monadFixClassKey = mkPreludeClassUnique 28
1012 monadPlusClassKey, randomClassKey, randomGenClassKey :: Unique
1013 monadPlusClassKey = mkPreludeClassUnique 30
1014 randomClassKey = mkPreludeClassUnique 31
1015 randomGenClassKey = mkPreludeClassUnique 32
1017 isStringClassKey :: Unique
1018 isStringClassKey = mkPreludeClassUnique 33
1020 applicativeClassKey, foldableClassKey, traversableClassKey :: Unique
1021 applicativeClassKey = mkPreludeClassUnique 34
1022 foldableClassKey = mkPreludeClassUnique 35
1023 traversableClassKey = mkPreludeClassUnique 36
1026 %************************************************************************
1028 \subsubsection[Uniques-prelude-TyCons]{@Uniques@ for wired-in @TyCons@}
1030 %************************************************************************
1033 addrPrimTyConKey, arrayPrimTyConKey, boolTyConKey, byteArrayPrimTyConKey,
1034 charPrimTyConKey, charTyConKey, doublePrimTyConKey, doubleTyConKey,
1035 floatPrimTyConKey, floatTyConKey, funTyConKey, intPrimTyConKey,
1036 intTyConKey, int8TyConKey, int16TyConKey, int32PrimTyConKey,
1037 int32TyConKey, int64PrimTyConKey, int64TyConKey, integerTyConKey,
1038 listTyConKey, foreignObjPrimTyConKey, weakPrimTyConKey,
1039 mutableArrayPrimTyConKey, mutableByteArrayPrimTyConKey,
1040 orderingTyConKey, mVarPrimTyConKey, ratioTyConKey, rationalTyConKey,
1041 realWorldTyConKey, stablePtrPrimTyConKey, stablePtrTyConKey,
1042 anyTyConKey :: Unique
1043 addrPrimTyConKey = mkPreludeTyConUnique 1
1044 arrayPrimTyConKey = mkPreludeTyConUnique 3
1045 boolTyConKey = mkPreludeTyConUnique 4
1046 byteArrayPrimTyConKey = mkPreludeTyConUnique 5
1047 charPrimTyConKey = mkPreludeTyConUnique 7
1048 charTyConKey = mkPreludeTyConUnique 8
1049 doublePrimTyConKey = mkPreludeTyConUnique 9
1050 doubleTyConKey = mkPreludeTyConUnique 10
1051 floatPrimTyConKey = mkPreludeTyConUnique 11
1052 floatTyConKey = mkPreludeTyConUnique 12
1053 funTyConKey = mkPreludeTyConUnique 13
1054 intPrimTyConKey = mkPreludeTyConUnique 14
1055 intTyConKey = mkPreludeTyConUnique 15
1056 int8TyConKey = mkPreludeTyConUnique 16
1057 int16TyConKey = mkPreludeTyConUnique 17
1058 int32PrimTyConKey = mkPreludeTyConUnique 18
1059 int32TyConKey = mkPreludeTyConUnique 19
1060 int64PrimTyConKey = mkPreludeTyConUnique 20
1061 int64TyConKey = mkPreludeTyConUnique 21
1062 integerTyConKey = mkPreludeTyConUnique 22
1063 listTyConKey = mkPreludeTyConUnique 23
1064 foreignObjPrimTyConKey = mkPreludeTyConUnique 24
1065 weakPrimTyConKey = mkPreludeTyConUnique 27
1066 mutableArrayPrimTyConKey = mkPreludeTyConUnique 28
1067 mutableByteArrayPrimTyConKey = mkPreludeTyConUnique 29
1068 orderingTyConKey = mkPreludeTyConUnique 30
1069 mVarPrimTyConKey = mkPreludeTyConUnique 31
1070 ratioTyConKey = mkPreludeTyConUnique 32
1071 rationalTyConKey = mkPreludeTyConUnique 33
1072 realWorldTyConKey = mkPreludeTyConUnique 34
1073 stablePtrPrimTyConKey = mkPreludeTyConUnique 35
1074 stablePtrTyConKey = mkPreludeTyConUnique 36
1075 anyTyConKey = mkPreludeTyConUnique 37
1077 statePrimTyConKey, stableNamePrimTyConKey, stableNameTyConKey,
1078 mutVarPrimTyConKey, ioTyConKey,
1079 wordPrimTyConKey, wordTyConKey, word8TyConKey, word16TyConKey,
1080 word32PrimTyConKey, word32TyConKey, word64PrimTyConKey, word64TyConKey,
1081 liftedConKey, unliftedConKey, anyBoxConKey, kindConKey, boxityConKey,
1082 typeConKey, threadIdPrimTyConKey, bcoPrimTyConKey, ptrTyConKey,
1083 funPtrTyConKey, tVarPrimTyConKey :: Unique
1084 statePrimTyConKey = mkPreludeTyConUnique 50
1085 stableNamePrimTyConKey = mkPreludeTyConUnique 51
1086 stableNameTyConKey = mkPreludeTyConUnique 52
1087 mutVarPrimTyConKey = mkPreludeTyConUnique 55
1088 ioTyConKey = mkPreludeTyConUnique 56
1089 wordPrimTyConKey = mkPreludeTyConUnique 58
1090 wordTyConKey = mkPreludeTyConUnique 59
1091 word8TyConKey = mkPreludeTyConUnique 60
1092 word16TyConKey = mkPreludeTyConUnique 61
1093 word32PrimTyConKey = mkPreludeTyConUnique 62
1094 word32TyConKey = mkPreludeTyConUnique 63
1095 word64PrimTyConKey = mkPreludeTyConUnique 64
1096 word64TyConKey = mkPreludeTyConUnique 65
1097 liftedConKey = mkPreludeTyConUnique 66
1098 unliftedConKey = mkPreludeTyConUnique 67
1099 anyBoxConKey = mkPreludeTyConUnique 68
1100 kindConKey = mkPreludeTyConUnique 69
1101 boxityConKey = mkPreludeTyConUnique 70
1102 typeConKey = mkPreludeTyConUnique 71
1103 threadIdPrimTyConKey = mkPreludeTyConUnique 72
1104 bcoPrimTyConKey = mkPreludeTyConUnique 73
1105 ptrTyConKey = mkPreludeTyConUnique 74
1106 funPtrTyConKey = mkPreludeTyConUnique 75
1107 tVarPrimTyConKey = mkPreludeTyConUnique 76
1109 -- Generic Type Constructors
1110 crossTyConKey, plusTyConKey, genUnitTyConKey :: Unique
1111 crossTyConKey = mkPreludeTyConUnique 79
1112 plusTyConKey = mkPreludeTyConUnique 80
1113 genUnitTyConKey = mkPreludeTyConUnique 81
1115 -- Parallel array type constructor
1116 parrTyConKey :: Unique
1117 parrTyConKey = mkPreludeTyConUnique 82
1120 objectTyConKey :: Unique
1121 objectTyConKey = mkPreludeTyConUnique 83
1123 eitherTyConKey :: Unique
1124 eitherTyConKey = mkPreludeTyConUnique 84
1126 -- Super Kinds constructors
1127 tySuperKindTyConKey, coSuperKindTyConKey :: Unique
1128 tySuperKindTyConKey = mkPreludeTyConUnique 85
1129 coSuperKindTyConKey = mkPreludeTyConUnique 86
1131 -- Kind constructors
1132 liftedTypeKindTyConKey, openTypeKindTyConKey, unliftedTypeKindTyConKey,
1133 ubxTupleKindTyConKey, argTypeKindTyConKey :: Unique
1134 liftedTypeKindTyConKey = mkPreludeTyConUnique 87
1135 openTypeKindTyConKey = mkPreludeTyConUnique 88
1136 unliftedTypeKindTyConKey = mkPreludeTyConUnique 89
1137 ubxTupleKindTyConKey = mkPreludeTyConUnique 90
1138 argTypeKindTyConKey = mkPreludeTyConUnique 91
1140 -- Coercion constructors
1141 symCoercionTyConKey, transCoercionTyConKey, leftCoercionTyConKey,
1142 rightCoercionTyConKey, instCoercionTyConKey, unsafeCoercionTyConKey,
1143 csel1CoercionTyConKey, csel2CoercionTyConKey, cselRCoercionTyConKey
1145 symCoercionTyConKey = mkPreludeTyConUnique 93
1146 transCoercionTyConKey = mkPreludeTyConUnique 94
1147 leftCoercionTyConKey = mkPreludeTyConUnique 95
1148 rightCoercionTyConKey = mkPreludeTyConUnique 96
1149 instCoercionTyConKey = mkPreludeTyConUnique 97
1150 unsafeCoercionTyConKey = mkPreludeTyConUnique 98
1151 csel1CoercionTyConKey = mkPreludeTyConUnique 99
1152 csel2CoercionTyConKey = mkPreludeTyConUnique 100
1153 cselRCoercionTyConKey = mkPreludeTyConUnique 101
1155 unknownTyConKey, unknown1TyConKey, unknown2TyConKey, unknown3TyConKey,
1156 opaqueTyConKey :: Unique
1157 unknownTyConKey = mkPreludeTyConUnique 129
1158 unknown1TyConKey = mkPreludeTyConUnique 130
1159 unknown2TyConKey = mkPreludeTyConUnique 131
1160 unknown3TyConKey = mkPreludeTyConUnique 132
1161 opaqueTyConKey = mkPreludeTyConUnique 133
1163 stringTyConKey :: Unique
1164 stringTyConKey = mkPreludeTyConUnique 134
1166 -- Heterogeneous Metaprogramming code type constructor
1167 hetMetCodeTypeTyConKey :: Unique
1168 hetMetCodeTypeTyConKey = mkPreludeTyConUnique 135
1170 ---------------- Template Haskell -------------------
1171 -- USES TyConUniques 200-299
1172 -----------------------------------------------------
1174 unitTyConKey :: Unique
1175 unitTyConKey = mkTupleTyConUnique Boxed 0
1178 %************************************************************************
1180 \subsubsection[Uniques-prelude-DataCons]{@Uniques@ for wired-in @DataCons@}
1182 %************************************************************************
1185 charDataConKey, consDataConKey, doubleDataConKey, falseDataConKey,
1186 floatDataConKey, intDataConKey, nilDataConKey, ratioDataConKey,
1187 stableNameDataConKey, trueDataConKey, wordDataConKey,
1188 ioDataConKey, integerDataConKey :: Unique
1189 charDataConKey = mkPreludeDataConUnique 1
1190 consDataConKey = mkPreludeDataConUnique 2
1191 doubleDataConKey = mkPreludeDataConUnique 3
1192 falseDataConKey = mkPreludeDataConUnique 4
1193 floatDataConKey = mkPreludeDataConUnique 5
1194 intDataConKey = mkPreludeDataConUnique 6
1195 nilDataConKey = mkPreludeDataConUnique 11
1196 ratioDataConKey = mkPreludeDataConUnique 12
1197 stableNameDataConKey = mkPreludeDataConUnique 14
1198 trueDataConKey = mkPreludeDataConUnique 15
1199 wordDataConKey = mkPreludeDataConUnique 16
1200 ioDataConKey = mkPreludeDataConUnique 17
1201 integerDataConKey = mkPreludeDataConUnique 18
1203 -- Generic data constructors
1204 crossDataConKey, inlDataConKey, inrDataConKey, genUnitDataConKey :: Unique
1205 crossDataConKey = mkPreludeDataConUnique 20
1206 inlDataConKey = mkPreludeDataConUnique 21
1207 inrDataConKey = mkPreludeDataConUnique 22
1208 genUnitDataConKey = mkPreludeDataConUnique 23
1210 -- Data constructor for parallel arrays
1211 parrDataConKey :: Unique
1212 parrDataConKey = mkPreludeDataConUnique 24
1214 leftDataConKey, rightDataConKey :: Unique
1215 leftDataConKey = mkPreludeDataConUnique 25
1216 rightDataConKey = mkPreludeDataConUnique 26
1218 -- Data constructor for Heterogeneous Metaprogramming code types
1219 hetMetCodeTypeDataConKey :: Unique
1220 hetMetCodeTypeDataConKey = mkPreludeDataConUnique 27
1223 %************************************************************************
1225 \subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}
1227 %************************************************************************
1230 absentErrorIdKey, augmentIdKey, appendIdKey, buildIdKey, errorIdKey,
1231 foldlIdKey, foldrIdKey, recSelErrorIdKey,
1232 integerMinusOneIdKey, integerPlusOneIdKey,
1233 integerPlusTwoIdKey, integerZeroIdKey,
1234 int2IntegerIdKey, seqIdKey, irrefutPatErrorIdKey, eqStringIdKey,
1235 noMethodBindingErrorIdKey, nonExhaustiveGuardsErrorIdKey,
1236 runtimeErrorIdKey, parErrorIdKey, parIdKey, patErrorIdKey,
1237 realWorldPrimIdKey, recConErrorIdKey, recUpdErrorIdKey,
1238 traceIdKey, wildCardKey,
1239 unpackCStringUtf8IdKey, unpackCStringAppendIdKey,
1240 unpackCStringFoldrIdKey, unpackCStringIdKey :: Unique
1241 wildCardKey = mkPreludeMiscIdUnique 0 -- See Note [WildCard]
1242 absentErrorIdKey = mkPreludeMiscIdUnique 1
1243 augmentIdKey = mkPreludeMiscIdUnique 3
1244 appendIdKey = mkPreludeMiscIdUnique 4
1245 buildIdKey = mkPreludeMiscIdUnique 5
1246 errorIdKey = mkPreludeMiscIdUnique 6
1247 foldlIdKey = mkPreludeMiscIdUnique 7
1248 foldrIdKey = mkPreludeMiscIdUnique 8
1249 recSelErrorIdKey = mkPreludeMiscIdUnique 9
1250 integerMinusOneIdKey = mkPreludeMiscIdUnique 10
1251 integerPlusOneIdKey = mkPreludeMiscIdUnique 11
1252 integerPlusTwoIdKey = mkPreludeMiscIdUnique 12
1253 integerZeroIdKey = mkPreludeMiscIdUnique 13
1254 int2IntegerIdKey = mkPreludeMiscIdUnique 14
1255 seqIdKey = mkPreludeMiscIdUnique 15
1256 irrefutPatErrorIdKey = mkPreludeMiscIdUnique 16
1257 eqStringIdKey = mkPreludeMiscIdUnique 17
1258 noMethodBindingErrorIdKey = mkPreludeMiscIdUnique 18
1259 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 19
1260 runtimeErrorIdKey = mkPreludeMiscIdUnique 20
1261 parErrorIdKey = mkPreludeMiscIdUnique 21
1262 parIdKey = mkPreludeMiscIdUnique 22
1263 patErrorIdKey = mkPreludeMiscIdUnique 23
1264 realWorldPrimIdKey = mkPreludeMiscIdUnique 24
1265 recConErrorIdKey = mkPreludeMiscIdUnique 25
1266 recUpdErrorIdKey = mkPreludeMiscIdUnique 26
1267 traceIdKey = mkPreludeMiscIdUnique 27
1268 unpackCStringUtf8IdKey = mkPreludeMiscIdUnique 28
1269 unpackCStringAppendIdKey = mkPreludeMiscIdUnique 29
1270 unpackCStringFoldrIdKey = mkPreludeMiscIdUnique 30
1271 unpackCStringIdKey = mkPreludeMiscIdUnique 31
1273 unsafeCoerceIdKey, concatIdKey, filterIdKey, zipIdKey, bindIOIdKey,
1274 returnIOIdKey, deRefStablePtrIdKey, newStablePtrIdKey,
1275 smallIntegerIdKey, plusIntegerIdKey, timesIntegerIdKey,
1276 printIdKey, failIOIdKey, nullAddrIdKey, voidArgIdKey,
1277 fstIdKey, sndIdKey, otherwiseIdKey, assertIdKey, runSTRepIdKey :: Unique
1278 unsafeCoerceIdKey = mkPreludeMiscIdUnique 32
1279 concatIdKey = mkPreludeMiscIdUnique 33
1280 filterIdKey = mkPreludeMiscIdUnique 34
1281 zipIdKey = mkPreludeMiscIdUnique 35
1282 bindIOIdKey = mkPreludeMiscIdUnique 36
1283 returnIOIdKey = mkPreludeMiscIdUnique 37
1284 deRefStablePtrIdKey = mkPreludeMiscIdUnique 38
1285 newStablePtrIdKey = mkPreludeMiscIdUnique 39
1286 smallIntegerIdKey = mkPreludeMiscIdUnique 40
1287 plusIntegerIdKey = mkPreludeMiscIdUnique 41
1288 timesIntegerIdKey = mkPreludeMiscIdUnique 42
1289 printIdKey = mkPreludeMiscIdUnique 43
1290 failIOIdKey = mkPreludeMiscIdUnique 44
1291 nullAddrIdKey = mkPreludeMiscIdUnique 46
1292 voidArgIdKey = mkPreludeMiscIdUnique 47
1293 fstIdKey = mkPreludeMiscIdUnique 49
1294 sndIdKey = mkPreludeMiscIdUnique 50
1295 otherwiseIdKey = mkPreludeMiscIdUnique 51
1296 assertIdKey = mkPreludeMiscIdUnique 53
1297 runSTRepIdKey = mkPreludeMiscIdUnique 54
1299 rootMainKey, runMainKey :: Unique
1300 rootMainKey = mkPreludeMiscIdUnique 55
1301 runMainKey = mkPreludeMiscIdUnique 56
1303 thenIOIdKey, lazyIdKey, assertErrorIdKey :: Unique
1304 thenIOIdKey = mkPreludeMiscIdUnique 59
1305 lazyIdKey = mkPreludeMiscIdUnique 60
1306 assertErrorIdKey = mkPreludeMiscIdUnique 61
1308 breakpointIdKey, breakpointCondIdKey, breakpointAutoIdKey,
1309 breakpointJumpIdKey, breakpointCondJumpIdKey,
1310 breakpointAutoJumpIdKey :: Unique
1311 breakpointIdKey = mkPreludeMiscIdUnique 62
1312 breakpointCondIdKey = mkPreludeMiscIdUnique 63
1313 breakpointAutoIdKey = mkPreludeMiscIdUnique 64
1314 breakpointJumpIdKey = mkPreludeMiscIdUnique 65
1315 breakpointCondJumpIdKey = mkPreludeMiscIdUnique 66
1316 breakpointAutoJumpIdKey = mkPreludeMiscIdUnique 67
1318 inlineIdKey :: Unique
1319 inlineIdKey = mkPreludeMiscIdUnique 68
1321 mapIdKey, groupWithIdKey, dollarIdKey :: Unique
1322 mapIdKey = mkPreludeMiscIdUnique 69
1323 groupWithIdKey = mkPreludeMiscIdUnique 70
1324 dollarIdKey = mkPreludeMiscIdUnique 71
1326 -- Parallel array functions
1327 singletonPIdKey, nullPIdKey, lengthPIdKey, replicatePIdKey, mapPIdKey,
1328 filterPIdKey, zipPIdKey, crossMapPIdKey, indexPIdKey, toPIdKey,
1329 enumFromToPIdKey, enumFromThenToPIdKey, emptyPIdKey, appPIdKey :: Unique
1330 singletonPIdKey = mkPreludeMiscIdUnique 79
1331 nullPIdKey = mkPreludeMiscIdUnique 80
1332 lengthPIdKey = mkPreludeMiscIdUnique 81
1333 replicatePIdKey = mkPreludeMiscIdUnique 82
1334 mapPIdKey = mkPreludeMiscIdUnique 83
1335 filterPIdKey = mkPreludeMiscIdUnique 84
1336 zipPIdKey = mkPreludeMiscIdUnique 85
1337 crossMapPIdKey = mkPreludeMiscIdUnique 86
1338 indexPIdKey = mkPreludeMiscIdUnique 87
1339 toPIdKey = mkPreludeMiscIdUnique 88
1340 enumFromToPIdKey = mkPreludeMiscIdUnique 89
1341 enumFromThenToPIdKey = mkPreludeMiscIdUnique 90
1342 emptyPIdKey = mkPreludeMiscIdUnique 91
1343 appPIdKey = mkPreludeMiscIdUnique 92
1346 unmarshalObjectIdKey, marshalObjectIdKey, marshalStringIdKey,
1347 unmarshalStringIdKey, checkDotnetResNameIdKey :: Unique
1348 unmarshalObjectIdKey = mkPreludeMiscIdUnique 94
1349 marshalObjectIdKey = mkPreludeMiscIdUnique 95
1350 marshalStringIdKey = mkPreludeMiscIdUnique 96
1351 unmarshalStringIdKey = mkPreludeMiscIdUnique 97
1352 checkDotnetResNameIdKey = mkPreludeMiscIdUnique 98
1356 Certain class operations from Prelude classes. They get their own
1357 uniques so we can look them up easily when we want to conjure them up
1358 during type checking.
1361 -- Just a place holder for unbound variables produced by the renamer:
1362 unboundKey :: Unique
1363 unboundKey = mkPreludeMiscIdUnique 101
1365 fromIntegerClassOpKey, minusClassOpKey, fromRationalClassOpKey,
1366 enumFromClassOpKey, enumFromThenClassOpKey, enumFromToClassOpKey,
1367 enumFromThenToClassOpKey, eqClassOpKey, geClassOpKey, negateClassOpKey,
1368 failMClassOpKey, bindMClassOpKey, thenMClassOpKey, returnMClassOpKey
1370 fromIntegerClassOpKey = mkPreludeMiscIdUnique 102
1371 minusClassOpKey = mkPreludeMiscIdUnique 103
1372 fromRationalClassOpKey = mkPreludeMiscIdUnique 104
1373 enumFromClassOpKey = mkPreludeMiscIdUnique 105
1374 enumFromThenClassOpKey = mkPreludeMiscIdUnique 106
1375 enumFromToClassOpKey = mkPreludeMiscIdUnique 107
1376 enumFromThenToClassOpKey = mkPreludeMiscIdUnique 108
1377 eqClassOpKey = mkPreludeMiscIdUnique 109
1378 geClassOpKey = mkPreludeMiscIdUnique 110
1379 negateClassOpKey = mkPreludeMiscIdUnique 111
1380 failMClassOpKey = mkPreludeMiscIdUnique 112
1381 bindMClassOpKey = mkPreludeMiscIdUnique 113 -- (>>=)
1382 thenMClassOpKey = mkPreludeMiscIdUnique 114 -- (>>)
1383 returnMClassOpKey = mkPreludeMiscIdUnique 117
1385 -- Recursive do notation
1387 mfixIdKey = mkPreludeMiscIdUnique 118
1390 arrAIdKey, composeAIdKey, firstAIdKey, appAIdKey, choiceAIdKey,
1391 loopAIdKey :: Unique
1392 arrAIdKey = mkPreludeMiscIdUnique 119
1393 composeAIdKey = mkPreludeMiscIdUnique 120 -- >>>
1394 firstAIdKey = mkPreludeMiscIdUnique 121
1395 appAIdKey = mkPreludeMiscIdUnique 122
1396 choiceAIdKey = mkPreludeMiscIdUnique 123 -- |||
1397 loopAIdKey = mkPreludeMiscIdUnique 124
1399 fromStringClassOpKey :: Unique
1400 fromStringClassOpKey = mkPreludeMiscIdUnique 125
1402 -- Annotation type checking
1403 toAnnotationWrapperIdKey :: Unique
1404 toAnnotationWrapperIdKey = mkPreludeMiscIdUnique 126
1406 -- Conversion functions
1407 fromIntegralIdKey, realToFracIdKey, toIntegerClassOpKey, toRationalClassOpKey :: Unique
1408 fromIntegralIdKey = mkPreludeMiscIdUnique 127
1409 realToFracIdKey = mkPreludeMiscIdUnique 128
1410 toIntegerClassOpKey = mkPreludeMiscIdUnique 129
1411 toRationalClassOpKey = mkPreludeMiscIdUnique 130
1414 hetmet_brak_key, hetmet_esc_key, hetmet_csp_key, hetmet_flatten_key, hetmet_unflatten_key, hetmet_flattened_id_key :: Unique
1415 hetmet_brak_key = mkPreludeMiscIdUnique 131
1416 hetmet_esc_key = mkPreludeMiscIdUnique 132
1417 hetmet_csp_key = mkPreludeMiscIdUnique 133
1418 hetmet_guest_integer_literal_key, hetmet_guest_string_literal_key, hetmet_guest_char_literal_key :: Unique
1419 hetmet_guest_integer_literal_key = mkPreludeMiscIdUnique 134
1420 hetmet_guest_string_literal_key = mkPreludeMiscIdUnique 135
1421 hetmet_guest_char_literal_key = mkPreludeMiscIdUnique 136
1422 hetmet_PGArrow_key :: Unique
1423 hetmet_PGArrow_key = mkPreludeMiscIdUnique 137
1424 hetmet_pga_id_key :: Unique
1425 hetmet_pga_id_key = mkPreludeMiscIdUnique 138
1426 hetmet_pga_comp_key :: Unique
1427 hetmet_pga_comp_key = mkPreludeMiscIdUnique 139
1428 hetmet_pga_first_key :: Unique
1429 hetmet_pga_first_key = mkPreludeMiscIdUnique 140
1430 hetmet_pga_second_key :: Unique
1431 hetmet_pga_second_key = mkPreludeMiscIdUnique 141
1432 hetmet_pga_cancell_key :: Unique
1433 hetmet_pga_cancell_key = mkPreludeMiscIdUnique 142
1434 hetmet_pga_cancelr_key :: Unique
1435 hetmet_pga_cancelr_key = mkPreludeMiscIdUnique 143
1436 hetmet_pga_uncancell_key :: Unique
1437 hetmet_pga_uncancell_key = mkPreludeMiscIdUnique 144
1438 hetmet_pga_uncancelr_key :: Unique
1439 hetmet_pga_uncancelr_key = mkPreludeMiscIdUnique 145
1440 hetmet_pga_assoc_key :: Unique
1441 hetmet_pga_assoc_key = mkPreludeMiscIdUnique 146
1442 hetmet_pga_unassoc_key :: Unique
1443 hetmet_pga_unassoc_key = mkPreludeMiscIdUnique 147
1444 hetmet_pga_copy_key :: Unique
1445 hetmet_pga_copy_key = mkPreludeMiscIdUnique 148
1446 hetmet_pga_drop_key :: Unique
1447 hetmet_pga_drop_key = mkPreludeMiscIdUnique 149
1448 hetmet_pga_swap_key :: Unique
1449 hetmet_pga_swap_key = mkPreludeMiscIdUnique 150
1450 hetmet_pga_applyl_key :: Unique
1451 hetmet_pga_applyl_key = mkPreludeMiscIdUnique 151
1452 hetmet_pga_applyr_key :: Unique
1453 hetmet_pga_applyr_key = mkPreludeMiscIdUnique 152
1454 hetmet_pga_curryl_key :: Unique
1455 hetmet_pga_curryl_key = mkPreludeMiscIdUnique 153
1456 hetmet_pga_curryr_key :: Unique
1457 hetmet_pga_curryr_key = mkPreludeMiscIdUnique 154
1458 hetmet_flatten_key = mkPreludeMiscIdUnique 155
1459 hetmet_unflatten_key = mkPreludeMiscIdUnique 156
1460 hetmet_flattened_id_key = mkPreludeMiscIdUnique 157
1464 ---------------- Template Haskell -------------------
1465 -- USES IdUniques 200-499
1466 -----------------------------------------------------
1470 %************************************************************************
1472 \subsection{Standard groups of types}
1474 %************************************************************************
1477 numericTyKeys :: [Unique]
1486 kindKeys :: [Unique]
1487 kindKeys = [ liftedTypeKindTyConKey
1488 , openTypeKindTyConKey
1489 , unliftedTypeKindTyConKey
1490 , ubxTupleKindTyConKey
1491 , argTypeKindTyConKey ]
1495 %************************************************************************
1497 \subsection[Class-std-groups]{Standard groups of Prelude classes}
1499 %************************************************************************
1501 NOTE: @Eq@ and @Text@ do need to appear in @standardClasses@
1502 even though every numeric class has these two as a superclass,
1503 because the list of ambiguous dictionaries hasn't been simplified.
1506 numericClassKeys :: [Unique]
1512 ++ fractionalClassKeys
1514 fractionalClassKeys :: [Unique]
1515 fractionalClassKeys =
1516 [ fractionalClassKey
1522 -- the strictness analyser needs to know about numeric types
1523 -- (see SaAbsInt.lhs)
1524 needsDataDeclCtxtClassKeys :: [Unique]
1525 needsDataDeclCtxtClassKeys = -- see comments in TcDeriv
1529 -- The "standard classes" are used in defaulting (Haskell 98 report 4.3.4),
1530 -- and are: "classes defined in the Prelude or a standard library"
1531 standardClassKeys :: [Unique]
1532 standardClassKeys = derivableClassKeys ++ numericClassKeys
1533 ++ [randomClassKey, randomGenClassKey,
1535 monadClassKey, monadPlusClassKey,
1537 applicativeClassKey, foldableClassKey, traversableClassKey
1541 @derivableClassKeys@ is also used in checking \tr{deriving} constructs
1545 derivableClassKeys :: [Unique]
1547 = [ eqClassKey, ordClassKey, enumClassKey, ixClassKey,
1548 boundedClassKey, showClassKey, readClassKey ]