syb is now in its own package
[ghc.git] / compiler / prelude / PrelNames.lhs
1 %
2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
3 %
4 \section[PrelNames]{Definitions of prelude modules and names}
5
6
7 Nota Bene: all Names defined in here should come from the base package
8
9  - ModuleNames for prelude modules, 
10         e.g.    pREL_BASE_Name :: ModuleName
11
12  - Modules for prelude modules
13         e.g.    pREL_Base :: Module
14
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
19
20  - Names for Ids, DataCons, TyCons and Classes that the compiler 
21    "knows about" in some way
22         e.g.    intTyConName :: Name
23                 minusName    :: Name
24    One of these Names contains
25         (a) the module and occurrence name of the thing
26         (b) its Unique
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.
32
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
36
37
38 \begin{code}
39 module PrelNames (
40         Unique, Uniquable(..), hasKey,  -- Re-exported for convenience
41
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
48     ) where
49
50 #include "HsVersions.h"
51
52 import Module
53 import OccName
54 import RdrName    ( RdrName, nameRdrName, mkOrig, rdrNameOcc, mkUnqual )
55 import Unique     ( Unique, Uniquable(..), hasKey,
56                     mkPreludeMiscIdUnique, mkPreludeDataConUnique,
57                     mkPreludeTyConUnique, mkPreludeClassUnique,
58                     mkTupleTyConUnique
59                   ) 
60 import BasicTypes ( Boxity(..), Arity )
61 import Name       ( Name, mkInternalName, mkExternalName )
62 import SrcLoc
63 import FastString
64 \end{code}
65
66
67 %************************************************************************
68 %*                                                                      *
69 \subsection{Local Names}
70 %*                                                                      *
71 %************************************************************************
72
73 This *local* name is used by the interactive stuff
74
75 \begin{code}
76 itName :: Unique -> Name
77 itName uniq = mkInternalName uniq (mkOccNameFS varName (fsLit "it")) noSrcSpan
78 \end{code}
79
80 \begin{code}
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
85
86 isUnboundName :: Name -> Bool
87 isUnboundName name = name `hasKey` unboundKey
88 \end{code}
89
90
91 %************************************************************************
92 %*                                                                      *
93 \subsection{Known key Names}
94 %*                                                                      *
95 %************************************************************************
96
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.
100
101 \begin{code}
102 basicKnownKeyNames :: [Name]
103 basicKnownKeyNames
104  = genericTyConNames
105  ++ typeableClassNames
106  ++ [   -- Type constructors (synonyms especially)
107         ioTyConName, ioDataConName,
108         runMainIOName,
109         orderingTyConName,
110         rationalTyConName,
111         stringTyConName,
112         ratioDataConName,
113         ratioTyConName,
114         integerTyConName, smallIntegerName,
115
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
124         monadClassName,
125         functorClassName,
126         realClassName,                  -- numeric
127         integralClassName,              -- numeric
128         fractionalClassName,            -- numeric
129         floatingClassName,              -- numeric
130         realFracClassName,              -- numeric
131         realFloatClassName,             -- numeric
132         dataClassName, 
133         isStringClassName,
134
135         -- Numeric stuff
136         negateName, minusName, 
137         fromRationalName, fromIntegerName, 
138         geName, eqName, 
139
140         -- String stuff
141         fromStringName,
142         
143         -- Enum stuff
144         enumFromName, enumFromThenName, 
145         enumFromThenToName, enumFromToName,
146         enumFromToPName, enumFromThenToPName,
147
148         -- Monad stuff
149         thenIOName, bindIOName, returnIOName, failIOName,
150         failMName, bindMName, thenMName, returnMName,
151
152         -- MonadRec stuff
153         mfixName,
154
155         -- Arrow stuff
156         arrAName, composeAName, firstAName,
157         appAName, choiceAName, loopAName,
158
159         -- Ix stuff
160         ixClassName, 
161
162         -- Show stuff
163         showClassName, 
164
165         -- Read stuff
166         readClassName, 
167         
168         -- Stable pointers
169         newStablePtrName,
170
171     -- GHC Extensions
172     groupWithName,
173
174         -- Strings and lists
175         unpackCStringName, unpackCStringAppendName,
176         unpackCStringFoldrName, unpackCStringUtf8Name,
177
178         -- List operations
179         concatName, filterName, mapName,
180         zipName, foldrName, buildName, augmentName, appendName,
181
182         -- Parallel array operations
183         nullPName, lengthPName, replicatePName, singletonPName, mapPName,
184         filterPName, zipPName, crossMapPName, indexPName,
185         toPName, bpermutePName, bpermuteDftPName, indexOfPName,
186
187         -- FFI primitive types that are not wired-in.
188         stablePtrTyConName, ptrTyConName, funPtrTyConName,
189         int8TyConName, int16TyConName, int32TyConName, int64TyConName,
190         wordTyConName, word8TyConName, word16TyConName, word32TyConName, word64TyConName,
191
192         -- Others
193         otherwiseIdName, inlineIdName,
194         plusIntegerName, timesIntegerName,
195         eqStringName, assertName, breakpointName, breakpointCondName,
196         breakpointAutoName,  opaqueTyConName,
197         assertErrorName, runSTRepName,
198         printName, fstName, sndName,
199
200         -- MonadFix
201         monadFixClassName, mfixName,
202
203         -- Other classes
204         randomClassName, randomGenClassName, monadPlusClassName,
205
206         -- Booleans
207         andName, orName
208         
209         -- The Either type
210         , eitherTyConName, leftDataConName, rightDataConName
211
212         -- dotnet interop
213         , objectTyConName, marshalObjectName, unmarshalObjectName
214         , marshalStringName, unmarshalStringName, checkDotnetResName
215     ]
216
217 genericTyConNames :: [Name]
218 genericTyConNames = [crossTyConName, plusTyConName, genUnitTyConName]
219 \end{code}
220
221
222 %************************************************************************
223 %*                                                                      *
224 \subsection{Module names}
225 %*                                                                      *
226 %************************************************************************
227
228
229 --MetaHaskell Extension Add a new module here
230 \begin{code}
231 pRELUDE :: Module
232 pRELUDE         = mkBaseModule_ pRELUDE_NAME
233
234 gHC_PRIM, gHC_TYPES, gHC_BOOL, gHC_UNIT, gHC_ORDERING, gHC_GENERICS, gHC_CLASSES, gHC_BASE, gHC_ENUM,
235     gHC_SHOW, gHC_READ, gHC_NUM, gHC_INTEGER, gHC_LIST, gHC_PARR,
236     gHC_TUPLE, dATA_TUPLE, dATA_EITHER, dATA_STRING, gHC_PACK, gHC_CONC, gHC_IO_BASE,
237     gHC_ST, gHC_ARR, gHC_STABLE, gHC_ADDR, gHC_PTR, gHC_ERR, gHC_REAL,
238     gHC_FLOAT, gHC_TOP_HANDLER, sYSTEM_IO, dYNAMIC, tYPEABLE, gENERICS,
239     dOTNET, rEAD_PREC, lEX, gHC_INT, gHC_WORD, mONAD, mONAD_FIX, aRROW,
240     gHC_DESUGAR, rANDOM, gHC_EXTS, cONTROL_EXCEPTION_BASE :: Module
241 gHC_PRIM        = mkPrimModule (fsLit "GHC.Prim")   -- Primitive types and values
242 gHC_TYPES   = mkPrimModule (fsLit "GHC.Types")
243 gHC_UNIT        = mkPrimModule (fsLit "GHC.Unit")
244 gHC_BOOL        = mkPrimModule (fsLit "GHC.Bool")
245 gHC_ORDERING    = mkPrimModule (fsLit "GHC.Ordering")
246 gHC_GENERICS    = mkPrimModule (fsLit "GHC.Generics")
247 gHC_CLASSES     = mkBaseModule (fsLit "GHC.Classes")
248 gHC_BASE        = mkBaseModule (fsLit "GHC.Base")
249 gHC_ENUM        = mkBaseModule (fsLit "GHC.Enum")
250 gHC_SHOW        = mkBaseModule (fsLit "GHC.Show")
251 gHC_READ        = mkBaseModule (fsLit "GHC.Read")
252 gHC_NUM         = mkBaseModule (fsLit "GHC.Num")
253 gHC_INTEGER     = mkIntegerModule (fsLit "GHC.Integer")
254 gHC_LIST        = mkBaseModule (fsLit "GHC.List")
255 gHC_PARR        = mkBaseModule (fsLit "GHC.PArr")
256 gHC_TUPLE       = mkPrimModule (fsLit "GHC.Tuple")
257 dATA_TUPLE      = mkBaseModule (fsLit "Data.Tuple")
258 dATA_EITHER     = mkBaseModule (fsLit "Data.Either")
259 dATA_STRING     = mkBaseModule (fsLit "Data.String")
260 gHC_PACK        = mkBaseModule (fsLit "GHC.Pack")
261 gHC_CONC        = mkBaseModule (fsLit "GHC.Conc")
262 gHC_IO_BASE     = mkBaseModule (fsLit "GHC.IOBase")
263 gHC_ST          = mkBaseModule (fsLit "GHC.ST")
264 gHC_ARR         = mkBaseModule (fsLit "GHC.Arr")
265 gHC_STABLE      = mkBaseModule (fsLit "GHC.Stable")
266 gHC_ADDR        = mkBaseModule (fsLit "GHC.Addr")
267 gHC_PTR         = mkBaseModule (fsLit "GHC.Ptr")
268 gHC_ERR         = mkBaseModule (fsLit "GHC.Err")
269 gHC_REAL        = mkBaseModule (fsLit "GHC.Real")
270 gHC_FLOAT       = mkBaseModule (fsLit "GHC.Float")
271 gHC_TOP_HANDLER = mkBaseModule (fsLit "GHC.TopHandler")
272 sYSTEM_IO       = mkBaseModule (fsLit "System.IO")
273 dYNAMIC         = mkBaseModule (fsLit "Data.Dynamic")
274 tYPEABLE        = mkBaseModule (fsLit "Data.Typeable")
275 gENERICS        = mkSybModule (fsLit "Data.Generics.Basics")
276 dOTNET          = mkBaseModule (fsLit "GHC.Dotnet")
277 rEAD_PREC       = mkBaseModule (fsLit "Text.ParserCombinators.ReadPrec")
278 lEX                 = mkBaseModule (fsLit "Text.Read.Lex")
279 gHC_INT         = mkBaseModule (fsLit "GHC.Int")
280 gHC_WORD        = mkBaseModule (fsLit "GHC.Word")
281 mONAD           = mkBaseModule (fsLit "Control.Monad")
282 mONAD_FIX       = mkBaseModule (fsLit "Control.Monad.Fix")
283 aRROW           = mkBaseModule (fsLit "Control.Arrow")
284 gHC_DESUGAR = mkBaseModule (fsLit "GHC.Desugar")
285 rANDOM          = mkBaseModule (fsLit "System.Random")
286 gHC_EXTS        = mkBaseModule (fsLit "GHC.Exts")
287 cONTROL_EXCEPTION_BASE = mkBaseModule (fsLit "Control.Exception.Base")
288
289 mAIN, rOOT_MAIN :: Module
290 mAIN            = mkMainModule_ mAIN_NAME
291 rOOT_MAIN       = mkMainModule (fsLit ":Main") -- Root module for initialisation 
292
293         -- The ':xxx' makes a module name that the user can never
294         -- use himself.  The z-encoding for ':' is "ZC", so the z-encoded
295         -- module name still starts with a capital letter, which keeps
296         -- the z-encoded version consistent.
297 iNTERACTIVE, thFAKE :: Module
298 iNTERACTIVE    = mkMainModule (fsLit ":Interactive")
299 thFAKE         = mkMainModule (fsLit ":THFake")
300
301 pRELUDE_NAME, mAIN_NAME :: ModuleName
302 pRELUDE_NAME   = mkModuleNameFS (fsLit "Prelude")
303 mAIN_NAME      = mkModuleNameFS (fsLit "Main")
304
305 mkPrimModule :: FastString -> Module
306 mkPrimModule m = mkModule primPackageId (mkModuleNameFS m)
307
308 mkIntegerModule :: FastString -> Module
309 mkIntegerModule m = mkModule integerPackageId (mkModuleNameFS m)
310
311 mkBaseModule :: FastString -> Module
312 mkBaseModule m = mkModule basePackageId (mkModuleNameFS m)
313
314 mkBaseModule_ :: ModuleName -> Module
315 mkBaseModule_ m = mkModule basePackageId m
316
317 mkSybModule :: FastString -> Module
318 mkSybModule m = mkModule sybPackageId (mkModuleNameFS m)
319
320 mkMainModule :: FastString -> Module
321 mkMainModule m = mkModule mainPackageId (mkModuleNameFS m)
322
323 mkMainModule_ :: ModuleName -> Module
324 mkMainModule_ m = mkModule mainPackageId m
325 \end{code}
326
327 %************************************************************************
328 %*                                                                      *
329 \subsection{Constructing the names of tuples
330 %*                                                                      *
331 %************************************************************************
332
333 \begin{code}
334 mkTupleModule :: Boxity -> Arity -> Module
335 mkTupleModule Boxed   0 = gHC_UNIT
336 mkTupleModule Boxed   _ = gHC_TUPLE
337 mkTupleModule Unboxed _ = gHC_PRIM
338 \end{code}
339
340
341 %************************************************************************
342 %*                                                                      *
343                         RdrNames
344 %*                                                                      *
345 %************************************************************************
346
347 \begin{code}
348 main_RDR_Unqual    :: RdrName
349 main_RDR_Unqual = mkUnqual varName (fsLit "main")
350         -- We definitely don't want an Orig RdrName, because
351         -- main might, in principle, be imported into module Main
352
353 forall_tv_RDR, dot_tv_RDR :: RdrName
354 forall_tv_RDR = mkUnqual tvName (fsLit "forall")
355 dot_tv_RDR    = mkUnqual tvName (fsLit ".")
356
357 eq_RDR, ge_RDR, ne_RDR, le_RDR, lt_RDR, gt_RDR, compare_RDR,
358     ltTag_RDR, eqTag_RDR, gtTag_RDR :: RdrName
359 eq_RDR                  = nameRdrName eqName
360 ge_RDR                  = nameRdrName geName
361 ne_RDR                  = varQual_RDR  gHC_CLASSES (fsLit "/=")
362 le_RDR                  = varQual_RDR  gHC_CLASSES (fsLit "<=") 
363 lt_RDR                  = varQual_RDR  gHC_CLASSES (fsLit "<") 
364 gt_RDR                  = varQual_RDR  gHC_CLASSES (fsLit ">")  
365 compare_RDR             = varQual_RDR  gHC_CLASSES (fsLit "compare") 
366 ltTag_RDR               = dataQual_RDR gHC_ORDERING (fsLit "LT") 
367 eqTag_RDR               = dataQual_RDR gHC_ORDERING (fsLit "EQ")
368 gtTag_RDR               = dataQual_RDR gHC_ORDERING (fsLit "GT")
369
370 eqClass_RDR, numClass_RDR, ordClass_RDR, enumClass_RDR, monadClass_RDR
371     :: RdrName
372 eqClass_RDR             = nameRdrName eqClassName
373 numClass_RDR            = nameRdrName numClassName
374 ordClass_RDR            = nameRdrName ordClassName
375 enumClass_RDR           = nameRdrName enumClassName
376 monadClass_RDR          = nameRdrName monadClassName
377
378 map_RDR, append_RDR :: RdrName
379 map_RDR                 = varQual_RDR gHC_BASE (fsLit "map")
380 append_RDR              = varQual_RDR gHC_BASE (fsLit "++")
381
382 foldr_RDR, build_RDR, returnM_RDR, bindM_RDR, failM_RDR :: RdrName
383 foldr_RDR               = nameRdrName foldrName
384 build_RDR               = nameRdrName buildName
385 returnM_RDR             = nameRdrName returnMName
386 bindM_RDR               = nameRdrName bindMName
387 failM_RDR               = nameRdrName failMName
388
389 and_RDR :: RdrName
390 and_RDR                 = nameRdrName andName
391
392 left_RDR, right_RDR :: RdrName
393 left_RDR                = nameRdrName leftDataConName
394 right_RDR               = nameRdrName rightDataConName
395
396 fromEnum_RDR, toEnum_RDR :: RdrName
397 fromEnum_RDR            = varQual_RDR gHC_ENUM (fsLit "fromEnum")
398 toEnum_RDR              = varQual_RDR gHC_ENUM (fsLit "toEnum")
399
400 enumFrom_RDR, enumFromTo_RDR, enumFromThen_RDR, enumFromThenTo_RDR :: RdrName
401 enumFrom_RDR            = nameRdrName enumFromName
402 enumFromTo_RDR          = nameRdrName enumFromToName
403 enumFromThen_RDR        = nameRdrName enumFromThenName
404 enumFromThenTo_RDR      = nameRdrName enumFromThenToName
405
406 ratioDataCon_RDR, plusInteger_RDR, timesInteger_RDR :: RdrName
407 ratioDataCon_RDR        = nameRdrName ratioDataConName
408 plusInteger_RDR         = nameRdrName plusIntegerName
409 timesInteger_RDR        = nameRdrName timesIntegerName
410
411 ioDataCon_RDR :: RdrName
412 ioDataCon_RDR           = nameRdrName ioDataConName
413
414 eqString_RDR, unpackCString_RDR, unpackCStringFoldr_RDR,
415     unpackCStringUtf8_RDR :: RdrName
416 eqString_RDR            = nameRdrName eqStringName
417 unpackCString_RDR       = nameRdrName unpackCStringName
418 unpackCStringFoldr_RDR  = nameRdrName unpackCStringFoldrName
419 unpackCStringUtf8_RDR   = nameRdrName unpackCStringUtf8Name
420
421 newStablePtr_RDR, wordDataCon_RDR :: RdrName
422 newStablePtr_RDR        = nameRdrName newStablePtrName
423 wordDataCon_RDR         = dataQual_RDR gHC_WORD (fsLit "W#")
424
425 bindIO_RDR, returnIO_RDR :: RdrName
426 bindIO_RDR              = nameRdrName bindIOName
427 returnIO_RDR            = nameRdrName returnIOName
428
429 fromInteger_RDR, fromRational_RDR, minus_RDR, times_RDR, plus_RDR :: RdrName
430 fromInteger_RDR         = nameRdrName fromIntegerName
431 fromRational_RDR        = nameRdrName fromRationalName
432 minus_RDR               = nameRdrName minusName
433 times_RDR               = varQual_RDR  gHC_NUM (fsLit "*")
434 plus_RDR                = varQual_RDR gHC_NUM (fsLit "+")
435
436 fromString_RDR :: RdrName
437 fromString_RDR          = nameRdrName fromStringName
438
439 compose_RDR :: RdrName
440 compose_RDR             = varQual_RDR gHC_BASE (fsLit ".")
441
442 not_RDR, getTag_RDR, succ_RDR, pred_RDR, minBound_RDR, maxBound_RDR,
443     range_RDR, inRange_RDR, index_RDR,
444     unsafeIndex_RDR, unsafeRangeSize_RDR :: RdrName
445 not_RDR                 = varQual_RDR gHC_CLASSES (fsLit "not")
446 getTag_RDR              = varQual_RDR gHC_BASE (fsLit "getTag")
447 succ_RDR                = varQual_RDR gHC_ENUM (fsLit "succ")
448 pred_RDR                = varQual_RDR gHC_ENUM (fsLit "pred")
449 minBound_RDR            = varQual_RDR gHC_ENUM (fsLit "minBound")
450 maxBound_RDR            = varQual_RDR gHC_ENUM (fsLit "maxBound")
451 range_RDR               = varQual_RDR gHC_ARR (fsLit "range")
452 inRange_RDR             = varQual_RDR gHC_ARR (fsLit "inRange")
453 index_RDR               = varQual_RDR gHC_ARR (fsLit "index")
454 unsafeIndex_RDR         = varQual_RDR gHC_ARR (fsLit "unsafeIndex")
455 unsafeRangeSize_RDR     = varQual_RDR gHC_ARR (fsLit "unsafeRangeSize")
456
457 readList_RDR, readListDefault_RDR, readListPrec_RDR, readListPrecDefault_RDR,
458     readPrec_RDR, parens_RDR, choose_RDR, lexP_RDR :: RdrName
459 readList_RDR            = varQual_RDR gHC_READ (fsLit "readList")
460 readListDefault_RDR     = varQual_RDR gHC_READ (fsLit "readListDefault")
461 readListPrec_RDR        = varQual_RDR gHC_READ (fsLit "readListPrec")
462 readListPrecDefault_RDR = varQual_RDR gHC_READ (fsLit "readListPrecDefault")
463 readPrec_RDR            = varQual_RDR gHC_READ (fsLit "readPrec")
464 parens_RDR              = varQual_RDR gHC_READ (fsLit "parens")
465 choose_RDR              = varQual_RDR gHC_READ (fsLit "choose")
466 lexP_RDR                = varQual_RDR gHC_READ (fsLit "lexP")
467
468 punc_RDR, ident_RDR, symbol_RDR :: RdrName
469 punc_RDR                = dataQual_RDR lEX (fsLit "Punc")
470 ident_RDR               = dataQual_RDR lEX (fsLit "Ident")
471 symbol_RDR              = dataQual_RDR lEX (fsLit "Symbol")
472
473 step_RDR, alt_RDR, reset_RDR, prec_RDR :: RdrName
474 step_RDR                = varQual_RDR  rEAD_PREC (fsLit "step")
475 alt_RDR                 = varQual_RDR  rEAD_PREC (fsLit "+++") 
476 reset_RDR               = varQual_RDR  rEAD_PREC (fsLit "reset")
477 prec_RDR                = varQual_RDR  rEAD_PREC (fsLit "prec")
478
479 showList_RDR, showList___RDR, showsPrec_RDR, showString_RDR,
480     showSpace_RDR, showParen_RDR :: RdrName
481 showList_RDR            = varQual_RDR gHC_SHOW (fsLit "showList")
482 showList___RDR          = varQual_RDR gHC_SHOW (fsLit "showList__")
483 showsPrec_RDR           = varQual_RDR gHC_SHOW (fsLit "showsPrec") 
484 showString_RDR          = varQual_RDR gHC_SHOW (fsLit "showString")
485 showSpace_RDR           = varQual_RDR gHC_SHOW (fsLit "showSpace") 
486 showParen_RDR           = varQual_RDR gHC_SHOW (fsLit "showParen") 
487
488 typeOf_RDR, mkTypeRep_RDR, mkTyConRep_RDR :: RdrName
489 typeOf_RDR     = varQual_RDR tYPEABLE (fsLit "typeOf")
490 mkTypeRep_RDR  = varQual_RDR tYPEABLE (fsLit "mkTyConApp")
491 mkTyConRep_RDR = varQual_RDR tYPEABLE (fsLit "mkTyCon")
492
493 undefined_RDR :: RdrName
494 undefined_RDR = varQual_RDR gHC_ERR (fsLit "undefined")
495
496 crossDataCon_RDR, inlDataCon_RDR, inrDataCon_RDR, genUnitDataCon_RDR :: RdrName
497 crossDataCon_RDR   = dataQual_RDR gHC_GENERICS (fsLit ":*:")
498 inlDataCon_RDR     = dataQual_RDR gHC_GENERICS (fsLit "Inl")
499 inrDataCon_RDR     = dataQual_RDR gHC_GENERICS (fsLit "Inr")
500 genUnitDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Unit")
501
502 ----------------------
503 varQual_RDR, tcQual_RDR, clsQual_RDR, dataQual_RDR
504     :: Module -> FastString -> RdrName
505 varQual_RDR  mod str = mkOrig mod (mkOccNameFS varName str)
506 tcQual_RDR   mod str = mkOrig mod (mkOccNameFS tcName str)
507 clsQual_RDR  mod str = mkOrig mod (mkOccNameFS clsName str)
508 dataQual_RDR mod str = mkOrig mod (mkOccNameFS dataName str)
509 \end{code}
510
511 %************************************************************************
512 %*                                                                      *
513 \subsection{Known-key names}
514 %*                                                                      *
515 %************************************************************************
516
517 Many of these Names are not really "built in", but some parts of the
518 compiler (notably the deriving mechanism) need to mention their names,
519 and it's convenient to write them all down in one place.
520
521 --MetaHaskell Extension  add the constrs and the lower case case
522 -- guys as well (perhaps) e.g. see  trueDataConName     below
523
524
525 \begin{code}
526 runMainIOName :: Name
527 runMainIOName = varQual gHC_TOP_HANDLER (fsLit "runMainIO") runMainKey
528
529 orderingTyConName :: Name
530 orderingTyConName = tcQual   gHC_ORDERING (fsLit "Ordering") orderingTyConKey
531
532 eitherTyConName, leftDataConName, rightDataConName :: Name
533 eitherTyConName   = tcQual  dATA_EITHER (fsLit "Either") eitherTyConKey
534 leftDataConName   = conName dATA_EITHER (fsLit "Left")   leftDataConKey
535 rightDataConName  = conName dATA_EITHER (fsLit "Right")  rightDataConKey
536
537 -- Generics
538 crossTyConName, plusTyConName, genUnitTyConName :: Name
539 crossTyConName     = tcQual   gHC_GENERICS (fsLit ":*:") crossTyConKey
540 plusTyConName      = tcQual   gHC_GENERICS (fsLit ":+:") plusTyConKey
541 genUnitTyConName   = tcQual   gHC_GENERICS (fsLit "Unit") genUnitTyConKey
542
543 -- Base strings Strings
544 unpackCStringName, unpackCStringAppendName, unpackCStringFoldrName,
545     unpackCStringUtf8Name, eqStringName, stringTyConName :: Name
546 unpackCStringName       = varQual gHC_BASE (fsLit "unpackCString#") unpackCStringIdKey
547 unpackCStringAppendName = varQual gHC_BASE (fsLit "unpackAppendCString#") unpackCStringAppendIdKey
548 unpackCStringFoldrName  = varQual gHC_BASE (fsLit "unpackFoldrCString#") unpackCStringFoldrIdKey
549 unpackCStringUtf8Name   = varQual gHC_BASE (fsLit "unpackCStringUtf8#") unpackCStringUtf8IdKey
550 eqStringName            = varQual gHC_BASE (fsLit "eqString")  eqStringIdKey
551 stringTyConName         = tcQual  gHC_BASE (fsLit "String") stringTyConKey
552
553 -- The 'inline' function
554 inlineIdName :: Name
555 inlineIdName            = varQual gHC_BASE (fsLit "inline") inlineIdKey
556
557 -- Base classes (Eq, Ord, Functor)
558 eqClassName, eqName, ordClassName, geName, functorClassName :: Name
559 eqClassName       = clsQual  gHC_CLASSES (fsLit "Eq")      eqClassKey
560 eqName            = methName gHC_CLASSES (fsLit "==")      eqClassOpKey
561 ordClassName      = clsQual  gHC_CLASSES (fsLit "Ord")     ordClassKey
562 geName            = methName gHC_CLASSES (fsLit ">=")      geClassOpKey
563 functorClassName  = clsQual  gHC_BASE (fsLit "Functor") functorClassKey
564
565 -- Class Monad
566 monadClassName, thenMName, bindMName, returnMName, failMName :: Name
567 monadClassName     = clsQual  gHC_BASE (fsLit "Monad")  monadClassKey
568 thenMName          = methName gHC_BASE (fsLit ">>")     thenMClassOpKey
569 bindMName          = methName gHC_BASE (fsLit ">>=")    bindMClassOpKey
570 returnMName        = methName gHC_BASE (fsLit "return") returnMClassOpKey
571 failMName          = methName gHC_BASE (fsLit "fail")   failMClassOpKey
572
573 -- Functions for GHC extensions
574 groupWithName :: Name
575 groupWithName = varQual gHC_EXTS (fsLit "groupWith") groupWithIdKey
576
577 -- Random PrelBase functions
578 fromStringName, otherwiseIdName, foldrName, buildName, augmentName,
579     mapName, appendName, andName, orName, assertName,
580     breakpointName, breakpointCondName, breakpointAutoName,
581     opaqueTyConName :: Name
582 fromStringName = methName dATA_STRING (fsLit "fromString") fromStringClassOpKey
583 otherwiseIdName   = varQual gHC_BASE (fsLit "otherwise")  otherwiseIdKey
584 foldrName         = varQual gHC_BASE (fsLit "foldr")      foldrIdKey
585 buildName         = varQual gHC_BASE (fsLit "build")      buildIdKey
586 augmentName       = varQual gHC_BASE (fsLit "augment")    augmentIdKey
587 mapName       = varQual gHC_BASE (fsLit "map")        mapIdKey
588 appendName        = varQual gHC_BASE (fsLit "++")         appendIdKey
589 andName           = varQual gHC_CLASSES (fsLit "&&")     andIdKey
590 orName            = varQual gHC_CLASSES (fsLit "||")     orIdKey
591 assertName        = varQual gHC_BASE (fsLit "assert")     assertIdKey
592 breakpointName    = varQual gHC_BASE (fsLit "breakpoint") breakpointIdKey
593 breakpointCondName= varQual gHC_BASE (fsLit "breakpointCond") breakpointCondIdKey
594 breakpointAutoName= varQual gHC_BASE (fsLit "breakpointAuto") breakpointAutoIdKey
595 opaqueTyConName   = tcQual  gHC_BASE (fsLit "Opaque")   opaqueTyConKey
596
597 breakpointJumpName :: Name
598 breakpointJumpName
599     = mkInternalName
600         breakpointJumpIdKey
601         (mkOccNameFS varName (fsLit "breakpointJump"))
602         noSrcSpan
603 breakpointCondJumpName :: Name
604 breakpointCondJumpName
605     = mkInternalName
606         breakpointCondJumpIdKey
607         (mkOccNameFS varName (fsLit "breakpointCondJump"))
608         noSrcSpan
609 breakpointAutoJumpName :: Name
610 breakpointAutoJumpName
611     = mkInternalName
612         breakpointAutoJumpIdKey
613         (mkOccNameFS varName (fsLit "breakpointAutoJump"))
614         noSrcSpan
615
616 -- PrelTup
617 fstName, sndName :: Name
618 fstName           = varQual dATA_TUPLE (fsLit "fst") fstIdKey
619 sndName           = varQual dATA_TUPLE (fsLit "snd") sndIdKey
620
621 -- Module PrelNum
622 numClassName, fromIntegerName, minusName, negateName, plusIntegerName,
623     timesIntegerName, integerTyConName, smallIntegerName :: Name
624 numClassName      = clsQual  gHC_NUM (fsLit "Num") numClassKey
625 fromIntegerName   = methName gHC_NUM (fsLit "fromInteger") fromIntegerClassOpKey
626 minusName         = methName gHC_NUM (fsLit "-") minusClassOpKey
627 negateName        = methName gHC_NUM (fsLit "negate") negateClassOpKey
628 plusIntegerName   = varQual  gHC_INTEGER (fsLit "plusInteger") plusIntegerIdKey
629 timesIntegerName  = varQual  gHC_INTEGER (fsLit "timesInteger") timesIntegerIdKey
630 integerTyConName  = tcQual   gHC_INTEGER (fsLit "Integer") integerTyConKey
631 smallIntegerName = varQual gHC_INTEGER (fsLit "smallInteger") smallIntegerIdKey
632
633 -- PrelReal types and classes
634 rationalTyConName, ratioTyConName, ratioDataConName, realClassName,
635     integralClassName, realFracClassName, fractionalClassName,
636     fromRationalName :: Name
637 rationalTyConName   = tcQual  gHC_REAL (fsLit "Rational") rationalTyConKey
638 ratioTyConName      = tcQual  gHC_REAL (fsLit "Ratio") ratioTyConKey
639 ratioDataConName    = conName gHC_REAL (fsLit ":%") ratioDataConKey
640 realClassName       = clsQual gHC_REAL (fsLit "Real") realClassKey
641 integralClassName   = clsQual gHC_REAL (fsLit "Integral") integralClassKey
642 realFracClassName   = clsQual gHC_REAL (fsLit "RealFrac") realFracClassKey
643 fractionalClassName = clsQual gHC_REAL (fsLit "Fractional") fractionalClassKey
644 fromRationalName    = methName gHC_REAL  (fsLit "fromRational") fromRationalClassOpKey
645
646 -- PrelFloat classes
647 floatingClassName, realFloatClassName :: Name
648 floatingClassName  = clsQual  gHC_FLOAT (fsLit "Floating") floatingClassKey
649 realFloatClassName = clsQual  gHC_FLOAT (fsLit "RealFloat") realFloatClassKey
650
651 -- Class Ix
652 ixClassName :: Name
653 ixClassName = clsQual gHC_ARR (fsLit "Ix") ixClassKey
654
655 -- Class Typeable
656 typeableClassName, typeable1ClassName, typeable2ClassName,
657     typeable3ClassName, typeable4ClassName, typeable5ClassName,
658     typeable6ClassName, typeable7ClassName :: Name
659 typeableClassName  = clsQual tYPEABLE (fsLit "Typeable") typeableClassKey
660 typeable1ClassName = clsQual tYPEABLE (fsLit "Typeable1") typeable1ClassKey
661 typeable2ClassName = clsQual tYPEABLE (fsLit "Typeable2") typeable2ClassKey
662 typeable3ClassName = clsQual tYPEABLE (fsLit "Typeable3") typeable3ClassKey
663 typeable4ClassName = clsQual tYPEABLE (fsLit "Typeable4") typeable4ClassKey
664 typeable5ClassName = clsQual tYPEABLE (fsLit "Typeable5") typeable5ClassKey
665 typeable6ClassName = clsQual tYPEABLE (fsLit "Typeable6") typeable6ClassKey
666 typeable7ClassName = clsQual tYPEABLE (fsLit "Typeable7") typeable7ClassKey
667
668 typeableClassNames :: [Name]
669 typeableClassNames =    [ typeableClassName, typeable1ClassName, typeable2ClassName
670                         , typeable3ClassName, typeable4ClassName, typeable5ClassName
671                         , typeable6ClassName, typeable7ClassName ]
672
673 -- Class Data
674 dataClassName :: Name
675 dataClassName = clsQual gENERICS (fsLit "Data") dataClassKey
676
677 -- Error module
678 assertErrorName    :: Name
679 assertErrorName   = varQual gHC_IO_BASE (fsLit "assertError") assertErrorIdKey
680
681 -- Enum module (Enum, Bounded)
682 enumClassName, enumFromName, enumFromToName, enumFromThenName,
683     enumFromThenToName, boundedClassName :: Name
684 enumClassName      = clsQual gHC_ENUM (fsLit "Enum") enumClassKey
685 enumFromName       = methName gHC_ENUM (fsLit "enumFrom") enumFromClassOpKey
686 enumFromToName     = methName gHC_ENUM (fsLit "enumFromTo") enumFromToClassOpKey
687 enumFromThenName   = methName gHC_ENUM (fsLit "enumFromThen") enumFromThenClassOpKey
688 enumFromThenToName = methName gHC_ENUM (fsLit "enumFromThenTo") enumFromThenToClassOpKey
689 boundedClassName   = clsQual gHC_ENUM (fsLit "Bounded") boundedClassKey
690
691 -- List functions
692 concatName, filterName, zipName :: Name
693 concatName        = varQual gHC_LIST (fsLit "concat") concatIdKey
694 filterName        = varQual gHC_LIST (fsLit "filter") filterIdKey
695 zipName           = varQual gHC_LIST (fsLit "zip") zipIdKey
696
697 -- Class Show
698 showClassName :: Name
699 showClassName     = clsQual gHC_SHOW (fsLit "Show")       showClassKey
700
701 -- Class Read
702 readClassName :: Name
703 readClassName      = clsQual gHC_READ (fsLit "Read") readClassKey
704
705 -- parallel array types and functions
706 enumFromToPName, enumFromThenToPName, nullPName, lengthPName,
707     singletonPName, replicatePName, mapPName, filterPName,
708     zipPName, crossMapPName, indexPName, toPName, bpermutePName,
709     bpermuteDftPName, indexOfPName :: Name
710 enumFromToPName    = varQual gHC_PARR (fsLit "enumFromToP") enumFromToPIdKey
711 enumFromThenToPName= varQual gHC_PARR (fsLit "enumFromThenToP") enumFromThenToPIdKey
712 nullPName         = varQual gHC_PARR (fsLit "nullP")             nullPIdKey
713 lengthPName       = varQual gHC_PARR (fsLit "lengthP")           lengthPIdKey
714 singletonPName    = varQual gHC_PARR (fsLit "singletonP")         singletonPIdKey
715 replicatePName    = varQual gHC_PARR (fsLit "replicateP")        replicatePIdKey
716 mapPName          = varQual gHC_PARR (fsLit "mapP")              mapPIdKey
717 filterPName       = varQual gHC_PARR (fsLit "filterP")           filterPIdKey
718 zipPName          = varQual gHC_PARR (fsLit "zipP")              zipPIdKey
719 crossMapPName     = varQual gHC_PARR (fsLit "crossMapP")         crossMapPIdKey
720 indexPName        = varQual gHC_PARR (fsLit "!:")                indexPIdKey
721 toPName           = varQual gHC_PARR (fsLit "toP")               toPIdKey
722 bpermutePName     = varQual gHC_PARR (fsLit "bpermuteP")    bpermutePIdKey
723 bpermuteDftPName  = varQual gHC_PARR (fsLit "bpermuteDftP") bpermuteDftPIdKey
724 indexOfPName      = varQual gHC_PARR (fsLit "indexOfP")     indexOfPIdKey
725
726 -- IOBase things
727 ioTyConName, ioDataConName, thenIOName, bindIOName, returnIOName,
728     failIOName :: Name
729 ioTyConName       = tcQual  gHC_IO_BASE (fsLit "IO") ioTyConKey
730 ioDataConName     = conName gHC_IO_BASE (fsLit "IO") ioDataConKey
731 thenIOName        = varQual gHC_IO_BASE (fsLit "thenIO") thenIOIdKey
732 bindIOName        = varQual gHC_IO_BASE (fsLit "bindIO") bindIOIdKey
733 returnIOName      = varQual gHC_IO_BASE (fsLit "returnIO") returnIOIdKey
734 failIOName        = varQual gHC_IO_BASE (fsLit "failIO") failIOIdKey
735
736 -- IO things
737 printName :: Name
738 printName         = varQual sYSTEM_IO (fsLit "print") printIdKey
739
740 -- Int, Word, and Addr things
741 int8TyConName, int16TyConName, int32TyConName, int64TyConName :: Name
742 int8TyConName     = tcQual gHC_INT  (fsLit "Int8") int8TyConKey
743 int16TyConName    = tcQual gHC_INT  (fsLit "Int16") int16TyConKey
744 int32TyConName    = tcQual gHC_INT  (fsLit "Int32") int32TyConKey
745 int64TyConName    = tcQual gHC_INT  (fsLit "Int64") int64TyConKey
746
747 -- Word module
748 word8TyConName, word16TyConName, word32TyConName, word64TyConName,
749     wordTyConName, wordDataConName :: Name
750 word8TyConName    = tcQual  gHC_WORD (fsLit "Word8")  word8TyConKey
751 word16TyConName   = tcQual  gHC_WORD (fsLit "Word16") word16TyConKey
752 word32TyConName   = tcQual  gHC_WORD (fsLit "Word32") word32TyConKey
753 word64TyConName   = tcQual  gHC_WORD (fsLit "Word64") word64TyConKey
754 wordTyConName     = tcQual  gHC_WORD (fsLit "Word")   wordTyConKey
755 wordDataConName   = conName gHC_WORD (fsLit "W#") wordDataConKey
756
757 -- PrelPtr module
758 ptrTyConName, funPtrTyConName :: Name
759 ptrTyConName      = tcQual   gHC_PTR (fsLit "Ptr") ptrTyConKey
760 funPtrTyConName   = tcQual   gHC_PTR (fsLit "FunPtr") funPtrTyConKey
761
762 -- Foreign objects and weak pointers
763 stablePtrTyConName, newStablePtrName :: Name
764 stablePtrTyConName    = tcQual   gHC_STABLE (fsLit "StablePtr") stablePtrTyConKey
765 newStablePtrName      = varQual  gHC_STABLE (fsLit "newStablePtr") newStablePtrIdKey
766
767 -- PrelST module
768 runSTRepName :: Name
769 runSTRepName       = varQual gHC_ST  (fsLit "runSTRep") runSTRepIdKey
770
771 -- Recursive-do notation
772 monadFixClassName, mfixName :: Name
773 monadFixClassName  = clsQual mONAD_FIX (fsLit "MonadFix") monadFixClassKey
774 mfixName           = methName mONAD_FIX (fsLit "mfix") mfixIdKey
775
776 -- Arrow notation
777 arrAName, composeAName, firstAName, appAName, choiceAName, loopAName :: Name
778 arrAName           = varQual aRROW (fsLit "arr")          arrAIdKey
779 composeAName       = varQual gHC_DESUGAR (fsLit ">>>") composeAIdKey
780 firstAName         = varQual aRROW (fsLit "first") firstAIdKey
781 appAName           = varQual aRROW (fsLit "app")          appAIdKey
782 choiceAName        = varQual aRROW (fsLit "|||")          choiceAIdKey
783 loopAName          = varQual aRROW (fsLit "loop")  loopAIdKey
784
785 -- Other classes, needed for type defaulting
786 monadPlusClassName, randomClassName, randomGenClassName,
787     isStringClassName :: Name
788 monadPlusClassName  = clsQual mONAD (fsLit "MonadPlus")  monadPlusClassKey
789 randomClassName     = clsQual rANDOM (fsLit "Random")    randomClassKey
790 randomGenClassName  = clsQual rANDOM (fsLit "RandomGen") randomGenClassKey
791 isStringClassName   = clsQual dATA_STRING (fsLit "IsString") isStringClassKey
792
793 -- dotnet interop
794 objectTyConName :: Name
795 objectTyConName     = tcQual   dOTNET (fsLit "Object") objectTyConKey
796         -- objectTyConName was "wTcQual", but that's gone now, and
797         -- I can't see why it was wired in anyway...
798 unmarshalObjectName, marshalObjectName, marshalStringName,
799     unmarshalStringName, checkDotnetResName :: Name
800 unmarshalObjectName = varQual  dOTNET (fsLit "unmarshalObject") unmarshalObjectIdKey
801 marshalObjectName   = varQual  dOTNET (fsLit "marshalObject") marshalObjectIdKey
802 marshalStringName   = varQual  dOTNET (fsLit "marshalString") marshalStringIdKey
803 unmarshalStringName = varQual  dOTNET (fsLit "unmarshalString") unmarshalStringIdKey
804 checkDotnetResName  = varQual  dOTNET (fsLit "checkResult")     checkDotnetResNameIdKey
805 \end{code}
806
807 %************************************************************************
808 %*                                                                      *
809 \subsection{Local helpers}
810 %*                                                                      *
811 %************************************************************************
812
813 All these are original names; hence mkOrig
814
815 \begin{code}
816 varQual, tcQual, clsQual :: Module -> FastString -> Unique -> Name
817 varQual  = mk_known_key_name varName
818 tcQual   = mk_known_key_name tcName
819 clsQual  = mk_known_key_name clsName
820
821 mk_known_key_name :: NameSpace -> Module -> FastString -> Unique -> Name
822 mk_known_key_name space modu str unique 
823   = mkExternalName unique modu (mkOccNameFS space str) noSrcSpan
824
825 conName :: Module -> FastString -> Unique -> Name
826 conName modu occ unique
827   = mkExternalName unique modu (mkOccNameFS dataName occ) noSrcSpan
828
829 methName :: Module -> FastString -> Unique -> Name
830 methName modu occ unique
831   = mkExternalName unique modu (mkVarOccFS occ) noSrcSpan
832 \end{code}
833
834 %************************************************************************
835 %*                                                                      *
836 \subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@}
837 %*                                                                      *
838 %************************************************************************
839 --MetaHaskell extension hand allocate keys here
840
841 \begin{code}
842 boundedClassKey, enumClassKey, eqClassKey, floatingClassKey,
843     fractionalClassKey, integralClassKey, monadClassKey, dataClassKey,
844     functorClassKey, numClassKey, ordClassKey, readClassKey, realClassKey,
845     realFloatClassKey, realFracClassKey, showClassKey, ixClassKey :: Unique
846 boundedClassKey         = mkPreludeClassUnique 1 
847 enumClassKey            = mkPreludeClassUnique 2 
848 eqClassKey              = mkPreludeClassUnique 3 
849 floatingClassKey        = mkPreludeClassUnique 5 
850 fractionalClassKey      = mkPreludeClassUnique 6 
851 integralClassKey        = mkPreludeClassUnique 7 
852 monadClassKey           = mkPreludeClassUnique 8 
853 dataClassKey            = mkPreludeClassUnique 9
854 functorClassKey         = mkPreludeClassUnique 10
855 numClassKey             = mkPreludeClassUnique 11
856 ordClassKey             = mkPreludeClassUnique 12
857 readClassKey            = mkPreludeClassUnique 13
858 realClassKey            = mkPreludeClassUnique 14
859 realFloatClassKey       = mkPreludeClassUnique 15
860 realFracClassKey        = mkPreludeClassUnique 16
861 showClassKey            = mkPreludeClassUnique 17
862 ixClassKey              = mkPreludeClassUnique 18
863
864 typeableClassKey, typeable1ClassKey, typeable2ClassKey, typeable3ClassKey,
865     typeable4ClassKey, typeable5ClassKey, typeable6ClassKey, typeable7ClassKey
866     :: Unique
867 typeableClassKey        = mkPreludeClassUnique 20
868 typeable1ClassKey       = mkPreludeClassUnique 21
869 typeable2ClassKey       = mkPreludeClassUnique 22
870 typeable3ClassKey       = mkPreludeClassUnique 23
871 typeable4ClassKey       = mkPreludeClassUnique 24
872 typeable5ClassKey       = mkPreludeClassUnique 25
873 typeable6ClassKey       = mkPreludeClassUnique 26
874 typeable7ClassKey       = mkPreludeClassUnique 27
875
876 monadFixClassKey :: Unique
877 monadFixClassKey        = mkPreludeClassUnique 28
878
879 monadPlusClassKey, randomClassKey, randomGenClassKey :: Unique
880 monadPlusClassKey       = mkPreludeClassUnique 30
881 randomClassKey          = mkPreludeClassUnique 31
882 randomGenClassKey       = mkPreludeClassUnique 32
883
884 isStringClassKey :: Unique
885 isStringClassKey        = mkPreludeClassUnique 33
886 \end{code}
887
888 %************************************************************************
889 %*                                                                      *
890 \subsubsection[Uniques-prelude-TyCons]{@Uniques@ for wired-in @TyCons@}
891 %*                                                                      *
892 %************************************************************************
893
894 \begin{code}
895 addrPrimTyConKey, arrayPrimTyConKey, boolTyConKey, byteArrayPrimTyConKey,
896     charPrimTyConKey, charTyConKey, doublePrimTyConKey, doubleTyConKey,
897     floatPrimTyConKey, floatTyConKey, funTyConKey, intPrimTyConKey,
898     intTyConKey, int8TyConKey, int16TyConKey, int32PrimTyConKey,
899     int32TyConKey, int64PrimTyConKey, int64TyConKey, integerTyConKey,
900     listTyConKey, foreignObjPrimTyConKey, weakPrimTyConKey,
901     mutableArrayPrimTyConKey, mutableByteArrayPrimTyConKey,
902     orderingTyConKey, mVarPrimTyConKey, ratioTyConKey, rationalTyConKey,
903     realWorldTyConKey, stablePtrPrimTyConKey, stablePtrTyConKey :: Unique
904 addrPrimTyConKey                        = mkPreludeTyConUnique  1
905 arrayPrimTyConKey                       = mkPreludeTyConUnique  3
906 boolTyConKey                            = mkPreludeTyConUnique  4
907 byteArrayPrimTyConKey                   = mkPreludeTyConUnique  5
908 charPrimTyConKey                        = mkPreludeTyConUnique  7
909 charTyConKey                            = mkPreludeTyConUnique  8
910 doublePrimTyConKey                      = mkPreludeTyConUnique  9
911 doubleTyConKey                          = mkPreludeTyConUnique 10 
912 floatPrimTyConKey                       = mkPreludeTyConUnique 11
913 floatTyConKey                           = mkPreludeTyConUnique 12
914 funTyConKey                             = mkPreludeTyConUnique 13
915 intPrimTyConKey                         = mkPreludeTyConUnique 14
916 intTyConKey                             = mkPreludeTyConUnique 15
917 int8TyConKey                            = mkPreludeTyConUnique 16
918 int16TyConKey                           = mkPreludeTyConUnique 17
919 int32PrimTyConKey                       = mkPreludeTyConUnique 18
920 int32TyConKey                           = mkPreludeTyConUnique 19
921 int64PrimTyConKey                       = mkPreludeTyConUnique 20
922 int64TyConKey                           = mkPreludeTyConUnique 21
923 integerTyConKey                         = mkPreludeTyConUnique 22
924 listTyConKey                            = mkPreludeTyConUnique 23
925 foreignObjPrimTyConKey                  = mkPreludeTyConUnique 24
926 weakPrimTyConKey                        = mkPreludeTyConUnique 27
927 mutableArrayPrimTyConKey                = mkPreludeTyConUnique 28
928 mutableByteArrayPrimTyConKey            = mkPreludeTyConUnique 29
929 orderingTyConKey                        = mkPreludeTyConUnique 30
930 mVarPrimTyConKey                        = mkPreludeTyConUnique 31
931 ratioTyConKey                           = mkPreludeTyConUnique 32
932 rationalTyConKey                        = mkPreludeTyConUnique 33
933 realWorldTyConKey                       = mkPreludeTyConUnique 34
934 stablePtrPrimTyConKey                   = mkPreludeTyConUnique 35
935 stablePtrTyConKey                       = mkPreludeTyConUnique 36
936
937 anyPrimTyConKey, anyPrimTyCon1Key :: Unique
938 anyPrimTyConKey                         = mkPreludeTyConUnique 37
939 anyPrimTyCon1Key                        = mkPreludeTyConUnique 38
940
941 statePrimTyConKey, stableNamePrimTyConKey, stableNameTyConKey,
942     mutVarPrimTyConKey, ioTyConKey,
943     wordPrimTyConKey, wordTyConKey, word8TyConKey, word16TyConKey,
944     word32PrimTyConKey, word32TyConKey, word64PrimTyConKey, word64TyConKey,
945     liftedConKey, unliftedConKey, anyBoxConKey, kindConKey, boxityConKey,
946     typeConKey, threadIdPrimTyConKey, bcoPrimTyConKey, ptrTyConKey,
947     funPtrTyConKey, tVarPrimTyConKey :: Unique
948 statePrimTyConKey                       = mkPreludeTyConUnique 50
949 stableNamePrimTyConKey                  = mkPreludeTyConUnique 51
950 stableNameTyConKey                      = mkPreludeTyConUnique 52
951 mutVarPrimTyConKey                      = mkPreludeTyConUnique 55
952 ioTyConKey                              = mkPreludeTyConUnique 56
953 wordPrimTyConKey                        = mkPreludeTyConUnique 58
954 wordTyConKey                            = mkPreludeTyConUnique 59
955 word8TyConKey                           = mkPreludeTyConUnique 60
956 word16TyConKey                          = mkPreludeTyConUnique 61 
957 word32PrimTyConKey                      = mkPreludeTyConUnique 62 
958 word32TyConKey                          = mkPreludeTyConUnique 63
959 word64PrimTyConKey                      = mkPreludeTyConUnique 64
960 word64TyConKey                          = mkPreludeTyConUnique 65
961 liftedConKey                            = mkPreludeTyConUnique 66
962 unliftedConKey                          = mkPreludeTyConUnique 67
963 anyBoxConKey                            = mkPreludeTyConUnique 68
964 kindConKey                              = mkPreludeTyConUnique 69
965 boxityConKey                            = mkPreludeTyConUnique 70
966 typeConKey                              = mkPreludeTyConUnique 71
967 threadIdPrimTyConKey                    = mkPreludeTyConUnique 72
968 bcoPrimTyConKey                         = mkPreludeTyConUnique 73
969 ptrTyConKey                             = mkPreludeTyConUnique 74
970 funPtrTyConKey                          = mkPreludeTyConUnique 75
971 tVarPrimTyConKey                        = mkPreludeTyConUnique 76
972
973 -- Generic Type Constructors
974 crossTyConKey, plusTyConKey, genUnitTyConKey :: Unique
975 crossTyConKey                           = mkPreludeTyConUnique 79
976 plusTyConKey                            = mkPreludeTyConUnique 80
977 genUnitTyConKey                         = mkPreludeTyConUnique 81
978
979 -- Parallel array type constructor
980 parrTyConKey :: Unique
981 parrTyConKey                            = mkPreludeTyConUnique 82
982
983 -- dotnet interop
984 objectTyConKey :: Unique
985 objectTyConKey                          = mkPreludeTyConUnique 83
986
987 eitherTyConKey :: Unique
988 eitherTyConKey                          = mkPreludeTyConUnique 84
989
990 -- Super Kinds constructors
991 tySuperKindTyConKey, coSuperKindTyConKey :: Unique
992 tySuperKindTyConKey                    = mkPreludeTyConUnique 85
993 coSuperKindTyConKey                    = mkPreludeTyConUnique 86
994
995 -- Kind constructors
996 liftedTypeKindTyConKey, openTypeKindTyConKey, unliftedTypeKindTyConKey,
997     ubxTupleKindTyConKey, argTypeKindTyConKey :: Unique
998 liftedTypeKindTyConKey                  = mkPreludeTyConUnique 87
999 openTypeKindTyConKey                    = mkPreludeTyConUnique 88
1000 unliftedTypeKindTyConKey                = mkPreludeTyConUnique 89
1001 ubxTupleKindTyConKey                    = mkPreludeTyConUnique 90
1002 argTypeKindTyConKey                     = mkPreludeTyConUnique 91
1003
1004 -- Coercion constructors
1005 symCoercionTyConKey, transCoercionTyConKey, leftCoercionTyConKey,
1006     rightCoercionTyConKey, instCoercionTyConKey, unsafeCoercionTyConKey
1007     :: Unique
1008 symCoercionTyConKey                     = mkPreludeTyConUnique 93
1009 transCoercionTyConKey                   = mkPreludeTyConUnique 94
1010 leftCoercionTyConKey                    = mkPreludeTyConUnique 95
1011 rightCoercionTyConKey                   = mkPreludeTyConUnique 96
1012 instCoercionTyConKey                    = mkPreludeTyConUnique 97
1013 unsafeCoercionTyConKey                  = mkPreludeTyConUnique 98
1014
1015 unknownTyConKey, unknown1TyConKey, unknown2TyConKey, unknown3TyConKey,
1016     opaqueTyConKey :: Unique
1017 unknownTyConKey                         = mkPreludeTyConUnique 99
1018 unknown1TyConKey                        = mkPreludeTyConUnique 130
1019 unknown2TyConKey                        = mkPreludeTyConUnique 131
1020 unknown3TyConKey                        = mkPreludeTyConUnique 132
1021 opaqueTyConKey                          = mkPreludeTyConUnique 133
1022
1023 stringTyConKey :: Unique
1024 stringTyConKey                          = mkPreludeTyConUnique 134
1025
1026 ---------------- Template Haskell -------------------
1027 --      USES TyConUniques 100-129
1028 -----------------------------------------------------
1029
1030 unitTyConKey :: Unique
1031 unitTyConKey = mkTupleTyConUnique Boxed 0
1032 \end{code}
1033
1034 %************************************************************************
1035 %*                                                                      *
1036 \subsubsection[Uniques-prelude-DataCons]{@Uniques@ for wired-in @DataCons@}
1037 %*                                                                      *
1038 %************************************************************************
1039
1040 \begin{code}
1041 charDataConKey, consDataConKey, doubleDataConKey, falseDataConKey,
1042     floatDataConKey, intDataConKey, nilDataConKey, ratioDataConKey,
1043     stableNameDataConKey, trueDataConKey, wordDataConKey,
1044     ioDataConKey :: Unique
1045 charDataConKey                          = mkPreludeDataConUnique  1
1046 consDataConKey                          = mkPreludeDataConUnique  2
1047 doubleDataConKey                        = mkPreludeDataConUnique  3
1048 falseDataConKey                         = mkPreludeDataConUnique  4
1049 floatDataConKey                         = mkPreludeDataConUnique  5
1050 intDataConKey                           = mkPreludeDataConUnique  6
1051 nilDataConKey                           = mkPreludeDataConUnique 11
1052 ratioDataConKey                         = mkPreludeDataConUnique 12
1053 stableNameDataConKey                    = mkPreludeDataConUnique 14
1054 trueDataConKey                          = mkPreludeDataConUnique 15
1055 wordDataConKey                          = mkPreludeDataConUnique 16
1056 ioDataConKey                            = mkPreludeDataConUnique 17
1057
1058 -- Generic data constructors
1059 crossDataConKey, inlDataConKey, inrDataConKey, genUnitDataConKey :: Unique
1060 crossDataConKey                         = mkPreludeDataConUnique 20
1061 inlDataConKey                           = mkPreludeDataConUnique 21
1062 inrDataConKey                           = mkPreludeDataConUnique 22
1063 genUnitDataConKey                       = mkPreludeDataConUnique 23
1064
1065 -- Data constructor for parallel arrays
1066 parrDataConKey :: Unique
1067 parrDataConKey                          = mkPreludeDataConUnique 24
1068
1069 leftDataConKey, rightDataConKey :: Unique
1070 leftDataConKey                          = mkPreludeDataConUnique 25
1071 rightDataConKey                         = mkPreludeDataConUnique 26
1072 \end{code}
1073
1074 %************************************************************************
1075 %*                                                                      *
1076 \subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}
1077 %*                                                                      *
1078 %************************************************************************
1079
1080 \begin{code}
1081 absentErrorIdKey, augmentIdKey, appendIdKey, buildIdKey, errorIdKey,
1082     foldlIdKey, foldrIdKey, recSelErrorIdKey,
1083     integerMinusOneIdKey, integerPlusOneIdKey,
1084     integerPlusTwoIdKey, integerZeroIdKey,
1085     int2IntegerIdKey, seqIdKey, irrefutPatErrorIdKey, eqStringIdKey,
1086     noMethodBindingErrorIdKey, nonExhaustiveGuardsErrorIdKey,
1087     runtimeErrorIdKey, parErrorIdKey, parIdKey, patErrorIdKey,
1088     realWorldPrimIdKey, recConErrorIdKey, recUpdErrorIdKey,
1089     traceIdKey,
1090     unpackCStringUtf8IdKey, unpackCStringAppendIdKey,
1091     unpackCStringFoldrIdKey, unpackCStringIdKey :: Unique
1092 absentErrorIdKey              = mkPreludeMiscIdUnique  1
1093 augmentIdKey                  = mkPreludeMiscIdUnique  3
1094 appendIdKey                   = mkPreludeMiscIdUnique  4
1095 buildIdKey                    = mkPreludeMiscIdUnique  5
1096 errorIdKey                    = mkPreludeMiscIdUnique  6
1097 foldlIdKey                    = mkPreludeMiscIdUnique  7
1098 foldrIdKey                    = mkPreludeMiscIdUnique  8
1099 recSelErrorIdKey              = mkPreludeMiscIdUnique  9
1100 integerMinusOneIdKey          = mkPreludeMiscIdUnique 10
1101 integerPlusOneIdKey           = mkPreludeMiscIdUnique 11
1102 integerPlusTwoIdKey           = mkPreludeMiscIdUnique 12
1103 integerZeroIdKey              = mkPreludeMiscIdUnique 13
1104 int2IntegerIdKey              = mkPreludeMiscIdUnique 14
1105 seqIdKey                      = mkPreludeMiscIdUnique 15
1106 irrefutPatErrorIdKey          = mkPreludeMiscIdUnique 16
1107 eqStringIdKey                 = mkPreludeMiscIdUnique 17
1108 noMethodBindingErrorIdKey     = mkPreludeMiscIdUnique 18
1109 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 19
1110 runtimeErrorIdKey             = mkPreludeMiscIdUnique 20 
1111 parErrorIdKey                 = mkPreludeMiscIdUnique 21
1112 parIdKey                      = mkPreludeMiscIdUnique 22
1113 patErrorIdKey                 = mkPreludeMiscIdUnique 23
1114 realWorldPrimIdKey            = mkPreludeMiscIdUnique 24
1115 recConErrorIdKey              = mkPreludeMiscIdUnique 25
1116 recUpdErrorIdKey              = mkPreludeMiscIdUnique 26
1117 traceIdKey                    = mkPreludeMiscIdUnique 27
1118 unpackCStringUtf8IdKey        = mkPreludeMiscIdUnique 28
1119 unpackCStringAppendIdKey      = mkPreludeMiscIdUnique 29
1120 unpackCStringFoldrIdKey       = mkPreludeMiscIdUnique 30
1121 unpackCStringIdKey            = mkPreludeMiscIdUnique 31
1122
1123 unsafeCoerceIdKey, concatIdKey, filterIdKey, zipIdKey, bindIOIdKey,
1124     returnIOIdKey, deRefStablePtrIdKey, newStablePtrIdKey,
1125     smallIntegerIdKey, plusIntegerIdKey, timesIntegerIdKey,
1126     printIdKey, failIOIdKey, nullAddrIdKey, voidArgIdKey,
1127     fstIdKey, sndIdKey, otherwiseIdKey, assertIdKey, runSTRepIdKey :: Unique
1128 unsafeCoerceIdKey             = mkPreludeMiscIdUnique 32
1129 concatIdKey                   = mkPreludeMiscIdUnique 33
1130 filterIdKey                   = mkPreludeMiscIdUnique 34
1131 zipIdKey                      = mkPreludeMiscIdUnique 35
1132 bindIOIdKey                   = mkPreludeMiscIdUnique 36
1133 returnIOIdKey                 = mkPreludeMiscIdUnique 37
1134 deRefStablePtrIdKey           = mkPreludeMiscIdUnique 38
1135 newStablePtrIdKey             = mkPreludeMiscIdUnique 39
1136 smallIntegerIdKey             = mkPreludeMiscIdUnique 40
1137 plusIntegerIdKey              = mkPreludeMiscIdUnique 41
1138 timesIntegerIdKey             = mkPreludeMiscIdUnique 42
1139 printIdKey                    = mkPreludeMiscIdUnique 43
1140 failIOIdKey                   = mkPreludeMiscIdUnique 44
1141 nullAddrIdKey                 = mkPreludeMiscIdUnique 46
1142 voidArgIdKey                  = mkPreludeMiscIdUnique 47
1143 fstIdKey                      = mkPreludeMiscIdUnique 49
1144 sndIdKey                      = mkPreludeMiscIdUnique 50
1145 otherwiseIdKey                = mkPreludeMiscIdUnique 51
1146 assertIdKey                   = mkPreludeMiscIdUnique 53
1147 runSTRepIdKey                 = mkPreludeMiscIdUnique 54
1148
1149 rootMainKey, runMainKey :: Unique
1150 rootMainKey                   = mkPreludeMiscIdUnique 55
1151 runMainKey                    = mkPreludeMiscIdUnique 56
1152
1153 andIdKey, orIdKey, thenIOIdKey, lazyIdKey, assertErrorIdKey :: Unique
1154 andIdKey                      = mkPreludeMiscIdUnique 57
1155 orIdKey                       = mkPreludeMiscIdUnique 58
1156 thenIOIdKey                   = mkPreludeMiscIdUnique 59
1157 lazyIdKey                     = mkPreludeMiscIdUnique 60
1158 assertErrorIdKey              = mkPreludeMiscIdUnique 61
1159
1160 breakpointIdKey, breakpointCondIdKey, breakpointAutoIdKey,
1161     breakpointJumpIdKey, breakpointCondJumpIdKey,
1162     breakpointAutoJumpIdKey :: Unique
1163 breakpointIdKey               = mkPreludeMiscIdUnique 62
1164 breakpointCondIdKey           = mkPreludeMiscIdUnique 63
1165 breakpointAutoIdKey           = mkPreludeMiscIdUnique 64
1166 breakpointJumpIdKey           = mkPreludeMiscIdUnique 65
1167 breakpointCondJumpIdKey       = mkPreludeMiscIdUnique 66
1168 breakpointAutoJumpIdKey       = mkPreludeMiscIdUnique 67
1169
1170 inlineIdKey :: Unique
1171 inlineIdKey                   = mkPreludeMiscIdUnique 68
1172
1173 mapIdKey, groupWithIdKey :: Unique
1174 mapIdKey                      = mkPreludeMiscIdUnique 69
1175 groupWithIdKey        = mkPreludeMiscIdUnique 70
1176
1177 -- Parallel array functions
1178 singletonPIdKey, nullPIdKey, lengthPIdKey, replicatePIdKey, mapPIdKey,
1179     filterPIdKey, zipPIdKey, crossMapPIdKey, indexPIdKey, toPIdKey,
1180     enumFromToPIdKey, enumFromThenToPIdKey,
1181     bpermutePIdKey, bpermuteDftPIdKey, indexOfPIdKey :: Unique
1182 singletonPIdKey               = mkPreludeMiscIdUnique 79
1183 nullPIdKey                    = mkPreludeMiscIdUnique 80
1184 lengthPIdKey                  = mkPreludeMiscIdUnique 81
1185 replicatePIdKey               = mkPreludeMiscIdUnique 82
1186 mapPIdKey                     = mkPreludeMiscIdUnique 83
1187 filterPIdKey                  = mkPreludeMiscIdUnique 84
1188 zipPIdKey                     = mkPreludeMiscIdUnique 85
1189 crossMapPIdKey                = mkPreludeMiscIdUnique 86
1190 indexPIdKey                   = mkPreludeMiscIdUnique 87
1191 toPIdKey                      = mkPreludeMiscIdUnique 88
1192 enumFromToPIdKey              = mkPreludeMiscIdUnique 89
1193 enumFromThenToPIdKey          = mkPreludeMiscIdUnique 90
1194 bpermutePIdKey                = mkPreludeMiscIdUnique 91
1195 bpermuteDftPIdKey             = mkPreludeMiscIdUnique 92
1196 indexOfPIdKey                 = mkPreludeMiscIdUnique 93
1197
1198 -- dotnet interop
1199 unmarshalObjectIdKey, marshalObjectIdKey, marshalStringIdKey,
1200     unmarshalStringIdKey, checkDotnetResNameIdKey :: Unique
1201 unmarshalObjectIdKey          = mkPreludeMiscIdUnique 94
1202 marshalObjectIdKey            = mkPreludeMiscIdUnique 95
1203 marshalStringIdKey            = mkPreludeMiscIdUnique 96
1204 unmarshalStringIdKey          = mkPreludeMiscIdUnique 97
1205 checkDotnetResNameIdKey       = mkPreludeMiscIdUnique 98
1206
1207 \end{code}
1208
1209 Certain class operations from Prelude classes.  They get their own
1210 uniques so we can look them up easily when we want to conjure them up
1211 during type checking.
1212
1213 \begin{code}
1214         -- Just a place holder for  unbound variables  produced by the renamer:
1215 unboundKey :: Unique
1216 unboundKey                    = mkPreludeMiscIdUnique 101 
1217
1218 fromIntegerClassOpKey, minusClassOpKey, fromRationalClassOpKey,
1219     enumFromClassOpKey, enumFromThenClassOpKey, enumFromToClassOpKey,
1220     enumFromThenToClassOpKey, eqClassOpKey, geClassOpKey, negateClassOpKey,
1221     failMClassOpKey, bindMClassOpKey, thenMClassOpKey, returnMClassOpKey
1222     :: Unique
1223 fromIntegerClassOpKey         = mkPreludeMiscIdUnique 102
1224 minusClassOpKey               = mkPreludeMiscIdUnique 103
1225 fromRationalClassOpKey        = mkPreludeMiscIdUnique 104
1226 enumFromClassOpKey            = mkPreludeMiscIdUnique 105
1227 enumFromThenClassOpKey        = mkPreludeMiscIdUnique 106
1228 enumFromToClassOpKey          = mkPreludeMiscIdUnique 107
1229 enumFromThenToClassOpKey      = mkPreludeMiscIdUnique 108
1230 eqClassOpKey                  = mkPreludeMiscIdUnique 109
1231 geClassOpKey                  = mkPreludeMiscIdUnique 110
1232 negateClassOpKey              = mkPreludeMiscIdUnique 111
1233 failMClassOpKey               = mkPreludeMiscIdUnique 112
1234 bindMClassOpKey               = mkPreludeMiscIdUnique 113 -- (>>=)
1235 thenMClassOpKey               = mkPreludeMiscIdUnique 114 -- (>>)
1236 returnMClassOpKey             = mkPreludeMiscIdUnique 117
1237
1238 -- Recursive do notation
1239 mfixIdKey :: Unique
1240 mfixIdKey       = mkPreludeMiscIdUnique 118
1241
1242 -- Arrow notation
1243 arrAIdKey, composeAIdKey, firstAIdKey, appAIdKey, choiceAIdKey,
1244     loopAIdKey :: Unique
1245 arrAIdKey       = mkPreludeMiscIdUnique 119
1246 composeAIdKey   = mkPreludeMiscIdUnique 120 -- >>>
1247 firstAIdKey     = mkPreludeMiscIdUnique 121
1248 appAIdKey       = mkPreludeMiscIdUnique 122
1249 choiceAIdKey    = mkPreludeMiscIdUnique 123 --  |||
1250 loopAIdKey      = mkPreludeMiscIdUnique 124
1251
1252 fromStringClassOpKey :: Unique
1253 fromStringClassOpKey          = mkPreludeMiscIdUnique 125
1254
1255 ---------------- Template Haskell -------------------
1256 --      USES IdUniques 200-399
1257 -----------------------------------------------------
1258 \end{code}
1259
1260
1261 %************************************************************************
1262 %*                                                                      *
1263 \subsection{Standard groups of types}
1264 %*                                                                      *
1265 %************************************************************************
1266
1267 \begin{code}
1268 numericTyKeys :: [Unique]
1269 numericTyKeys = 
1270         [ wordTyConKey
1271         , intTyConKey
1272         , integerTyConKey
1273         , doubleTyConKey
1274         , floatTyConKey
1275         ]
1276 \end{code}
1277
1278
1279 %************************************************************************
1280 %*                                                                      *
1281 \subsection[Class-std-groups]{Standard groups of Prelude classes}
1282 %*                                                                      *
1283 %************************************************************************
1284
1285 NOTE: @Eq@ and @Text@ do need to appear in @standardClasses@
1286 even though every numeric class has these two as a superclass,
1287 because the list of ambiguous dictionaries hasn't been simplified.
1288
1289 \begin{code}
1290 numericClassKeys :: [Unique]
1291 numericClassKeys =
1292         [ numClassKey
1293         , realClassKey
1294         , integralClassKey
1295         ]
1296         ++ fractionalClassKeys
1297
1298 fractionalClassKeys :: [Unique]
1299 fractionalClassKeys = 
1300         [ fractionalClassKey
1301         , floatingClassKey
1302         , realFracClassKey
1303         , realFloatClassKey
1304         ]
1305
1306         -- the strictness analyser needs to know about numeric types
1307         -- (see SaAbsInt.lhs)
1308 needsDataDeclCtxtClassKeys :: [Unique]
1309 needsDataDeclCtxtClassKeys = -- see comments in TcDeriv
1310         [ readClassKey
1311         ]
1312
1313 -- The "standard classes" are used in defaulting (Haskell 98 report 4.3.4),
1314 -- and are: "classes defined in the Prelude or a standard library"
1315 standardClassKeys :: [Unique]
1316 standardClassKeys = derivableClassKeys ++ numericClassKeys
1317                   ++ [randomClassKey, randomGenClassKey,
1318                       functorClassKey, 
1319                       monadClassKey, monadPlusClassKey,
1320                       isStringClassKey
1321                      ]
1322 \end{code}
1323
1324 @derivableClassKeys@ is also used in checking \tr{deriving} constructs
1325 (@TcDeriv@).
1326
1327 \begin{code}
1328 derivableClassKeys :: [Unique]
1329 derivableClassKeys
1330   = [ eqClassKey, ordClassKey, enumClassKey, ixClassKey,
1331       boundedClassKey, showClassKey, readClassKey ]
1332 \end{code}
1333