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"
53 import Module ( Module, ModuleName, mkModule, mkModuleNameFS )
54 import OccName ( dataName, tcName, clsName, varName, mkOccNameFS,
56 import RdrName ( RdrName, nameRdrName, mkOrig, rdrNameOcc, mkUnqual )
57 import Unique ( Unique, Uniquable(..), hasKey,
58 mkPreludeMiscIdUnique, mkPreludeDataConUnique,
59 mkPreludeTyConUnique, mkPreludeClassUnique,
62 import BasicTypes ( Boxity(..), Arity )
63 import Name ( Name, mkInternalName, mkExternalName, nameModule )
64 import SrcLoc ( noSrcLoc )
69 %************************************************************************
71 \subsection{Local Names}
73 %************************************************************************
75 This *local* name is used by the interactive stuff
78 itName uniq = mkInternalName uniq (mkOccNameFS varName FSLIT("it")) noSrcLoc
82 -- mkUnboundName makes a place-holder Name; it shouldn't be looked at except possibly
83 -- during compiler debugging.
84 mkUnboundName :: RdrName -> Name
85 mkUnboundName rdr_name = mkInternalName unboundKey (rdrNameOcc rdr_name) noSrcLoc
87 isUnboundName :: Name -> Bool
88 isUnboundName name = name `hasKey` unboundKey
92 %************************************************************************
94 \subsection{Known key Names}
96 %************************************************************************
98 This section tells what the compiler knows about the assocation of
99 names with uniques. These ones are the *non* wired-in ones. The
100 wired in ones are defined in TysWiredIn etc.
103 basicKnownKeyNames :: [Name]
106 ++ typeableClassNames
107 ++ [ -- Type constructors (synonyms especially)
108 ioTyConName, ioDataConName,
114 integerTyConName, smallIntegerDataConName, largeIntegerDataConName,
116 -- Classes. *Must* include:
117 -- classes that are grabbed by key (e.g., eqClassKey)
118 -- classes in "Class.standardClassKeys" (quite a few)
119 eqClassName, -- mentioned, derivable
120 ordClassName, -- derivable
121 boundedClassName, -- derivable
122 numClassName, -- mentioned, numeric
123 enumClassName, -- derivable
126 realClassName, -- numeric
127 integralClassName, -- numeric
128 fractionalClassName, -- numeric
129 floatingClassName, -- numeric
130 realFracClassName, -- numeric
131 realFloatClassName, -- numeric
135 negateName, minusName,
136 fromRationalName, fromIntegerName,
140 enumFromName, enumFromThenName,
141 enumFromThenToName, enumFromToName,
142 enumFromToPName, enumFromThenToPName,
145 thenIOName, bindIOName, returnIOName, failIOName,
146 failMName, bindMName, thenMName, returnMName,
152 arrAName, composeAName, firstAName,
153 appAName, choiceAName, loopAName,
168 unpackCStringName, unpackCStringAppendName,
169 unpackCStringFoldrName, unpackCStringUtf8Name,
172 concatName, filterName,
173 zipName, foldrName, buildName, augmentName, appendName,
175 -- Parallel array operations
176 nullPName, lengthPName, replicatePName, mapPName,
177 filterPName, zipPName, crossPName, indexPName,
178 toPName, bpermutePName, bpermuteDftPName, indexOfPName,
180 -- FFI primitive types that are not wired-in.
181 stablePtrTyConName, ptrTyConName, funPtrTyConName,
182 int8TyConName, int16TyConName, int32TyConName, int64TyConName,
183 wordTyConName, word8TyConName, word16TyConName, word32TyConName, word64TyConName,
187 plusIntegerName, timesIntegerName,
188 eqStringName, assertName, breakpointName, breakpointCondName,
189 assertErrorName, runSTRepName,
190 printName, fstName, sndName,
193 monadFixClassName, mfixName,
196 splittableClassName, splitName,
199 randomClassName, randomGenClassName, monadPlusClassName,
205 , eitherTyConName, leftDataConName, rightDataConName
208 , objectTyConName, marshalObjectName, unmarshalObjectName
209 , marshalStringName, unmarshalStringName, checkDotnetResName
212 genericTyConNames :: [Name]
213 genericTyConNames = [crossTyConName, plusTyConName, genUnitTyConName]
217 %************************************************************************
219 \subsection{Module names}
221 %************************************************************************
224 --MetaHaskell Extension Add a new module here
226 pRELUDE = mkBaseModule_ pRELUDE_NAME
227 gHC_PRIM = mkBaseModule FSLIT("GHC.Prim") -- Primitive types and values
228 gHC_BASE = mkBaseModule FSLIT("GHC.Base")
229 gHC_ENUM = mkBaseModule FSLIT("GHC.Enum")
230 gHC_SHOW = mkBaseModule FSLIT("GHC.Show")
231 gHC_READ = mkBaseModule FSLIT("GHC.Read")
232 gHC_NUM = mkBaseModule FSLIT("GHC.Num")
233 gHC_LIST = mkBaseModule FSLIT("GHC.List")
234 gHC_PARR = mkBaseModule FSLIT("GHC.PArr")
235 dATA_TUP = mkBaseModule FSLIT("Data.Tuple")
236 dATA_EITHER = mkBaseModule FSLIT("Data.Either")
237 gHC_PACK = mkBaseModule FSLIT("GHC.Pack")
238 gHC_CONC = mkBaseModule FSLIT("GHC.Conc")
239 gHC_IO_BASE = mkBaseModule FSLIT("GHC.IOBase")
240 gHC_ST = mkBaseModule FSLIT("GHC.ST")
241 gHC_ARR = mkBaseModule FSLIT("GHC.Arr")
242 gHC_STABLE = mkBaseModule FSLIT("GHC.Stable")
243 gHC_ADDR = mkBaseModule FSLIT("GHC.Addr")
244 gHC_PTR = mkBaseModule FSLIT("GHC.Ptr")
245 gHC_ERR = mkBaseModule FSLIT("GHC.Err")
246 gHC_REAL = mkBaseModule FSLIT("GHC.Real")
247 gHC_FLOAT = mkBaseModule FSLIT("GHC.Float")
248 gHC_TOP_HANDLER = mkBaseModule FSLIT("GHC.TopHandler")
249 sYSTEM_IO = mkBaseModule FSLIT("System.IO")
250 dYNAMIC = mkBaseModule FSLIT("Data.Dynamic")
251 tYPEABLE = mkBaseModule FSLIT("Data.Typeable")
252 gENERICS = mkBaseModule FSLIT("Data.Generics.Basics")
253 dOTNET = mkBaseModule FSLIT("GHC.Dotnet")
254 rEAD_PREC = mkBaseModule FSLIT("Text.ParserCombinators.ReadPrec")
255 lEX = mkBaseModule FSLIT("Text.Read.Lex")
256 gHC_INT = mkBaseModule FSLIT("GHC.Int")
257 gHC_WORD = mkBaseModule FSLIT("GHC.Word")
258 mONAD = mkBaseModule FSLIT("Control.Monad")
259 mONAD_FIX = mkBaseModule FSLIT("Control.Monad.Fix")
260 aRROW = mkBaseModule FSLIT("Control.Arrow")
261 rANDOM = mkBaseModule FSLIT("System.Random")
262 gLA_EXTS = mkBaseModule FSLIT("GHC.Exts")
264 mAIN = mkMainModule_ mAIN_NAME
265 rOOT_MAIN = mkMainModule FSLIT(":Main") -- Root module for initialisation
267 -- The ':xxx' makes a module name that the user can never
268 -- use himself. The z-encoding for ':' is "ZC", so the z-encoded
269 -- module name still starts with a capital letter, which keeps
270 -- the z-encoded version consistent.
271 iNTERACTIVE = mkMainModule FSLIT(":Interactive")
272 thFAKE = mkMainModule FSLIT(":THFake")
274 pRELUDE_NAME = mkModuleNameFS FSLIT("Prelude")
275 mAIN_NAME = mkModuleNameFS FSLIT("Main")
277 mkBaseModule :: FastString -> Module
278 mkBaseModule m = mkModule basePackageId (mkModuleNameFS m)
280 mkBaseModule_ :: ModuleName -> Module
281 mkBaseModule_ m = mkModule basePackageId m
283 mkMainModule :: FastString -> Module
284 mkMainModule m = mkModule mainPackageId (mkModuleNameFS m)
286 mkMainModule_ :: ModuleName -> Module
287 mkMainModule_ m = mkModule mainPackageId m
290 %************************************************************************
292 \subsection{Constructing the names of tuples
294 %************************************************************************
297 mkTupleModule :: Boxity -> Arity -> Module
298 mkTupleModule Boxed 0 = gHC_BASE
299 mkTupleModule Boxed _ = dATA_TUP
300 mkTupleModule Unboxed _ = gHC_PRIM
304 %************************************************************************
308 %************************************************************************
311 main_RDR_Unqual = mkUnqual varName FSLIT("main")
312 -- We definitely don't want an Orig RdrName, because
313 -- main might, in principle, be imported into module Main
315 eq_RDR = nameRdrName eqName
316 ge_RDR = nameRdrName geName
317 ne_RDR = varQual_RDR gHC_BASE FSLIT("/=")
318 le_RDR = varQual_RDR gHC_BASE FSLIT("<=")
319 gt_RDR = varQual_RDR gHC_BASE FSLIT(">")
320 compare_RDR = varQual_RDR gHC_BASE FSLIT("compare")
321 ltTag_RDR = dataQual_RDR gHC_BASE FSLIT("LT")
322 eqTag_RDR = dataQual_RDR gHC_BASE FSLIT("EQ")
323 gtTag_RDR = dataQual_RDR gHC_BASE FSLIT("GT")
325 eqClass_RDR = nameRdrName eqClassName
326 numClass_RDR = nameRdrName numClassName
327 ordClass_RDR = nameRdrName ordClassName
328 enumClass_RDR = nameRdrName enumClassName
329 monadClass_RDR = nameRdrName monadClassName
331 map_RDR = varQual_RDR gHC_BASE FSLIT("map")
332 append_RDR = varQual_RDR gHC_BASE FSLIT("++")
334 foldr_RDR = nameRdrName foldrName
335 build_RDR = nameRdrName buildName
336 returnM_RDR = nameRdrName returnMName
337 bindM_RDR = nameRdrName bindMName
338 failM_RDR = nameRdrName failMName
340 and_RDR = nameRdrName andName
342 left_RDR = nameRdrName leftDataConName
343 right_RDR = nameRdrName rightDataConName
345 fromEnum_RDR = varQual_RDR gHC_ENUM FSLIT("fromEnum")
346 toEnum_RDR = varQual_RDR gHC_ENUM FSLIT("toEnum")
348 enumFrom_RDR = nameRdrName enumFromName
349 enumFromTo_RDR = nameRdrName enumFromToName
350 enumFromThen_RDR = nameRdrName enumFromThenName
351 enumFromThenTo_RDR = nameRdrName enumFromThenToName
353 ratioDataCon_RDR = nameRdrName ratioDataConName
354 plusInteger_RDR = nameRdrName plusIntegerName
355 timesInteger_RDR = nameRdrName timesIntegerName
357 ioDataCon_RDR = nameRdrName ioDataConName
359 eqString_RDR = nameRdrName eqStringName
360 unpackCString_RDR = nameRdrName unpackCStringName
361 unpackCStringFoldr_RDR = nameRdrName unpackCStringFoldrName
362 unpackCStringUtf8_RDR = nameRdrName unpackCStringUtf8Name
364 newStablePtr_RDR = nameRdrName newStablePtrName
365 wordDataCon_RDR = dataQual_RDR gHC_WORD FSLIT("W#")
367 bindIO_RDR = nameRdrName bindIOName
368 returnIO_RDR = nameRdrName returnIOName
370 fromInteger_RDR = nameRdrName fromIntegerName
371 fromRational_RDR = nameRdrName fromRationalName
372 minus_RDR = nameRdrName minusName
373 times_RDR = varQual_RDR gHC_NUM FSLIT("*")
374 plus_RDR = varQual_RDR gHC_NUM FSLIT("+")
376 compose_RDR = varQual_RDR gHC_BASE FSLIT(".")
378 not_RDR = varQual_RDR gHC_BASE FSLIT("not")
379 getTag_RDR = varQual_RDR gHC_BASE FSLIT("getTag")
380 succ_RDR = varQual_RDR gHC_ENUM FSLIT("succ")
381 pred_RDR = varQual_RDR gHC_ENUM FSLIT("pred")
382 minBound_RDR = varQual_RDR gHC_ENUM FSLIT("minBound")
383 maxBound_RDR = varQual_RDR gHC_ENUM FSLIT("maxBound")
384 range_RDR = varQual_RDR gHC_ARR FSLIT("range")
385 inRange_RDR = varQual_RDR gHC_ARR FSLIT("inRange")
386 index_RDR = varQual_RDR gHC_ARR FSLIT("index")
387 unsafeIndex_RDR = varQual_RDR gHC_ARR FSLIT("unsafeIndex")
388 unsafeRangeSize_RDR = varQual_RDR gHC_ARR FSLIT("unsafeRangeSize")
390 readList_RDR = varQual_RDR gHC_READ FSLIT("readList")
391 readListDefault_RDR = varQual_RDR gHC_READ FSLIT("readListDefault")
392 readListPrec_RDR = varQual_RDR gHC_READ FSLIT("readListPrec")
393 readListPrecDefault_RDR = varQual_RDR gHC_READ FSLIT("readListPrecDefault")
394 readPrec_RDR = varQual_RDR gHC_READ FSLIT("readPrec")
395 parens_RDR = varQual_RDR gHC_READ FSLIT("parens")
396 choose_RDR = varQual_RDR gHC_READ FSLIT("choose")
397 lexP_RDR = varQual_RDR gHC_READ FSLIT("lexP")
399 punc_RDR = dataQual_RDR lEX FSLIT("Punc")
400 ident_RDR = dataQual_RDR lEX FSLIT("Ident")
401 symbol_RDR = dataQual_RDR lEX FSLIT("Symbol")
403 step_RDR = varQual_RDR rEAD_PREC FSLIT("step")
404 alt_RDR = varQual_RDR rEAD_PREC FSLIT("+++")
405 reset_RDR = varQual_RDR rEAD_PREC FSLIT("reset")
406 prec_RDR = varQual_RDR rEAD_PREC FSLIT("prec")
408 showList_RDR = varQual_RDR gHC_SHOW FSLIT("showList")
409 showList___RDR = varQual_RDR gHC_SHOW FSLIT("showList__")
410 showsPrec_RDR = varQual_RDR gHC_SHOW FSLIT("showsPrec")
411 showString_RDR = varQual_RDR gHC_SHOW FSLIT("showString")
412 showSpace_RDR = varQual_RDR gHC_SHOW FSLIT("showSpace")
413 showParen_RDR = varQual_RDR gHC_SHOW FSLIT("showParen")
415 typeOf_RDR = varQual_RDR tYPEABLE FSLIT("typeOf")
416 mkTypeRep_RDR = varQual_RDR tYPEABLE FSLIT("mkTyConApp")
417 mkTyConRep_RDR = varQual_RDR tYPEABLE FSLIT("mkTyCon")
419 undefined_RDR = varQual_RDR gHC_ERR FSLIT("undefined")
421 crossDataCon_RDR = dataQual_RDR gHC_BASE FSLIT(":*:")
422 inlDataCon_RDR = dataQual_RDR gHC_BASE FSLIT("Inl")
423 inrDataCon_RDR = dataQual_RDR gHC_BASE FSLIT("Inr")
424 genUnitDataCon_RDR = dataQual_RDR gHC_BASE FSLIT("Unit")
426 ----------------------
427 varQual_RDR mod str = mkOrig mod (mkOccNameFS varName str)
428 tcQual_RDR mod str = mkOrig mod (mkOccNameFS tcName str)
429 clsQual_RDR mod str = mkOrig mod (mkOccNameFS clsName str)
430 dataQual_RDR mod str = mkOrig mod (mkOccNameFS dataName str)
433 %************************************************************************
435 \subsection{Known-key names}
437 %************************************************************************
439 Many of these Names are not really "built in", but some parts of the
440 compiler (notably the deriving mechanism) need to mention their names,
441 and it's convenient to write them all down in one place.
443 --MetaHaskell Extension add the constrs and the lower case case
444 -- guys as well (perhaps) e.g. see trueDataConName below
448 runMainIOName = varQual gHC_TOP_HANDLER FSLIT("runMainIO") runMainKey
450 orderingTyConName = tcQual gHC_BASE FSLIT("Ordering") orderingTyConKey
452 eitherTyConName = tcQual dATA_EITHER FSLIT("Either") eitherTyConKey
453 leftDataConName = conName eitherTyConName FSLIT("Left") leftDataConKey
454 rightDataConName = conName eitherTyConName FSLIT("Right") rightDataConKey
457 crossTyConName = tcQual gHC_BASE FSLIT(":*:") crossTyConKey
458 plusTyConName = tcQual gHC_BASE FSLIT(":+:") plusTyConKey
459 genUnitTyConName = tcQual gHC_BASE FSLIT("Unit") genUnitTyConKey
461 -- Base strings Strings
462 unpackCStringName = varQual gHC_BASE FSLIT("unpackCString#") unpackCStringIdKey
463 unpackCStringAppendName = varQual gHC_BASE FSLIT("unpackAppendCString#") unpackCStringAppendIdKey
464 unpackCStringFoldrName = varQual gHC_BASE FSLIT("unpackFoldrCString#") unpackCStringFoldrIdKey
465 unpackCStringUtf8Name = varQual gHC_BASE FSLIT("unpackCStringUtf8#") unpackCStringUtf8IdKey
466 eqStringName = varQual gHC_BASE FSLIT("eqString") eqStringIdKey
468 -- The 'inline' function
469 inlineIdName = varQual gHC_BASE FSLIT("inline") inlineIdKey
471 -- Base classes (Eq, Ord, Functor)
472 eqClassName = clsQual gHC_BASE FSLIT("Eq") eqClassKey
473 eqName = methName eqClassName FSLIT("==") eqClassOpKey
474 ordClassName = clsQual gHC_BASE FSLIT("Ord") ordClassKey
475 geName = methName ordClassName FSLIT(">=") geClassOpKey
476 functorClassName = clsQual gHC_BASE FSLIT("Functor") functorClassKey
479 monadClassName = clsQual gHC_BASE FSLIT("Monad") monadClassKey
480 thenMName = methName monadClassName FSLIT(">>") thenMClassOpKey
481 bindMName = methName monadClassName FSLIT(">>=") bindMClassOpKey
482 returnMName = methName monadClassName FSLIT("return") returnMClassOpKey
483 failMName = methName monadClassName FSLIT("fail") failMClassOpKey
485 -- Random PrelBase functions
486 otherwiseIdName = varQual gHC_BASE FSLIT("otherwise") otherwiseIdKey
487 foldrName = varQual gHC_BASE FSLIT("foldr") foldrIdKey
488 buildName = varQual gHC_BASE FSLIT("build") buildIdKey
489 augmentName = varQual gHC_BASE FSLIT("augment") augmentIdKey
490 appendName = varQual gHC_BASE FSLIT("++") appendIdKey
491 andName = varQual gHC_BASE FSLIT("&&") andIdKey
492 orName = varQual gHC_BASE FSLIT("||") orIdKey
493 assertName = varQual gHC_BASE FSLIT("assert") assertIdKey
494 breakpointName = varQual gHC_BASE FSLIT("breakpoint") breakpointIdKey
495 breakpointCondName= varQual gHC_BASE FSLIT("breakpointCond") breakpointCondIdKey
499 (mkOccNameFS varName FSLIT("breakpointJump"))
501 breakpointCondJumpName
503 breakpointCondJumpIdKey
504 (mkOccNameFS varName FSLIT("breakpointCondJump"))
508 fstName = varQual dATA_TUP FSLIT("fst") fstIdKey
509 sndName = varQual dATA_TUP FSLIT("snd") sndIdKey
512 numClassName = clsQual gHC_NUM FSLIT("Num") numClassKey
513 fromIntegerName = methName numClassName FSLIT("fromInteger") fromIntegerClassOpKey
514 minusName = methName numClassName FSLIT("-") minusClassOpKey
515 negateName = methName numClassName FSLIT("negate") negateClassOpKey
516 plusIntegerName = varQual gHC_NUM FSLIT("plusInteger") plusIntegerIdKey
517 timesIntegerName = varQual gHC_NUM FSLIT("timesInteger") timesIntegerIdKey
518 integerTyConName = tcQual gHC_NUM FSLIT("Integer") integerTyConKey
519 smallIntegerDataConName = conName integerTyConName FSLIT("S#") smallIntegerDataConKey
520 largeIntegerDataConName = conName integerTyConName FSLIT("J#") largeIntegerDataConKey
522 -- PrelReal types and classes
523 rationalTyConName = tcQual gHC_REAL FSLIT("Rational") rationalTyConKey
524 ratioTyConName = tcQual gHC_REAL FSLIT("Ratio") ratioTyConKey
525 ratioDataConName = conName ratioTyConName FSLIT(":%") ratioDataConKey
526 realClassName = clsQual gHC_REAL FSLIT("Real") realClassKey
527 integralClassName = clsQual gHC_REAL FSLIT("Integral") integralClassKey
528 realFracClassName = clsQual gHC_REAL FSLIT("RealFrac") realFracClassKey
529 fractionalClassName = clsQual gHC_REAL FSLIT("Fractional") fractionalClassKey
530 fromRationalName = methName fractionalClassName FSLIT("fromRational") fromRationalClassOpKey
533 floatingClassName = clsQual gHC_FLOAT FSLIT("Floating") floatingClassKey
534 realFloatClassName = clsQual gHC_FLOAT FSLIT("RealFloat") realFloatClassKey
537 ixClassName = clsQual gHC_ARR FSLIT("Ix") ixClassKey
540 typeableClassName = clsQual tYPEABLE FSLIT("Typeable") typeableClassKey
541 typeable1ClassName = clsQual tYPEABLE FSLIT("Typeable1") typeable1ClassKey
542 typeable2ClassName = clsQual tYPEABLE FSLIT("Typeable2") typeable2ClassKey
543 typeable3ClassName = clsQual tYPEABLE FSLIT("Typeable3") typeable3ClassKey
544 typeable4ClassName = clsQual tYPEABLE FSLIT("Typeable4") typeable4ClassKey
545 typeable5ClassName = clsQual tYPEABLE FSLIT("Typeable5") typeable5ClassKey
546 typeable6ClassName = clsQual tYPEABLE FSLIT("Typeable6") typeable6ClassKey
547 typeable7ClassName = clsQual tYPEABLE FSLIT("Typeable7") typeable7ClassKey
549 typeableClassNames = [ typeableClassName, typeable1ClassName, typeable2ClassName
550 , typeable3ClassName, typeable4ClassName, typeable5ClassName
551 , typeable6ClassName, typeable7ClassName ]
554 dataClassName = clsQual gENERICS FSLIT("Data") dataClassKey
557 assertErrorName = varQual gHC_ERR FSLIT("assertError") assertErrorIdKey
559 -- Enum module (Enum, Bounded)
560 enumClassName = clsQual gHC_ENUM FSLIT("Enum") enumClassKey
561 enumFromName = methName enumClassName FSLIT("enumFrom") enumFromClassOpKey
562 enumFromToName = methName enumClassName FSLIT("enumFromTo") enumFromToClassOpKey
563 enumFromThenName = methName enumClassName FSLIT("enumFromThen") enumFromThenClassOpKey
564 enumFromThenToName = methName enumClassName FSLIT("enumFromThenTo") enumFromThenToClassOpKey
565 boundedClassName = clsQual gHC_ENUM FSLIT("Bounded") boundedClassKey
568 concatName = varQual gHC_LIST FSLIT("concat") concatIdKey
569 filterName = varQual gHC_LIST FSLIT("filter") filterIdKey
570 zipName = varQual gHC_LIST FSLIT("zip") zipIdKey
573 showClassName = clsQual gHC_SHOW FSLIT("Show") showClassKey
576 readClassName = clsQual gHC_READ FSLIT("Read") readClassKey
578 -- parallel array types and functions
579 enumFromToPName = varQual gHC_PARR FSLIT("enumFromToP") enumFromToPIdKey
580 enumFromThenToPName= varQual gHC_PARR FSLIT("enumFromThenToP") enumFromThenToPIdKey
581 nullPName = varQual gHC_PARR FSLIT("nullP") nullPIdKey
582 lengthPName = varQual gHC_PARR FSLIT("lengthP") lengthPIdKey
583 replicatePName = varQual gHC_PARR FSLIT("replicateP") replicatePIdKey
584 mapPName = varQual gHC_PARR FSLIT("mapP") mapPIdKey
585 filterPName = varQual gHC_PARR FSLIT("filterP") filterPIdKey
586 zipPName = varQual gHC_PARR FSLIT("zipP") zipPIdKey
587 crossPName = varQual gHC_PARR FSLIT("crossP") crossPIdKey
588 indexPName = varQual gHC_PARR FSLIT("!:") indexPIdKey
589 toPName = varQual gHC_PARR FSLIT("toP") toPIdKey
590 bpermutePName = varQual gHC_PARR FSLIT("bpermuteP") bpermutePIdKey
591 bpermuteDftPName = varQual gHC_PARR FSLIT("bpermuteDftP") bpermuteDftPIdKey
592 indexOfPName = varQual gHC_PARR FSLIT("indexOfP") indexOfPIdKey
595 ioTyConName = tcQual gHC_IO_BASE FSLIT("IO") ioTyConKey
596 ioDataConName = conName ioTyConName FSLIT("IO") ioDataConKey
597 thenIOName = varQual gHC_IO_BASE FSLIT("thenIO") thenIOIdKey
598 bindIOName = varQual gHC_IO_BASE FSLIT("bindIO") bindIOIdKey
599 returnIOName = varQual gHC_IO_BASE FSLIT("returnIO") returnIOIdKey
600 failIOName = varQual gHC_IO_BASE FSLIT("failIO") failIOIdKey
603 printName = varQual sYSTEM_IO FSLIT("print") printIdKey
605 -- Int, Word, and Addr things
606 int8TyConName = tcQual gHC_INT FSLIT("Int8") int8TyConKey
607 int16TyConName = tcQual gHC_INT FSLIT("Int16") int16TyConKey
608 int32TyConName = tcQual gHC_INT FSLIT("Int32") int32TyConKey
609 int64TyConName = tcQual gHC_INT FSLIT("Int64") int64TyConKey
612 word8TyConName = tcQual gHC_WORD FSLIT("Word8") word8TyConKey
613 word16TyConName = tcQual gHC_WORD FSLIT("Word16") word16TyConKey
614 word32TyConName = tcQual gHC_WORD FSLIT("Word32") word32TyConKey
615 word64TyConName = tcQual gHC_WORD FSLIT("Word64") word64TyConKey
616 wordTyConName = tcQual gHC_WORD FSLIT("Word") wordTyConKey
617 wordDataConName = conName wordTyConName FSLIT("W#") wordDataConKey
620 ptrTyConName = tcQual gHC_PTR FSLIT("Ptr") ptrTyConKey
621 funPtrTyConName = tcQual gHC_PTR FSLIT("FunPtr") funPtrTyConKey
623 -- Foreign objects and weak pointers
624 stablePtrTyConName = tcQual gHC_STABLE FSLIT("StablePtr") stablePtrTyConKey
625 newStablePtrName = varQual gHC_STABLE FSLIT("newStablePtr") newStablePtrIdKey
628 runSTRepName = varQual gHC_ST FSLIT("runSTRep") runSTRepIdKey
630 -- The "split" Id for splittable implicit parameters
631 splittableClassName = clsQual gLA_EXTS FSLIT("Splittable") splittableClassKey
632 splitName = methName splittableClassName FSLIT("split") splitIdKey
634 -- Recursive-do notation
635 monadFixClassName = clsQual mONAD_FIX FSLIT("MonadFix") monadFixClassKey
636 mfixName = methName monadFixClassName FSLIT("mfix") mfixIdKey
639 arrAName = varQual aRROW FSLIT("arr") arrAIdKey
640 composeAName = varQual aRROW FSLIT(">>>") composeAIdKey
641 firstAName = varQual aRROW FSLIT("first") firstAIdKey
642 appAName = varQual aRROW FSLIT("app") appAIdKey
643 choiceAName = varQual aRROW FSLIT("|||") choiceAIdKey
644 loopAName = varQual aRROW FSLIT("loop") loopAIdKey
646 -- Other classes, needed for type defaulting
647 monadPlusClassName = clsQual mONAD FSLIT("MonadPlus") monadPlusClassKey
648 randomClassName = clsQual rANDOM FSLIT("Random") randomClassKey
649 randomGenClassName = clsQual rANDOM FSLIT("RandomGen") randomGenClassKey
652 objectTyConName = tcQual dOTNET FSLIT("Object") objectTyConKey
653 -- objectTyConName was "wTcQual", but that's gone now, and
654 -- I can't see why it was wired in anyway...
655 unmarshalObjectName = varQual dOTNET FSLIT("unmarshalObject") unmarshalObjectIdKey
656 marshalObjectName = varQual dOTNET FSLIT("marshalObject") marshalObjectIdKey
657 marshalStringName = varQual dOTNET FSLIT("marshalString") marshalStringIdKey
658 unmarshalStringName = varQual dOTNET FSLIT("unmarshalString") unmarshalStringIdKey
659 checkDotnetResName = varQual dOTNET FSLIT("checkResult") checkDotnetResNameIdKey
662 %************************************************************************
664 \subsection{Local helpers}
666 %************************************************************************
668 All these are original names; hence mkOrig
671 varQual = mk_known_key_name varName
672 tcQual = mk_known_key_name tcName
673 clsQual = mk_known_key_name clsName
675 mk_known_key_name space mod str uniq
676 = mkExternalName uniq mod (mkOccNameFS space str)
679 conName :: Name -> FastString -> Unique -> Name
680 conName tycon occ uniq
681 = mkExternalName uniq (nameModule tycon) (mkOccNameFS dataName occ)
682 (Just tycon) noSrcLoc
684 methName :: Name -> FastString -> Unique -> Name
685 methName cls occ uniq
686 = mkExternalName uniq (nameModule cls) (mkVarOccFS occ)
690 %************************************************************************
692 \subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@}
694 %************************************************************************
695 --MetaHaskell extension hand allocate keys here
698 boundedClassKey = mkPreludeClassUnique 1
699 enumClassKey = mkPreludeClassUnique 2
700 eqClassKey = mkPreludeClassUnique 3
701 floatingClassKey = mkPreludeClassUnique 5
702 fractionalClassKey = mkPreludeClassUnique 6
703 integralClassKey = mkPreludeClassUnique 7
704 monadClassKey = mkPreludeClassUnique 8
705 dataClassKey = mkPreludeClassUnique 9
706 functorClassKey = mkPreludeClassUnique 10
707 numClassKey = mkPreludeClassUnique 11
708 ordClassKey = mkPreludeClassUnique 12
709 readClassKey = mkPreludeClassUnique 13
710 realClassKey = mkPreludeClassUnique 14
711 realFloatClassKey = mkPreludeClassUnique 15
712 realFracClassKey = mkPreludeClassUnique 16
713 showClassKey = mkPreludeClassUnique 17
714 ixClassKey = mkPreludeClassUnique 18
716 typeableClassKey = mkPreludeClassUnique 20
717 typeable1ClassKey = mkPreludeClassUnique 21
718 typeable2ClassKey = mkPreludeClassUnique 22
719 typeable3ClassKey = mkPreludeClassUnique 23
720 typeable4ClassKey = mkPreludeClassUnique 24
721 typeable5ClassKey = mkPreludeClassUnique 25
722 typeable6ClassKey = mkPreludeClassUnique 26
723 typeable7ClassKey = mkPreludeClassUnique 27
725 monadFixClassKey = mkPreludeClassUnique 28
726 splittableClassKey = mkPreludeClassUnique 29
728 monadPlusClassKey = mkPreludeClassUnique 30
729 randomClassKey = mkPreludeClassUnique 31
730 randomGenClassKey = mkPreludeClassUnique 32
733 %************************************************************************
735 \subsubsection[Uniques-prelude-TyCons]{@Uniques@ for wired-in @TyCons@}
737 %************************************************************************
740 addrPrimTyConKey = mkPreludeTyConUnique 1
741 arrayPrimTyConKey = mkPreludeTyConUnique 3
742 boolTyConKey = mkPreludeTyConUnique 4
743 byteArrayPrimTyConKey = mkPreludeTyConUnique 5
744 charPrimTyConKey = mkPreludeTyConUnique 7
745 charTyConKey = mkPreludeTyConUnique 8
746 doublePrimTyConKey = mkPreludeTyConUnique 9
747 doubleTyConKey = mkPreludeTyConUnique 10
748 floatPrimTyConKey = mkPreludeTyConUnique 11
749 floatTyConKey = mkPreludeTyConUnique 12
750 funTyConKey = mkPreludeTyConUnique 13
751 intPrimTyConKey = mkPreludeTyConUnique 14
752 intTyConKey = mkPreludeTyConUnique 15
753 int8TyConKey = mkPreludeTyConUnique 16
754 int16TyConKey = mkPreludeTyConUnique 17
755 int32PrimTyConKey = mkPreludeTyConUnique 18
756 int32TyConKey = mkPreludeTyConUnique 19
757 int64PrimTyConKey = mkPreludeTyConUnique 20
758 int64TyConKey = mkPreludeTyConUnique 21
759 integerTyConKey = mkPreludeTyConUnique 22
760 listTyConKey = mkPreludeTyConUnique 23
761 foreignObjPrimTyConKey = mkPreludeTyConUnique 24
762 weakPrimTyConKey = mkPreludeTyConUnique 27
763 mutableArrayPrimTyConKey = mkPreludeTyConUnique 28
764 mutableByteArrayPrimTyConKey = mkPreludeTyConUnique 29
765 orderingTyConKey = mkPreludeTyConUnique 30
766 mVarPrimTyConKey = mkPreludeTyConUnique 31
767 ratioTyConKey = mkPreludeTyConUnique 32
768 rationalTyConKey = mkPreludeTyConUnique 33
769 realWorldTyConKey = mkPreludeTyConUnique 34
770 stablePtrPrimTyConKey = mkPreludeTyConUnique 35
771 stablePtrTyConKey = mkPreludeTyConUnique 36
772 statePrimTyConKey = mkPreludeTyConUnique 50
773 stableNamePrimTyConKey = mkPreludeTyConUnique 51
774 stableNameTyConKey = mkPreludeTyConUnique 52
775 mutVarPrimTyConKey = mkPreludeTyConUnique 55
776 ioTyConKey = mkPreludeTyConUnique 56
777 wordPrimTyConKey = mkPreludeTyConUnique 58
778 wordTyConKey = mkPreludeTyConUnique 59
779 word8TyConKey = mkPreludeTyConUnique 60
780 word16TyConKey = mkPreludeTyConUnique 61
781 word32PrimTyConKey = mkPreludeTyConUnique 62
782 word32TyConKey = mkPreludeTyConUnique 63
783 word64PrimTyConKey = mkPreludeTyConUnique 64
784 word64TyConKey = mkPreludeTyConUnique 65
785 liftedConKey = mkPreludeTyConUnique 66
786 unliftedConKey = mkPreludeTyConUnique 67
787 anyBoxConKey = mkPreludeTyConUnique 68
788 kindConKey = mkPreludeTyConUnique 69
789 boxityConKey = mkPreludeTyConUnique 70
790 typeConKey = mkPreludeTyConUnique 71
791 threadIdPrimTyConKey = mkPreludeTyConUnique 72
792 bcoPrimTyConKey = mkPreludeTyConUnique 73
793 ptrTyConKey = mkPreludeTyConUnique 74
794 funPtrTyConKey = mkPreludeTyConUnique 75
795 tVarPrimTyConKey = mkPreludeTyConUnique 76
797 -- Generic Type Constructors
798 crossTyConKey = mkPreludeTyConUnique 79
799 plusTyConKey = mkPreludeTyConUnique 80
800 genUnitTyConKey = mkPreludeTyConUnique 81
802 -- Parallel array type constructor
803 parrTyConKey = mkPreludeTyConUnique 82
806 objectTyConKey = mkPreludeTyConUnique 83
808 eitherTyConKey = mkPreludeTyConUnique 84
810 -- Super Kinds constructors
811 tySuperKindTyConKey = mkPreludeTyConUnique 85
812 coSuperKindTyConKey = mkPreludeTyConUnique 86
815 liftedTypeKindTyConKey = mkPreludeTyConUnique 87
816 openTypeKindTyConKey = mkPreludeTyConUnique 88
817 unliftedTypeKindTyConKey = mkPreludeTyConUnique 89
818 ubxTupleKindTyConKey = mkPreludeTyConUnique 90
819 argTypeKindTyConKey = mkPreludeTyConUnique 91
821 eqCoercionKindTyConKey = mkPreludeTyConUnique 92
823 -- Coercion constructors
824 symCoercionTyConKey = mkPreludeTyConUnique 93
825 transCoercionTyConKey = mkPreludeTyConUnique 94
826 leftCoercionTyConKey = mkPreludeTyConUnique 95
827 rightCoercionTyConKey = mkPreludeTyConUnique 96
828 instCoercionTyConKey = mkPreludeTyConUnique 97
829 unsafeCoercionTyConKey = mkPreludeTyConUnique 98
832 ---------------- Template Haskell -------------------
833 -- USES TyConUniques 100-129
834 -----------------------------------------------------
836 unitTyConKey = mkTupleTyConUnique Boxed 0
839 %************************************************************************
841 \subsubsection[Uniques-prelude-DataCons]{@Uniques@ for wired-in @DataCons@}
843 %************************************************************************
846 charDataConKey = mkPreludeDataConUnique 1
847 consDataConKey = mkPreludeDataConUnique 2
848 doubleDataConKey = mkPreludeDataConUnique 3
849 falseDataConKey = mkPreludeDataConUnique 4
850 floatDataConKey = mkPreludeDataConUnique 5
851 intDataConKey = mkPreludeDataConUnique 6
852 smallIntegerDataConKey = mkPreludeDataConUnique 7
853 largeIntegerDataConKey = mkPreludeDataConUnique 8
854 nilDataConKey = mkPreludeDataConUnique 11
855 ratioDataConKey = mkPreludeDataConUnique 12
856 stableNameDataConKey = mkPreludeDataConUnique 14
857 trueDataConKey = mkPreludeDataConUnique 15
858 wordDataConKey = mkPreludeDataConUnique 16
859 ioDataConKey = mkPreludeDataConUnique 17
861 -- Generic data constructors
862 crossDataConKey = mkPreludeDataConUnique 20
863 inlDataConKey = mkPreludeDataConUnique 21
864 inrDataConKey = mkPreludeDataConUnique 22
865 genUnitDataConKey = mkPreludeDataConUnique 23
867 -- Data constructor for parallel arrays
868 parrDataConKey = mkPreludeDataConUnique 24
870 leftDataConKey = mkPreludeDataConUnique 25
871 rightDataConKey = mkPreludeDataConUnique 26
874 %************************************************************************
876 \subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}
878 %************************************************************************
881 absentErrorIdKey = mkPreludeMiscIdUnique 1
882 augmentIdKey = mkPreludeMiscIdUnique 3
883 appendIdKey = mkPreludeMiscIdUnique 4
884 buildIdKey = mkPreludeMiscIdUnique 5
885 errorIdKey = mkPreludeMiscIdUnique 6
886 foldlIdKey = mkPreludeMiscIdUnique 7
887 foldrIdKey = mkPreludeMiscIdUnique 8
888 recSelErrorIdKey = mkPreludeMiscIdUnique 9
889 integerMinusOneIdKey = mkPreludeMiscIdUnique 10
890 integerPlusOneIdKey = mkPreludeMiscIdUnique 11
891 integerPlusTwoIdKey = mkPreludeMiscIdUnique 12
892 integerZeroIdKey = mkPreludeMiscIdUnique 13
893 int2IntegerIdKey = mkPreludeMiscIdUnique 14
894 seqIdKey = mkPreludeMiscIdUnique 15
895 irrefutPatErrorIdKey = mkPreludeMiscIdUnique 16
896 eqStringIdKey = mkPreludeMiscIdUnique 17
897 noMethodBindingErrorIdKey = mkPreludeMiscIdUnique 18
898 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 19
899 runtimeErrorIdKey = mkPreludeMiscIdUnique 20
900 parErrorIdKey = mkPreludeMiscIdUnique 21
901 parIdKey = mkPreludeMiscIdUnique 22
902 patErrorIdKey = mkPreludeMiscIdUnique 23
903 realWorldPrimIdKey = mkPreludeMiscIdUnique 24
904 recConErrorIdKey = mkPreludeMiscIdUnique 25
905 recUpdErrorIdKey = mkPreludeMiscIdUnique 26
906 traceIdKey = mkPreludeMiscIdUnique 27
907 unpackCStringUtf8IdKey = mkPreludeMiscIdUnique 28
908 unpackCStringAppendIdKey = mkPreludeMiscIdUnique 29
909 unpackCStringFoldrIdKey = mkPreludeMiscIdUnique 30
910 unpackCStringIdKey = mkPreludeMiscIdUnique 31
912 unsafeCoerceIdKey = mkPreludeMiscIdUnique 32
913 concatIdKey = mkPreludeMiscIdUnique 33
914 filterIdKey = mkPreludeMiscIdUnique 34
915 zipIdKey = mkPreludeMiscIdUnique 35
916 bindIOIdKey = mkPreludeMiscIdUnique 36
917 returnIOIdKey = mkPreludeMiscIdUnique 37
918 deRefStablePtrIdKey = mkPreludeMiscIdUnique 38
919 newStablePtrIdKey = mkPreludeMiscIdUnique 39
920 plusIntegerIdKey = mkPreludeMiscIdUnique 41
921 timesIntegerIdKey = mkPreludeMiscIdUnique 42
922 printIdKey = mkPreludeMiscIdUnique 43
923 failIOIdKey = mkPreludeMiscIdUnique 44
924 nullAddrIdKey = mkPreludeMiscIdUnique 46
925 voidArgIdKey = mkPreludeMiscIdUnique 47
926 splitIdKey = mkPreludeMiscIdUnique 48
927 fstIdKey = mkPreludeMiscIdUnique 49
928 sndIdKey = mkPreludeMiscIdUnique 50
929 otherwiseIdKey = mkPreludeMiscIdUnique 51
930 assertIdKey = mkPreludeMiscIdUnique 53
931 runSTRepIdKey = mkPreludeMiscIdUnique 54
933 rootMainKey = mkPreludeMiscIdUnique 55
934 runMainKey = mkPreludeMiscIdUnique 56
936 andIdKey = mkPreludeMiscIdUnique 57
937 orIdKey = mkPreludeMiscIdUnique 58
938 thenIOIdKey = mkPreludeMiscIdUnique 59
939 lazyIdKey = mkPreludeMiscIdUnique 60
940 assertErrorIdKey = mkPreludeMiscIdUnique 61
942 breakpointIdKey = mkPreludeMiscIdUnique 62
943 breakpointCondIdKey = mkPreludeMiscIdUnique 63
944 breakpointJumpIdKey = mkPreludeMiscIdUnique 64
945 breakpointCondJumpIdKey = mkPreludeMiscIdUnique 65
947 inlineIdKey = mkPreludeMiscIdUnique 66
949 -- Parallel array functions
950 nullPIdKey = mkPreludeMiscIdUnique 80
951 lengthPIdKey = mkPreludeMiscIdUnique 81
952 replicatePIdKey = mkPreludeMiscIdUnique 82
953 mapPIdKey = mkPreludeMiscIdUnique 83
954 filterPIdKey = mkPreludeMiscIdUnique 84
955 zipPIdKey = mkPreludeMiscIdUnique 85
956 crossPIdKey = mkPreludeMiscIdUnique 86
957 indexPIdKey = mkPreludeMiscIdUnique 87
958 toPIdKey = mkPreludeMiscIdUnique 88
959 enumFromToPIdKey = mkPreludeMiscIdUnique 89
960 enumFromThenToPIdKey = mkPreludeMiscIdUnique 90
961 bpermutePIdKey = mkPreludeMiscIdUnique 91
962 bpermuteDftPIdKey = mkPreludeMiscIdUnique 92
963 indexOfPIdKey = mkPreludeMiscIdUnique 93
966 unmarshalObjectIdKey = mkPreludeMiscIdUnique 94
967 marshalObjectIdKey = mkPreludeMiscIdUnique 95
968 marshalStringIdKey = mkPreludeMiscIdUnique 96
969 unmarshalStringIdKey = mkPreludeMiscIdUnique 97
970 checkDotnetResNameIdKey = mkPreludeMiscIdUnique 98
974 Certain class operations from Prelude classes. They get their own
975 uniques so we can look them up easily when we want to conjure them up
976 during type checking.
979 -- Just a place holder for unbound variables produced by the renamer:
980 unboundKey = mkPreludeMiscIdUnique 101
982 fromIntegerClassOpKey = mkPreludeMiscIdUnique 102
983 minusClassOpKey = mkPreludeMiscIdUnique 103
984 fromRationalClassOpKey = mkPreludeMiscIdUnique 104
985 enumFromClassOpKey = mkPreludeMiscIdUnique 105
986 enumFromThenClassOpKey = mkPreludeMiscIdUnique 106
987 enumFromToClassOpKey = mkPreludeMiscIdUnique 107
988 enumFromThenToClassOpKey = mkPreludeMiscIdUnique 108
989 eqClassOpKey = mkPreludeMiscIdUnique 109
990 geClassOpKey = mkPreludeMiscIdUnique 110
991 negateClassOpKey = mkPreludeMiscIdUnique 111
992 failMClassOpKey = mkPreludeMiscIdUnique 112
993 bindMClassOpKey = mkPreludeMiscIdUnique 113 -- (>>=)
994 thenMClassOpKey = mkPreludeMiscIdUnique 114 -- (>>)
995 returnMClassOpKey = mkPreludeMiscIdUnique 117
997 -- Recursive do notation
998 mfixIdKey = mkPreludeMiscIdUnique 118
1001 arrAIdKey = mkPreludeMiscIdUnique 119
1002 composeAIdKey = mkPreludeMiscIdUnique 120 -- >>>
1003 firstAIdKey = mkPreludeMiscIdUnique 121
1004 appAIdKey = mkPreludeMiscIdUnique 122
1005 choiceAIdKey = mkPreludeMiscIdUnique 123 -- |||
1006 loopAIdKey = mkPreludeMiscIdUnique 124
1008 ---------------- Template Haskell -------------------
1009 -- USES IdUniques 200-399
1010 -----------------------------------------------------
1014 %************************************************************************
1016 \subsection{Standard groups of types}
1018 %************************************************************************
1031 %************************************************************************
1033 \subsection[Class-std-groups]{Standard groups of Prelude classes}
1035 %************************************************************************
1037 NOTE: @Eq@ and @Text@ do need to appear in @standardClasses@
1038 even though every numeric class has these two as a superclass,
1039 because the list of ambiguous dictionaries hasn't been simplified.
1047 ++ fractionalClassKeys
1049 fractionalClassKeys =
1050 [ fractionalClassKey
1056 -- the strictness analyser needs to know about numeric types
1057 -- (see SaAbsInt.lhs)
1058 needsDataDeclCtxtClassKeys = -- see comments in TcDeriv
1062 -- The "standard classes" are used in defaulting (Haskell 98 report 4.3.4),
1063 -- and are: "classes defined in the Prelude or a standard library"
1064 standardClassKeys = derivableClassKeys ++ numericClassKeys
1065 ++ [randomClassKey, randomGenClassKey,
1067 monadClassKey, monadPlusClassKey]
1070 @derivableClassKeys@ is also used in checking \tr{deriving} constructs
1075 = [ eqClassKey, ordClassKey, enumClassKey, ixClassKey,
1076 boundedClassKey, showClassKey, readClassKey ]