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_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_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_flattened_id_name = varQual gHC_HETMET_CODETYPES (fsLit "pga_flattened_id") hetmet_flattened_id_key
813 hetmet_guest_integer_literal_name = varQual gHC_HETMET_CODETYPES (fsLit "guestIntegerLiteral") hetmet_guest_integer_literal_key
814 hetmet_guest_string_literal_name = varQual gHC_HETMET_CODETYPES (fsLit "guestStringLiteral") hetmet_guest_string_literal_key
815 hetmet_guest_char_literal_name = varQual gHC_HETMET_CODETYPES (fsLit "guestCharLiteral") hetmet_guest_char_literal_key
817 hetmet_PGArrow_name :: Name
818 hetmet_PGArrow_name = tcQual gHC_HETMET_PRIVATE (fsLit "PGArrow") hetmet_PGArrow_key
819 hetmet_pga_id_name :: Name
820 hetmet_pga_id_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_id") hetmet_pga_id_key
821 hetmet_pga_comp_name :: Name
822 hetmet_pga_comp_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_comp") hetmet_pga_comp_key
823 hetmet_pga_first_name :: Name
824 hetmet_pga_first_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_first") hetmet_pga_first_key
825 hetmet_pga_second_name :: Name
826 hetmet_pga_second_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_second") hetmet_pga_second_key
827 hetmet_pga_cancell_name :: Name
828 hetmet_pga_cancell_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_cancell") hetmet_pga_cancell_key
829 hetmet_pga_cancelr_name :: Name
830 hetmet_pga_cancelr_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_cancelr") hetmet_pga_cancelr_key
831 hetmet_pga_uncancell_name :: Name
832 hetmet_pga_uncancell_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_uncancell") hetmet_pga_uncancell_key
833 hetmet_pga_uncancelr_name :: Name
834 hetmet_pga_uncancelr_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_uncancelr") hetmet_pga_uncancelr_key
835 hetmet_pga_assoc_name :: Name
836 hetmet_pga_assoc_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_assoc") hetmet_pga_assoc_key
837 hetmet_pga_unassoc_name :: Name
838 hetmet_pga_unassoc_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_unassoc") hetmet_pga_unassoc_key
839 hetmet_pga_copy_name :: Name
840 hetmet_pga_copy_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_copy") hetmet_pga_copy_key
841 hetmet_pga_drop_name :: Name
842 hetmet_pga_drop_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_drop") hetmet_pga_drop_key
843 hetmet_pga_swap_name :: Name
844 hetmet_pga_swap_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_swap") hetmet_pga_swap_key
845 hetmet_pga_applyl_name :: Name
846 hetmet_pga_applyl_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_applyl") hetmet_pga_applyl_key
847 hetmet_pga_applyr_name :: Name
848 hetmet_pga_applyr_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_applyr") hetmet_pga_applyr_key
849 hetmet_pga_curryl_name :: Name
850 hetmet_pga_curryl_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_curryl") hetmet_pga_curryl_key
851 hetmet_pga_curryr_name :: Name
852 hetmet_pga_curryr_name = varQual gHC_HETMET_PRIVATE (fsLit "pga_curryr") hetmet_pga_curryr_key
855 ioTyConName, ioDataConName, thenIOName, bindIOName, returnIOName,
857 ioTyConName = tcQual gHC_TYPES (fsLit "IO") ioTyConKey
858 ioDataConName = conName gHC_TYPES (fsLit "IO") ioDataConKey
859 thenIOName = varQual gHC_BASE (fsLit "thenIO") thenIOIdKey
860 bindIOName = varQual gHC_BASE (fsLit "bindIO") bindIOIdKey
861 returnIOName = varQual gHC_BASE (fsLit "returnIO") returnIOIdKey
862 failIOName = varQual gHC_IO (fsLit "failIO") failIOIdKey
866 printName = varQual sYSTEM_IO (fsLit "print") printIdKey
868 -- Int, Word, and Addr things
869 int8TyConName, int16TyConName, int32TyConName, int64TyConName :: Name
870 int8TyConName = tcQual gHC_INT (fsLit "Int8") int8TyConKey
871 int16TyConName = tcQual gHC_INT (fsLit "Int16") int16TyConKey
872 int32TyConName = tcQual gHC_INT (fsLit "Int32") int32TyConKey
873 int64TyConName = tcQual gHC_INT (fsLit "Int64") int64TyConKey
876 word8TyConName, word16TyConName, word32TyConName, word64TyConName,
877 wordTyConName, wordDataConName :: Name
878 word8TyConName = tcQual gHC_WORD (fsLit "Word8") word8TyConKey
879 word16TyConName = tcQual gHC_WORD (fsLit "Word16") word16TyConKey
880 word32TyConName = tcQual gHC_WORD (fsLit "Word32") word32TyConKey
881 word64TyConName = tcQual gHC_WORD (fsLit "Word64") word64TyConKey
882 wordTyConName = tcQual gHC_WORD (fsLit "Word") wordTyConKey
883 wordDataConName = conName gHC_WORD (fsLit "W#") wordDataConKey
886 ptrTyConName, funPtrTyConName :: Name
887 ptrTyConName = tcQual gHC_PTR (fsLit "Ptr") ptrTyConKey
888 funPtrTyConName = tcQual gHC_PTR (fsLit "FunPtr") funPtrTyConKey
890 -- Foreign objects and weak pointers
891 stablePtrTyConName, newStablePtrName :: Name
892 stablePtrTyConName = tcQual gHC_STABLE (fsLit "StablePtr") stablePtrTyConKey
893 newStablePtrName = varQual gHC_STABLE (fsLit "newStablePtr") newStablePtrIdKey
897 runSTRepName = varQual gHC_ST (fsLit "runSTRep") runSTRepIdKey
899 -- Recursive-do notation
900 monadFixClassName, mfixName :: Name
901 monadFixClassName = clsQual mONAD_FIX (fsLit "MonadFix") monadFixClassKey
902 mfixName = methName mONAD_FIX (fsLit "mfix") mfixIdKey
905 arrAName, composeAName, firstAName, appAName, choiceAName, loopAName :: Name
906 arrAName = varQual aRROW (fsLit "arr") arrAIdKey
907 composeAName = varQual gHC_DESUGAR (fsLit ">>>") composeAIdKey
908 firstAName = varQual aRROW (fsLit "first") firstAIdKey
909 appAName = varQual aRROW (fsLit "app") appAIdKey
910 choiceAName = varQual aRROW (fsLit "|||") choiceAIdKey
911 loopAName = varQual aRROW (fsLit "loop") loopAIdKey
913 -- Annotation type checking
914 toAnnotationWrapperName :: Name
915 toAnnotationWrapperName = varQual gHC_DESUGAR (fsLit "toAnnotationWrapper") toAnnotationWrapperIdKey
917 -- Other classes, needed for type defaulting
918 monadPlusClassName, randomClassName, randomGenClassName,
919 isStringClassName :: Name
920 monadPlusClassName = clsQual mONAD (fsLit "MonadPlus") monadPlusClassKey
921 randomClassName = clsQual rANDOM (fsLit "Random") randomClassKey
922 randomGenClassName = clsQual rANDOM (fsLit "RandomGen") randomGenClassKey
923 isStringClassName = clsQual dATA_STRING (fsLit "IsString") isStringClassKey
926 objectTyConName :: Name
927 objectTyConName = tcQual dOTNET (fsLit "Object") objectTyConKey
928 -- objectTyConName was "wTcQual", but that's gone now, and
929 -- I can't see why it was wired in anyway...
930 unmarshalObjectName, marshalObjectName, marshalStringName,
931 unmarshalStringName, checkDotnetResName :: Name
932 unmarshalObjectName = varQual dOTNET (fsLit "unmarshalObject") unmarshalObjectIdKey
933 marshalObjectName = varQual dOTNET (fsLit "marshalObject") marshalObjectIdKey
934 marshalStringName = varQual dOTNET (fsLit "marshalString") marshalStringIdKey
935 unmarshalStringName = varQual dOTNET (fsLit "unmarshalString") unmarshalStringIdKey
936 checkDotnetResName = varQual dOTNET (fsLit "checkResult") checkDotnetResNameIdKey
939 %************************************************************************
941 \subsection{Local helpers}
943 %************************************************************************
945 All these are original names; hence mkOrig
948 varQual, tcQual, clsQual :: Module -> FastString -> Unique -> Name
949 varQual = mk_known_key_name varName
950 tcQual = mk_known_key_name tcName
951 clsQual = mk_known_key_name clsName
953 mk_known_key_name :: NameSpace -> Module -> FastString -> Unique -> Name
954 mk_known_key_name space modu str unique
955 = mkExternalName unique modu (mkOccNameFS space str) noSrcSpan
957 conName :: Module -> FastString -> Unique -> Name
958 conName modu occ unique
959 = mkExternalName unique modu (mkOccNameFS dataName occ) noSrcSpan
961 methName :: Module -> FastString -> Unique -> Name
962 methName modu occ unique
963 = mkExternalName unique modu (mkVarOccFS occ) noSrcSpan
966 %************************************************************************
968 \subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@}
970 %************************************************************************
971 --MetaHaskell extension hand allocate keys here
974 boundedClassKey, enumClassKey, eqClassKey, floatingClassKey,
975 fractionalClassKey, integralClassKey, monadClassKey, dataClassKey,
976 functorClassKey, numClassKey, ordClassKey, readClassKey, realClassKey,
977 realFloatClassKey, realFracClassKey, showClassKey, ixClassKey :: Unique
978 boundedClassKey = mkPreludeClassUnique 1
979 enumClassKey = mkPreludeClassUnique 2
980 eqClassKey = mkPreludeClassUnique 3
981 floatingClassKey = mkPreludeClassUnique 5
982 fractionalClassKey = mkPreludeClassUnique 6
983 integralClassKey = mkPreludeClassUnique 7
984 monadClassKey = mkPreludeClassUnique 8
985 dataClassKey = mkPreludeClassUnique 9
986 functorClassKey = mkPreludeClassUnique 10
987 numClassKey = mkPreludeClassUnique 11
988 ordClassKey = mkPreludeClassUnique 12
989 readClassKey = mkPreludeClassUnique 13
990 realClassKey = mkPreludeClassUnique 14
991 realFloatClassKey = mkPreludeClassUnique 15
992 realFracClassKey = mkPreludeClassUnique 16
993 showClassKey = mkPreludeClassUnique 17
994 ixClassKey = mkPreludeClassUnique 18
996 typeableClassKey, typeable1ClassKey, typeable2ClassKey, typeable3ClassKey,
997 typeable4ClassKey, typeable5ClassKey, typeable6ClassKey, typeable7ClassKey
999 typeableClassKey = mkPreludeClassUnique 20
1000 typeable1ClassKey = mkPreludeClassUnique 21
1001 typeable2ClassKey = mkPreludeClassUnique 22
1002 typeable3ClassKey = mkPreludeClassUnique 23
1003 typeable4ClassKey = mkPreludeClassUnique 24
1004 typeable5ClassKey = mkPreludeClassUnique 25
1005 typeable6ClassKey = mkPreludeClassUnique 26
1006 typeable7ClassKey = mkPreludeClassUnique 27
1008 monadFixClassKey :: Unique
1009 monadFixClassKey = mkPreludeClassUnique 28
1011 monadPlusClassKey, randomClassKey, randomGenClassKey :: Unique
1012 monadPlusClassKey = mkPreludeClassUnique 30
1013 randomClassKey = mkPreludeClassUnique 31
1014 randomGenClassKey = mkPreludeClassUnique 32
1016 isStringClassKey :: Unique
1017 isStringClassKey = mkPreludeClassUnique 33
1019 applicativeClassKey, foldableClassKey, traversableClassKey :: Unique
1020 applicativeClassKey = mkPreludeClassUnique 34
1021 foldableClassKey = mkPreludeClassUnique 35
1022 traversableClassKey = mkPreludeClassUnique 36
1025 %************************************************************************
1027 \subsubsection[Uniques-prelude-TyCons]{@Uniques@ for wired-in @TyCons@}
1029 %************************************************************************
1032 addrPrimTyConKey, arrayPrimTyConKey, boolTyConKey, byteArrayPrimTyConKey,
1033 charPrimTyConKey, charTyConKey, doublePrimTyConKey, doubleTyConKey,
1034 floatPrimTyConKey, floatTyConKey, funTyConKey, intPrimTyConKey,
1035 intTyConKey, int8TyConKey, int16TyConKey, int32PrimTyConKey,
1036 int32TyConKey, int64PrimTyConKey, int64TyConKey, integerTyConKey,
1037 listTyConKey, foreignObjPrimTyConKey, weakPrimTyConKey,
1038 mutableArrayPrimTyConKey, mutableByteArrayPrimTyConKey,
1039 orderingTyConKey, mVarPrimTyConKey, ratioTyConKey, rationalTyConKey,
1040 realWorldTyConKey, stablePtrPrimTyConKey, stablePtrTyConKey,
1041 anyTyConKey :: Unique
1042 addrPrimTyConKey = mkPreludeTyConUnique 1
1043 arrayPrimTyConKey = mkPreludeTyConUnique 3
1044 boolTyConKey = mkPreludeTyConUnique 4
1045 byteArrayPrimTyConKey = mkPreludeTyConUnique 5
1046 charPrimTyConKey = mkPreludeTyConUnique 7
1047 charTyConKey = mkPreludeTyConUnique 8
1048 doublePrimTyConKey = mkPreludeTyConUnique 9
1049 doubleTyConKey = mkPreludeTyConUnique 10
1050 floatPrimTyConKey = mkPreludeTyConUnique 11
1051 floatTyConKey = mkPreludeTyConUnique 12
1052 funTyConKey = mkPreludeTyConUnique 13
1053 intPrimTyConKey = mkPreludeTyConUnique 14
1054 intTyConKey = mkPreludeTyConUnique 15
1055 int8TyConKey = mkPreludeTyConUnique 16
1056 int16TyConKey = mkPreludeTyConUnique 17
1057 int32PrimTyConKey = mkPreludeTyConUnique 18
1058 int32TyConKey = mkPreludeTyConUnique 19
1059 int64PrimTyConKey = mkPreludeTyConUnique 20
1060 int64TyConKey = mkPreludeTyConUnique 21
1061 integerTyConKey = mkPreludeTyConUnique 22
1062 listTyConKey = mkPreludeTyConUnique 23
1063 foreignObjPrimTyConKey = mkPreludeTyConUnique 24
1064 weakPrimTyConKey = mkPreludeTyConUnique 27
1065 mutableArrayPrimTyConKey = mkPreludeTyConUnique 28
1066 mutableByteArrayPrimTyConKey = mkPreludeTyConUnique 29
1067 orderingTyConKey = mkPreludeTyConUnique 30
1068 mVarPrimTyConKey = mkPreludeTyConUnique 31
1069 ratioTyConKey = mkPreludeTyConUnique 32
1070 rationalTyConKey = mkPreludeTyConUnique 33
1071 realWorldTyConKey = mkPreludeTyConUnique 34
1072 stablePtrPrimTyConKey = mkPreludeTyConUnique 35
1073 stablePtrTyConKey = mkPreludeTyConUnique 36
1074 anyTyConKey = mkPreludeTyConUnique 37
1076 statePrimTyConKey, stableNamePrimTyConKey, stableNameTyConKey,
1077 mutVarPrimTyConKey, ioTyConKey,
1078 wordPrimTyConKey, wordTyConKey, word8TyConKey, word16TyConKey,
1079 word32PrimTyConKey, word32TyConKey, word64PrimTyConKey, word64TyConKey,
1080 liftedConKey, unliftedConKey, anyBoxConKey, kindConKey, boxityConKey,
1081 typeConKey, threadIdPrimTyConKey, bcoPrimTyConKey, ptrTyConKey,
1082 funPtrTyConKey, tVarPrimTyConKey :: Unique
1083 statePrimTyConKey = mkPreludeTyConUnique 50
1084 stableNamePrimTyConKey = mkPreludeTyConUnique 51
1085 stableNameTyConKey = mkPreludeTyConUnique 52
1086 mutVarPrimTyConKey = mkPreludeTyConUnique 55
1087 ioTyConKey = mkPreludeTyConUnique 56
1088 wordPrimTyConKey = mkPreludeTyConUnique 58
1089 wordTyConKey = mkPreludeTyConUnique 59
1090 word8TyConKey = mkPreludeTyConUnique 60
1091 word16TyConKey = mkPreludeTyConUnique 61
1092 word32PrimTyConKey = mkPreludeTyConUnique 62
1093 word32TyConKey = mkPreludeTyConUnique 63
1094 word64PrimTyConKey = mkPreludeTyConUnique 64
1095 word64TyConKey = mkPreludeTyConUnique 65
1096 liftedConKey = mkPreludeTyConUnique 66
1097 unliftedConKey = mkPreludeTyConUnique 67
1098 anyBoxConKey = mkPreludeTyConUnique 68
1099 kindConKey = mkPreludeTyConUnique 69
1100 boxityConKey = mkPreludeTyConUnique 70
1101 typeConKey = mkPreludeTyConUnique 71
1102 threadIdPrimTyConKey = mkPreludeTyConUnique 72
1103 bcoPrimTyConKey = mkPreludeTyConUnique 73
1104 ptrTyConKey = mkPreludeTyConUnique 74
1105 funPtrTyConKey = mkPreludeTyConUnique 75
1106 tVarPrimTyConKey = mkPreludeTyConUnique 76
1108 -- Generic Type Constructors
1109 crossTyConKey, plusTyConKey, genUnitTyConKey :: Unique
1110 crossTyConKey = mkPreludeTyConUnique 79
1111 plusTyConKey = mkPreludeTyConUnique 80
1112 genUnitTyConKey = mkPreludeTyConUnique 81
1114 -- Parallel array type constructor
1115 parrTyConKey :: Unique
1116 parrTyConKey = mkPreludeTyConUnique 82
1119 objectTyConKey :: Unique
1120 objectTyConKey = mkPreludeTyConUnique 83
1122 eitherTyConKey :: Unique
1123 eitherTyConKey = mkPreludeTyConUnique 84
1125 -- Super Kinds constructors
1126 tySuperKindTyConKey, coSuperKindTyConKey :: Unique
1127 tySuperKindTyConKey = mkPreludeTyConUnique 85
1128 coSuperKindTyConKey = mkPreludeTyConUnique 86
1130 -- Kind constructors
1131 liftedTypeKindTyConKey, openTypeKindTyConKey, unliftedTypeKindTyConKey,
1132 ubxTupleKindTyConKey, argTypeKindTyConKey :: Unique
1133 liftedTypeKindTyConKey = mkPreludeTyConUnique 87
1134 openTypeKindTyConKey = mkPreludeTyConUnique 88
1135 unliftedTypeKindTyConKey = mkPreludeTyConUnique 89
1136 ubxTupleKindTyConKey = mkPreludeTyConUnique 90
1137 argTypeKindTyConKey = mkPreludeTyConUnique 91
1139 -- Coercion constructors
1140 symCoercionTyConKey, transCoercionTyConKey, leftCoercionTyConKey,
1141 rightCoercionTyConKey, instCoercionTyConKey, unsafeCoercionTyConKey,
1142 csel1CoercionTyConKey, csel2CoercionTyConKey, cselRCoercionTyConKey
1144 symCoercionTyConKey = mkPreludeTyConUnique 93
1145 transCoercionTyConKey = mkPreludeTyConUnique 94
1146 leftCoercionTyConKey = mkPreludeTyConUnique 95
1147 rightCoercionTyConKey = mkPreludeTyConUnique 96
1148 instCoercionTyConKey = mkPreludeTyConUnique 97
1149 unsafeCoercionTyConKey = mkPreludeTyConUnique 98
1150 csel1CoercionTyConKey = mkPreludeTyConUnique 99
1151 csel2CoercionTyConKey = mkPreludeTyConUnique 100
1152 cselRCoercionTyConKey = mkPreludeTyConUnique 101
1154 unknownTyConKey, unknown1TyConKey, unknown2TyConKey, unknown3TyConKey,
1155 opaqueTyConKey :: Unique
1156 unknownTyConKey = mkPreludeTyConUnique 129
1157 unknown1TyConKey = mkPreludeTyConUnique 130
1158 unknown2TyConKey = mkPreludeTyConUnique 131
1159 unknown3TyConKey = mkPreludeTyConUnique 132
1160 opaqueTyConKey = mkPreludeTyConUnique 133
1162 stringTyConKey :: Unique
1163 stringTyConKey = mkPreludeTyConUnique 134
1165 -- Heterogeneous Metaprogramming code type constructor
1166 hetMetCodeTypeTyConKey :: Unique
1167 hetMetCodeTypeTyConKey = mkPreludeTyConUnique 135
1169 ---------------- Template Haskell -------------------
1170 -- USES TyConUniques 200-299
1171 -----------------------------------------------------
1173 unitTyConKey :: Unique
1174 unitTyConKey = mkTupleTyConUnique Boxed 0
1177 %************************************************************************
1179 \subsubsection[Uniques-prelude-DataCons]{@Uniques@ for wired-in @DataCons@}
1181 %************************************************************************
1184 charDataConKey, consDataConKey, doubleDataConKey, falseDataConKey,
1185 floatDataConKey, intDataConKey, nilDataConKey, ratioDataConKey,
1186 stableNameDataConKey, trueDataConKey, wordDataConKey,
1187 ioDataConKey, integerDataConKey :: Unique
1188 charDataConKey = mkPreludeDataConUnique 1
1189 consDataConKey = mkPreludeDataConUnique 2
1190 doubleDataConKey = mkPreludeDataConUnique 3
1191 falseDataConKey = mkPreludeDataConUnique 4
1192 floatDataConKey = mkPreludeDataConUnique 5
1193 intDataConKey = mkPreludeDataConUnique 6
1194 nilDataConKey = mkPreludeDataConUnique 11
1195 ratioDataConKey = mkPreludeDataConUnique 12
1196 stableNameDataConKey = mkPreludeDataConUnique 14
1197 trueDataConKey = mkPreludeDataConUnique 15
1198 wordDataConKey = mkPreludeDataConUnique 16
1199 ioDataConKey = mkPreludeDataConUnique 17
1200 integerDataConKey = mkPreludeDataConUnique 18
1202 -- Generic data constructors
1203 crossDataConKey, inlDataConKey, inrDataConKey, genUnitDataConKey :: Unique
1204 crossDataConKey = mkPreludeDataConUnique 20
1205 inlDataConKey = mkPreludeDataConUnique 21
1206 inrDataConKey = mkPreludeDataConUnique 22
1207 genUnitDataConKey = mkPreludeDataConUnique 23
1209 -- Data constructor for parallel arrays
1210 parrDataConKey :: Unique
1211 parrDataConKey = mkPreludeDataConUnique 24
1213 leftDataConKey, rightDataConKey :: Unique
1214 leftDataConKey = mkPreludeDataConUnique 25
1215 rightDataConKey = mkPreludeDataConUnique 26
1217 -- Data constructor for Heterogeneous Metaprogramming code types
1218 hetMetCodeTypeDataConKey :: Unique
1219 hetMetCodeTypeDataConKey = mkPreludeDataConUnique 27
1222 %************************************************************************
1224 \subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}
1226 %************************************************************************
1229 absentErrorIdKey, augmentIdKey, appendIdKey, buildIdKey, errorIdKey,
1230 foldlIdKey, foldrIdKey, recSelErrorIdKey,
1231 integerMinusOneIdKey, integerPlusOneIdKey,
1232 integerPlusTwoIdKey, integerZeroIdKey,
1233 int2IntegerIdKey, seqIdKey, irrefutPatErrorIdKey, eqStringIdKey,
1234 noMethodBindingErrorIdKey, nonExhaustiveGuardsErrorIdKey,
1235 runtimeErrorIdKey, parErrorIdKey, parIdKey, patErrorIdKey,
1236 realWorldPrimIdKey, recConErrorIdKey, recUpdErrorIdKey,
1237 traceIdKey, wildCardKey,
1238 unpackCStringUtf8IdKey, unpackCStringAppendIdKey,
1239 unpackCStringFoldrIdKey, unpackCStringIdKey :: Unique
1240 wildCardKey = mkPreludeMiscIdUnique 0 -- See Note [WildCard]
1241 absentErrorIdKey = mkPreludeMiscIdUnique 1
1242 augmentIdKey = mkPreludeMiscIdUnique 3
1243 appendIdKey = mkPreludeMiscIdUnique 4
1244 buildIdKey = mkPreludeMiscIdUnique 5
1245 errorIdKey = mkPreludeMiscIdUnique 6
1246 foldlIdKey = mkPreludeMiscIdUnique 7
1247 foldrIdKey = mkPreludeMiscIdUnique 8
1248 recSelErrorIdKey = mkPreludeMiscIdUnique 9
1249 integerMinusOneIdKey = mkPreludeMiscIdUnique 10
1250 integerPlusOneIdKey = mkPreludeMiscIdUnique 11
1251 integerPlusTwoIdKey = mkPreludeMiscIdUnique 12
1252 integerZeroIdKey = mkPreludeMiscIdUnique 13
1253 int2IntegerIdKey = mkPreludeMiscIdUnique 14
1254 seqIdKey = mkPreludeMiscIdUnique 15
1255 irrefutPatErrorIdKey = mkPreludeMiscIdUnique 16
1256 eqStringIdKey = mkPreludeMiscIdUnique 17
1257 noMethodBindingErrorIdKey = mkPreludeMiscIdUnique 18
1258 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 19
1259 runtimeErrorIdKey = mkPreludeMiscIdUnique 20
1260 parErrorIdKey = mkPreludeMiscIdUnique 21
1261 parIdKey = mkPreludeMiscIdUnique 22
1262 patErrorIdKey = mkPreludeMiscIdUnique 23
1263 realWorldPrimIdKey = mkPreludeMiscIdUnique 24
1264 recConErrorIdKey = mkPreludeMiscIdUnique 25
1265 recUpdErrorIdKey = mkPreludeMiscIdUnique 26
1266 traceIdKey = mkPreludeMiscIdUnique 27
1267 unpackCStringUtf8IdKey = mkPreludeMiscIdUnique 28
1268 unpackCStringAppendIdKey = mkPreludeMiscIdUnique 29
1269 unpackCStringFoldrIdKey = mkPreludeMiscIdUnique 30
1270 unpackCStringIdKey = mkPreludeMiscIdUnique 31
1272 unsafeCoerceIdKey, concatIdKey, filterIdKey, zipIdKey, bindIOIdKey,
1273 returnIOIdKey, deRefStablePtrIdKey, newStablePtrIdKey,
1274 smallIntegerIdKey, plusIntegerIdKey, timesIntegerIdKey,
1275 printIdKey, failIOIdKey, nullAddrIdKey, voidArgIdKey,
1276 fstIdKey, sndIdKey, otherwiseIdKey, assertIdKey, runSTRepIdKey :: Unique
1277 unsafeCoerceIdKey = mkPreludeMiscIdUnique 32
1278 concatIdKey = mkPreludeMiscIdUnique 33
1279 filterIdKey = mkPreludeMiscIdUnique 34
1280 zipIdKey = mkPreludeMiscIdUnique 35
1281 bindIOIdKey = mkPreludeMiscIdUnique 36
1282 returnIOIdKey = mkPreludeMiscIdUnique 37
1283 deRefStablePtrIdKey = mkPreludeMiscIdUnique 38
1284 newStablePtrIdKey = mkPreludeMiscIdUnique 39
1285 smallIntegerIdKey = mkPreludeMiscIdUnique 40
1286 plusIntegerIdKey = mkPreludeMiscIdUnique 41
1287 timesIntegerIdKey = mkPreludeMiscIdUnique 42
1288 printIdKey = mkPreludeMiscIdUnique 43
1289 failIOIdKey = mkPreludeMiscIdUnique 44
1290 nullAddrIdKey = mkPreludeMiscIdUnique 46
1291 voidArgIdKey = mkPreludeMiscIdUnique 47
1292 fstIdKey = mkPreludeMiscIdUnique 49
1293 sndIdKey = mkPreludeMiscIdUnique 50
1294 otherwiseIdKey = mkPreludeMiscIdUnique 51
1295 assertIdKey = mkPreludeMiscIdUnique 53
1296 runSTRepIdKey = mkPreludeMiscIdUnique 54
1298 rootMainKey, runMainKey :: Unique
1299 rootMainKey = mkPreludeMiscIdUnique 55
1300 runMainKey = mkPreludeMiscIdUnique 56
1302 thenIOIdKey, lazyIdKey, assertErrorIdKey :: Unique
1303 thenIOIdKey = mkPreludeMiscIdUnique 59
1304 lazyIdKey = mkPreludeMiscIdUnique 60
1305 assertErrorIdKey = mkPreludeMiscIdUnique 61
1307 breakpointIdKey, breakpointCondIdKey, breakpointAutoIdKey,
1308 breakpointJumpIdKey, breakpointCondJumpIdKey,
1309 breakpointAutoJumpIdKey :: Unique
1310 breakpointIdKey = mkPreludeMiscIdUnique 62
1311 breakpointCondIdKey = mkPreludeMiscIdUnique 63
1312 breakpointAutoIdKey = mkPreludeMiscIdUnique 64
1313 breakpointJumpIdKey = mkPreludeMiscIdUnique 65
1314 breakpointCondJumpIdKey = mkPreludeMiscIdUnique 66
1315 breakpointAutoJumpIdKey = mkPreludeMiscIdUnique 67
1317 inlineIdKey :: Unique
1318 inlineIdKey = mkPreludeMiscIdUnique 68
1320 mapIdKey, groupWithIdKey, dollarIdKey :: Unique
1321 mapIdKey = mkPreludeMiscIdUnique 69
1322 groupWithIdKey = mkPreludeMiscIdUnique 70
1323 dollarIdKey = mkPreludeMiscIdUnique 71
1325 -- Parallel array functions
1326 singletonPIdKey, nullPIdKey, lengthPIdKey, replicatePIdKey, mapPIdKey,
1327 filterPIdKey, zipPIdKey, crossMapPIdKey, indexPIdKey, toPIdKey,
1328 enumFromToPIdKey, enumFromThenToPIdKey, emptyPIdKey, appPIdKey :: Unique
1329 singletonPIdKey = mkPreludeMiscIdUnique 79
1330 nullPIdKey = mkPreludeMiscIdUnique 80
1331 lengthPIdKey = mkPreludeMiscIdUnique 81
1332 replicatePIdKey = mkPreludeMiscIdUnique 82
1333 mapPIdKey = mkPreludeMiscIdUnique 83
1334 filterPIdKey = mkPreludeMiscIdUnique 84
1335 zipPIdKey = mkPreludeMiscIdUnique 85
1336 crossMapPIdKey = mkPreludeMiscIdUnique 86
1337 indexPIdKey = mkPreludeMiscIdUnique 87
1338 toPIdKey = mkPreludeMiscIdUnique 88
1339 enumFromToPIdKey = mkPreludeMiscIdUnique 89
1340 enumFromThenToPIdKey = mkPreludeMiscIdUnique 90
1341 emptyPIdKey = mkPreludeMiscIdUnique 91
1342 appPIdKey = mkPreludeMiscIdUnique 92
1345 unmarshalObjectIdKey, marshalObjectIdKey, marshalStringIdKey,
1346 unmarshalStringIdKey, checkDotnetResNameIdKey :: Unique
1347 unmarshalObjectIdKey = mkPreludeMiscIdUnique 94
1348 marshalObjectIdKey = mkPreludeMiscIdUnique 95
1349 marshalStringIdKey = mkPreludeMiscIdUnique 96
1350 unmarshalStringIdKey = mkPreludeMiscIdUnique 97
1351 checkDotnetResNameIdKey = mkPreludeMiscIdUnique 98
1355 Certain class operations from Prelude classes. They get their own
1356 uniques so we can look them up easily when we want to conjure them up
1357 during type checking.
1360 -- Just a place holder for unbound variables produced by the renamer:
1361 unboundKey :: Unique
1362 unboundKey = mkPreludeMiscIdUnique 101
1364 fromIntegerClassOpKey, minusClassOpKey, fromRationalClassOpKey,
1365 enumFromClassOpKey, enumFromThenClassOpKey, enumFromToClassOpKey,
1366 enumFromThenToClassOpKey, eqClassOpKey, geClassOpKey, negateClassOpKey,
1367 failMClassOpKey, bindMClassOpKey, thenMClassOpKey, returnMClassOpKey
1369 fromIntegerClassOpKey = mkPreludeMiscIdUnique 102
1370 minusClassOpKey = mkPreludeMiscIdUnique 103
1371 fromRationalClassOpKey = mkPreludeMiscIdUnique 104
1372 enumFromClassOpKey = mkPreludeMiscIdUnique 105
1373 enumFromThenClassOpKey = mkPreludeMiscIdUnique 106
1374 enumFromToClassOpKey = mkPreludeMiscIdUnique 107
1375 enumFromThenToClassOpKey = mkPreludeMiscIdUnique 108
1376 eqClassOpKey = mkPreludeMiscIdUnique 109
1377 geClassOpKey = mkPreludeMiscIdUnique 110
1378 negateClassOpKey = mkPreludeMiscIdUnique 111
1379 failMClassOpKey = mkPreludeMiscIdUnique 112
1380 bindMClassOpKey = mkPreludeMiscIdUnique 113 -- (>>=)
1381 thenMClassOpKey = mkPreludeMiscIdUnique 114 -- (>>)
1382 returnMClassOpKey = mkPreludeMiscIdUnique 117
1384 -- Recursive do notation
1386 mfixIdKey = mkPreludeMiscIdUnique 118
1389 arrAIdKey, composeAIdKey, firstAIdKey, appAIdKey, choiceAIdKey,
1390 loopAIdKey :: Unique
1391 arrAIdKey = mkPreludeMiscIdUnique 119
1392 composeAIdKey = mkPreludeMiscIdUnique 120 -- >>>
1393 firstAIdKey = mkPreludeMiscIdUnique 121
1394 appAIdKey = mkPreludeMiscIdUnique 122
1395 choiceAIdKey = mkPreludeMiscIdUnique 123 -- |||
1396 loopAIdKey = mkPreludeMiscIdUnique 124
1398 fromStringClassOpKey :: Unique
1399 fromStringClassOpKey = mkPreludeMiscIdUnique 125
1401 -- Annotation type checking
1402 toAnnotationWrapperIdKey :: Unique
1403 toAnnotationWrapperIdKey = mkPreludeMiscIdUnique 126
1405 -- Conversion functions
1406 fromIntegralIdKey, realToFracIdKey, toIntegerClassOpKey, toRationalClassOpKey :: Unique
1407 fromIntegralIdKey = mkPreludeMiscIdUnique 127
1408 realToFracIdKey = mkPreludeMiscIdUnique 128
1409 toIntegerClassOpKey = mkPreludeMiscIdUnique 129
1410 toRationalClassOpKey = mkPreludeMiscIdUnique 130
1413 hetmet_brak_key, hetmet_esc_key, hetmet_csp_key, hetmet_flatten_key, hetmet_flattened_id_key :: Unique
1414 hetmet_brak_key = mkPreludeMiscIdUnique 131
1415 hetmet_esc_key = mkPreludeMiscIdUnique 132
1416 hetmet_csp_key = mkPreludeMiscIdUnique 133
1417 hetmet_guest_integer_literal_key, hetmet_guest_string_literal_key, hetmet_guest_char_literal_key :: Unique
1418 hetmet_guest_integer_literal_key = mkPreludeMiscIdUnique 134
1419 hetmet_guest_string_literal_key = mkPreludeMiscIdUnique 135
1420 hetmet_guest_char_literal_key = mkPreludeMiscIdUnique 136
1421 hetmet_PGArrow_key :: Unique
1422 hetmet_PGArrow_key = mkPreludeMiscIdUnique 137
1423 hetmet_pga_id_key :: Unique
1424 hetmet_pga_id_key = mkPreludeMiscIdUnique 138
1425 hetmet_pga_comp_key :: Unique
1426 hetmet_pga_comp_key = mkPreludeMiscIdUnique 139
1427 hetmet_pga_first_key :: Unique
1428 hetmet_pga_first_key = mkPreludeMiscIdUnique 140
1429 hetmet_pga_second_key :: Unique
1430 hetmet_pga_second_key = mkPreludeMiscIdUnique 141
1431 hetmet_pga_cancell_key :: Unique
1432 hetmet_pga_cancell_key = mkPreludeMiscIdUnique 142
1433 hetmet_pga_cancelr_key :: Unique
1434 hetmet_pga_cancelr_key = mkPreludeMiscIdUnique 143
1435 hetmet_pga_uncancell_key :: Unique
1436 hetmet_pga_uncancell_key = mkPreludeMiscIdUnique 144
1437 hetmet_pga_uncancelr_key :: Unique
1438 hetmet_pga_uncancelr_key = mkPreludeMiscIdUnique 145
1439 hetmet_pga_assoc_key :: Unique
1440 hetmet_pga_assoc_key = mkPreludeMiscIdUnique 146
1441 hetmet_pga_unassoc_key :: Unique
1442 hetmet_pga_unassoc_key = mkPreludeMiscIdUnique 147
1443 hetmet_pga_copy_key :: Unique
1444 hetmet_pga_copy_key = mkPreludeMiscIdUnique 148
1445 hetmet_pga_drop_key :: Unique
1446 hetmet_pga_drop_key = mkPreludeMiscIdUnique 149
1447 hetmet_pga_swap_key :: Unique
1448 hetmet_pga_swap_key = mkPreludeMiscIdUnique 150
1449 hetmet_pga_applyl_key :: Unique
1450 hetmet_pga_applyl_key = mkPreludeMiscIdUnique 151
1451 hetmet_pga_applyr_key :: Unique
1452 hetmet_pga_applyr_key = mkPreludeMiscIdUnique 152
1453 hetmet_pga_curryl_key :: Unique
1454 hetmet_pga_curryl_key = mkPreludeMiscIdUnique 153
1455 hetmet_pga_curryr_key :: Unique
1456 hetmet_pga_curryr_key = mkPreludeMiscIdUnique 154
1457 hetmet_flatten_key = mkPreludeMiscIdUnique 155
1458 hetmet_flattened_id_key = mkPreludeMiscIdUnique 156
1462 ---------------- Template Haskell -------------------
1463 -- USES IdUniques 200-499
1464 -----------------------------------------------------
1468 %************************************************************************
1470 \subsection{Standard groups of types}
1472 %************************************************************************
1475 numericTyKeys :: [Unique]
1484 kindKeys :: [Unique]
1485 kindKeys = [ liftedTypeKindTyConKey
1486 , openTypeKindTyConKey
1487 , unliftedTypeKindTyConKey
1488 , ubxTupleKindTyConKey
1489 , argTypeKindTyConKey ]
1493 %************************************************************************
1495 \subsection[Class-std-groups]{Standard groups of Prelude classes}
1497 %************************************************************************
1499 NOTE: @Eq@ and @Text@ do need to appear in @standardClasses@
1500 even though every numeric class has these two as a superclass,
1501 because the list of ambiguous dictionaries hasn't been simplified.
1504 numericClassKeys :: [Unique]
1510 ++ fractionalClassKeys
1512 fractionalClassKeys :: [Unique]
1513 fractionalClassKeys =
1514 [ fractionalClassKey
1520 -- the strictness analyser needs to know about numeric types
1521 -- (see SaAbsInt.lhs)
1522 needsDataDeclCtxtClassKeys :: [Unique]
1523 needsDataDeclCtxtClassKeys = -- see comments in TcDeriv
1527 -- The "standard classes" are used in defaulting (Haskell 98 report 4.3.4),
1528 -- and are: "classes defined in the Prelude or a standard library"
1529 standardClassKeys :: [Unique]
1530 standardClassKeys = derivableClassKeys ++ numericClassKeys
1531 ++ [randomClassKey, randomGenClassKey,
1533 monadClassKey, monadPlusClassKey,
1535 applicativeClassKey, foldableClassKey, traversableClassKey
1539 @derivableClassKeys@ is also used in checking \tr{deriving} constructs
1543 derivableClassKeys :: [Unique]
1545 = [ eqClassKey, ordClassKey, enumClassKey, ixClassKey,
1546 boundedClassKey, showClassKey, readClassKey ]