ghc/compiler/basicTypes/Unique.lhs

   1 %
   2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1996
   3 %
   4 \section[Unique]{The @Unique@ data type}
   5
   6 @Uniques@ are used to distinguish entities in the compiler (@Ids@,
   7 @Classes@, etc.) from each other.  Thus, @Uniques@ are the basic
   8 comparison key in the compiler.
   9
  10 If there is any single operation that needs to be fast, it is @Unique@
  11 comparison.  Unsurprisingly, there is quite a bit of huff-and-puff
  12 directed to that end.
  13
  14 Some of the other hair in this code is to be able to use a
  15 ``splittable @UniqueSupply@'' if requested/possible (not standard
  16 Haskell).
  17
  18 \begin{code}
  19 #include "HsVersions.h"
  20
  21 --<mkdependHS:friends> UniqSupply
  22
  23 module Unique (
  24         Unique, Uniquable(..),
  25         u2i,                            -- hack: used in UniqFM
  26
  27         pprUnique, pprUnique10, showUnique,
  28
  29         mkUnique,                       -- Used in UniqSupply
  30         mkUniqueGrimily,                -- Used in UniqSupply only!
  31
  32         incrUnique,                     -- Used for renumbering
  33         initTyVarUnique, mkTyVarUnique,
  34         initTidyUniques,
  35
  36         -- now all the built-in Uniques (and functions to make them)
  37         -- [the Oh-So-Wonderful Haskell module system wins again...]
  38         mkAlphaTyVarUnique,
  39         mkPrimOpIdUnique,
  40         mkTupleDataConUnique,
  41         mkTupleTyConUnique,
  42
  43         getBuiltinUniques, mkBuiltinUnique,
  44         mkPseudoUnique1, mkPseudoUnique2, mkPseudoUnique3,
  45
  46         absentErrorIdKey,       -- alphabetical...
  47         addrDataConKey,
  48         addrPrimTyConKey,
  49         addrTyConKey,
  50         andandIdKey,
  51         appendIdKey,
  52         arrayPrimTyConKey,
  53         augmentIdKey,
  54         boolTyConKey,
  55         boundedClassKey,
  56         buildDataConKey,
  57         buildIdKey,
  58         byteArrayPrimTyConKey,
  59         cCallableClassKey,
  60         cReturnableClassKey,
  61         charDataConKey,
  62         charPrimTyConKey,
  63         charTyConKey,
  64         composeIdKey,
  65         consDataConKey,
  66         doubleDataConKey,
  67         doublePrimTyConKey,
  68         doubleTyConKey,
  69         enumClassKey,
  70         enumFromClassOpKey,
  71         enumFromThenClassOpKey,
  72         enumFromThenToClassOpKey,
  73         enumFromToClassOpKey,
  74         eqClassKey,
  75         eqClassOpKey,
  76         eqDataConKey,
  77         errorIdKey,
  78         evalClassKey,
  79         falseDataConKey,
  80         floatDataConKey,
  81         floatPrimTyConKey,
  82         floatTyConKey,
  83         floatingClassKey,
  84         foldlIdKey,
  85         foldrIdKey,
  86         foreignObjDataConKey,
  87         foreignObjPrimTyConKey,
  88         foreignObjTyConKey,
  89         forkIdKey,
  90         fractionalClassKey,
  91         fromEnumClassOpKey,
  92         fromIntClassOpKey,
  93         fromIntegerClassOpKey,
  94         fromRationalClassOpKey,
  95         funTyConKey,
  96         functorClassKey,
  97         geClassOpKey,
  98         gtDataConKey,
  99         intDataConKey,
 100         intPrimTyConKey,
 101         intTyConKey,
 102         integerDataConKey,
 103         integerMinusOneIdKey,
 104         integerPlusOneIdKey,
 105         integerPlusTwoIdKey,
 106         integerTyConKey,
 107         integerZeroIdKey,
 108         integralClassKey,
 109         irrefutPatErrorIdKey,
 110         ixClassKey,
 111         lexIdKey,
 112         liftDataConKey,
 113         liftTyConKey,
 114         listTyConKey,
 115         ltDataConKey,
 116         mainKey,
 117         minusClassOpKey,
 118         monadClassKey,
 119         monadPlusClassKey,
 120         monadZeroClassKey,
 121         mutableArrayPrimTyConKey,
 122         mutableByteArrayPrimTyConKey,
 123         nilDataConKey,
 124         noDefaultMethodErrorIdKey,
 125         nonExhaustiveGuardsErrorIdKey,
 126         nonExplicitMethodErrorIdKey,
 127         notIdKey,
 128         numClassKey,
 129         ordClassKey,
 130         orderingTyConKey,
 131         otherwiseIdKey,
 132         packCStringIdKey,
 133         parErrorIdKey,
 134         parIdKey,
 135         patErrorIdKey,
 136         ratioDataConKey,
 137         ratioTyConKey,
 138         rationalTyConKey,
 139         readClassKey,
 140         readParenIdKey,
 141         realClassKey,
 142         realFloatClassKey,
 143         realFracClassKey,
 144         realWorldPrimIdKey,
 145         realWorldTyConKey,
 146         recConErrorIdKey,
 147         recUpdErrorIdKey,
 148         return2GMPsDataConKey,
 149         return2GMPsTyConKey,
 150         returnIntAndGMPDataConKey,
 151         returnIntAndGMPTyConKey,
 152         returnMClassOpKey,
 153         seqIdKey,
 154         showClassKey,
 155         showParenIdKey,
 156         showSpaceIdKey,
 157         showStringIdKey,
 158         stTyConKey,
 159         stDataConKey,
 160         ioTyConKey,
 161         ioDataConKey,
 162         ioResultTyConKey,
 163         ioOkDataConKey,
 164         ioFailDataConKey,
 165         stablePtrDataConKey,
 166         stablePtrPrimTyConKey,
 167         stablePtrTyConKey,
 168         stateAndAddrPrimDataConKey,
 169         stateAndAddrPrimTyConKey,
 170         stateAndArrayPrimDataConKey,
 171         stateAndArrayPrimTyConKey,
 172         stateAndByteArrayPrimDataConKey,
 173         stateAndByteArrayPrimTyConKey,
 174         stateAndCharPrimDataConKey,
 175         stateAndCharPrimTyConKey,
 176         stateAndDoublePrimDataConKey,
 177         stateAndDoublePrimTyConKey,
 178         stateAndFloatPrimDataConKey,
 179         stateAndFloatPrimTyConKey,
 180         stateAndForeignObjPrimDataConKey,
 181         stateAndForeignObjPrimTyConKey,
 182         stateAndIntPrimDataConKey,
 183         stateAndIntPrimTyConKey,
 184         stateAndMutableArrayPrimDataConKey,
 185         stateAndMutableArrayPrimTyConKey,
 186         stateAndMutableByteArrayPrimDataConKey,
 187         stateAndMutableByteArrayPrimTyConKey,
 188         stateAndPtrPrimDataConKey,
 189         stateAndPtrPrimTyConKey,
 190         stateAndStablePtrPrimDataConKey,
 191         stateAndStablePtrPrimTyConKey,
 192         stateAndSynchVarPrimDataConKey,
 193         stateAndSynchVarPrimTyConKey,
 194         stateAndWordPrimDataConKey,
 195         stateAndWordPrimTyConKey,
 196         stateDataConKey,
 197         stRetDataConKey,
 198         statePrimTyConKey,
 199         stateTyConKey,
 200         stRetTyConKey,
 201         synchVarPrimTyConKey,
 202         thenMClassOpKey,
 203         toEnumClassOpKey,
 204         traceIdKey,
 205         trueDataConKey,
 206         unpackCString2IdKey,
 207         unpackCStringAppendIdKey,
 208         unpackCStringFoldrIdKey,
 209         unpackCStringIdKey,
 210         ureadListIdKey,
 211         ushowListIdKey,
 212         voidIdKey,
 213         voidTyConKey,
 214         wordDataConKey,
 215         wordPrimTyConKey,
 216         wordTyConKey,
 217         zeroClassOpKey
 218         , copyableIdKey
 219         , noFollowIdKey
 220         , parAtAbsIdKey
 221         , parAtForNowIdKey
 222         , parAtIdKey
 223         , parAtRelIdKey
 224         , parGlobalIdKey
 225         , parLocalIdKey
 226         , unboundKey
 227         , byteArrayTyConKey
 228         , mutableByteArrayTyConKey
 229         , allClassKey
 230     ) where
 231
 232 #if __GLASGOW_HASKELL__ <= 201
 233 import PreludeGlaST
 234 #else
 235 import GlaExts
 236 import ST
 237 import PrelBase ( Char(..), chr, ord )
 238 #endif
 239
 240 IMP_Ubiq(){-uitous-}
 241
 242 import Outputable
 243 import Pretty
 244 import Util
 245 \end{code}
 246
 247 %************************************************************************
 248 %*                                                                      *
 249 \subsection[Unique-type]{@Unique@ type and operations}
 250 %*                                                                      *
 251 %************************************************************************
 252
 253 The @Chars@ are ``tag letters'' that identify the @UniqueSupply@.
 254 Fast comparison is everything on @Uniques@:
 255
 256 \begin{code}
 257 data Unique = MkUnique Int#
 258
 259 class Uniquable a where
 260     uniqueOf :: a -> Unique
 261 \end{code}
 262
 263 \begin{code}
 264 u2i :: Unique -> FAST_INT
 265 u2i (MkUnique i) = i
 266 \end{code}
 267
 268 Now come the functions which construct uniques from their pieces, and vice versa.
 269 The stuff about unique *supplies* is handled further down this module.
 270
 271 \begin{code}
 272 mkUnique        :: Char -> Int -> Unique        -- Builds a unique from pieces
 273 unpkUnique      :: Unique -> (Char, Int)        -- The reverse
 274
 275 mkUniqueGrimily :: Int# -> Unique               -- A trap-door for UniqSupply
 276
 277 incrUnique      :: Unique -> Unique
 278 \end{code}
 279
 280
 281 \begin{code}
 282 mkUniqueGrimily x = MkUnique x
 283
 284 incrUnique (MkUnique i) = MkUnique (i +# 1#)
 285
 286 -- pop the Char in the top 8 bits of the Unique(Supply)
 287
 288 -- No 64-bit bugs here, as long as we have at least 32 bits. --JSM
 289
 290 w2i x = word2Int# x
 291 i2w x = int2Word# x
 292 i2w_s x = (x::Int#)
 293
 294 mkUnique (C# c) (I# i)
 295   = MkUnique (w2i (((i2w (ord# c)) `shiftL#` (i2w_s 24#)) `or#` (i2w i)))
 296
 297 unpkUnique (MkUnique u)
 298   = let
 299         tag = C# (chr# (w2i ((i2w u) `shiftr` (i2w_s 24#))))
 300         i   = I#  (w2i ((i2w u) `and#` (i2w 16777215#){-``0x00ffffff''-}))
 301     in
 302     (tag, i)
 303   where
 304     shiftr x y = shiftRA# x y
 305 \end{code}
 306
 307 %************************************************************************
 308 %*                                                                      *
 309 \subsection[Unique-instances]{Instance declarations for @Unique@}
 310 %*                                                                      *
 311 %************************************************************************
 312
 313 And the whole point (besides uniqueness) is fast equality.  We don't
 314 use `deriving' because we want {\em precise} control of ordering
 315 (equality on @Uniques@ is v common).
 316
 317 \begin{code}
 318 eqUnique (MkUnique u1) (MkUnique u2) = u1 ==# u2
 319 ltUnique (MkUnique u1) (MkUnique u2) = u1 <#  u2
 320 leUnique (MkUnique u1) (MkUnique u2) = u1 <=# u2
 321
 322 cmpUnique (MkUnique u1) (MkUnique u2)
 323   = if u1 ==# u2 then EQ_ else if u1 <# u2 then LT_ else GT_
 324
 325 instance Eq Unique where
 326     a == b = eqUnique a b
 327     a /= b = not (eqUnique a b)
 328
 329 instance Ord Unique where
 330     a  < b = ltUnique a b
 331     a <= b = leUnique a b
 332     a  > b = not (leUnique a b)
 333     a >= b = not (ltUnique a b)
 334     _tagCmp a b = case cmpUnique a b of { LT_ -> _LT; EQ_ -> _EQ; GT__ -> _GT }
 335
 336 instance Ord3 Unique where
 337     cmp = cmpUnique
 338
 339 -----------------
 340 instance Uniquable Unique where
 341     uniqueOf u = u
 342 \end{code}
 343
 344 We do sometimes make strings with @Uniques@ in them:
 345 \begin{code}
 346 pprUnique, pprUnique10 :: Unique -> Doc
 347
 348 pprUnique uniq
 349   = case unpkUnique uniq of
 350       (tag, u) -> finish_ppr tag u (iToBase62 u)
 351
 352 pprUnique10 uniq        -- in base-10, dudes
 353   = case unpkUnique uniq of
 354       (tag, u) -> finish_ppr tag u (int u)
 355
 356 finish_ppr 't' u pp_u | u < 26
 357   =     -- Special case to make v common tyvars, t1, t2, ...
 358         -- come out as a, b, ... (shorter, easier to read)
 359     char (chr (ord 'a' + u))
 360 finish_ppr tag u pp_u = char tag <> pp_u
 361
 362 showUnique :: Unique -> String
 363 showUnique uniq = show (pprUnique uniq)
 364
 365 instance Outputable Unique where
 366     ppr sty u = pprUnique u
 367
 368 instance Text Unique where
 369     showsPrec p uniq rest = showUnique uniq
 370 \end{code}
 371
 372 %************************************************************************
 373 %*                                                                      *
 374 \subsection[Utils-base62]{Base-62 numbers}
 375 %*                                                                      *
 376 %************************************************************************
 377
 378 A character-stingy way to read/write numbers (notably Uniques).
 379 The ``62-its'' are \tr{[0-9a-zA-Z]}.  We don't handle negative Ints.
 380 Code stolen from Lennart.
 381 \begin{code}
 382 #if __GLASGOW_HASKELL__ == 201
 383 # define BYTE_ARRAY GHCbase.ByteArray
 384 # define RUN_ST     GHCbase.runST
 385 # define AND_THEN   >>=
 386 # define AND_THEN_  >>
 387 # define RETURN     return
 388 #elif __GLASGOW_HASKELL__ >= 202
 389 # define BYTE_ARRAY GlaExts.ByteArray
 390 # define RUN_ST     ST.runST
 391 # define AND_THEN   >>=
 392 # define AND_THEN_  >>
 393 # define RETURN     return
 394 #else
 395 # define BYTE_ARRAY _ByteArray
 396 # define RUN_ST     _runST
 397 # define AND_THEN   `thenStrictlyST`
 398 # define AND_THEN_  `seqStrictlyST`
 399 # define RETURN     returnStrictlyST
 400 #endif
 401
 402 iToBase62 :: Int -> Doc
 403
 404 iToBase62 n@(I# n#)
 405   = ASSERT(n >= 0)
 406     let
 407         bytes = case chars62 of { BYTE_ARRAY bounds_who_needs_'em bytes -> bytes }
 408     in
 409     if n# <# 62# then
 410         case (indexCharArray# bytes n#) of { c ->
 411         char (C# c) }
 412     else
 413         case (quotRem n 62)             of { (q, I# r#) ->
 414         case (indexCharArray# bytes r#) of { c  ->
 415         (<>) (iToBase62 q) (char (C# c)) }}
 416
 417 -- keep this at top level! (bug on 94/10/24 WDP)
 418 chars62 :: BYTE_ARRAY Int
 419 chars62
 420   = RUN_ST (
 421         newCharArray (0, 61)    AND_THEN \ ch_array ->
 422         fill_in ch_array 0 62 "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
 423                                 AND_THEN_
 424         unsafeFreezeByteArray ch_array
 425     )
 426   where
 427     fill_in ch_array i lim str
 428       | i == lim
 429       = RETURN ()
 430       | otherwise
 431       = writeCharArray ch_array i (str !! i)    AND_THEN_
 432         fill_in ch_array (i+1) lim str
 433 \end{code}
 434
 435 %************************************************************************
 436 %*                                                                      *
 437 \subsection[Uniques-prelude]{@Uniques@ for wired-in Prelude things}
 438 %*                                                                      *
 439 %************************************************************************
 440
 441 Allocation of unique supply characters:
 442         v,t,u : for renumbering value-, type- and usage- vars.
 443         other a-z: lower case chars for unique supplies (see Main.lhs)
 444         B:   builtin
 445         C-E: pseudo uniques     (used in native-code generator)
 446         _:   unifiable tyvars   (above)
 447         1-8: prelude things below
 448
 449 \begin{code}
 450 mkAlphaTyVarUnique i            = mkUnique '1' i
 451
 452 mkPreludeClassUnique i          = mkUnique '2' i
 453 mkPreludeTyConUnique i          = mkUnique '3' i
 454 mkTupleTyConUnique a            = mkUnique '4' a
 455
 456 mkPreludeDataConUnique i        = mkUnique '5' i        -- must be alphabetic
 457 mkTupleDataConUnique a          = mkUnique '6' a        -- ditto (*may* be used in C labels)
 458
 459 mkPrimOpIdUnique op             = mkUnique '7' op
 460 mkPreludeMiscIdUnique i         = mkUnique '8' i
 461
 462 -- The "tyvar uniques" print specially nicely: a, b, c, etc.
 463 -- See pprUnique for details
 464
 465 initTyVarUnique :: Unique
 466 initTyVarUnique = mkUnique 't' 0
 467
 468 mkTyVarUnique :: Int -> Unique
 469 mkTyVarUnique n = mkUnique 't' n
 470
 471 initTidyUniques :: (Unique, Unique)     -- Global and local
 472 initTidyUniques = (mkUnique 'g' 0, mkUnique 'x' 0)
 473
 474 mkPseudoUnique1, mkPseudoUnique2, mkPseudoUnique3,
 475  mkBuiltinUnique :: Int -> Unique
 476
 477 mkBuiltinUnique i = mkUnique 'B' i
 478 mkPseudoUnique1 i = mkUnique 'C' i -- used for uniqueOf on Regs
 479 mkPseudoUnique2 i = mkUnique 'D' i -- ditto
 480 mkPseudoUnique3 i = mkUnique 'E' i -- ditto
 481
 482 getBuiltinUniques :: Int -> [Unique]
 483 getBuiltinUniques n = map (mkUnique 'B') [1 .. n]
 484 \end{code}
 485
 486 %************************************************************************
 487 %*                                                                      *
 488 \subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@}
 489 %*                                                                      *
 490 %************************************************************************
 491
 492 \begin{code}
 493 boundedClassKey         = mkPreludeClassUnique 1
 494 enumClassKey            = mkPreludeClassUnique 2
 495 eqClassKey              = mkPreludeClassUnique 3
 496 evalClassKey            = mkPreludeClassUnique 4
 497 floatingClassKey        = mkPreludeClassUnique 5
 498 fractionalClassKey      = mkPreludeClassUnique 6
 499 integralClassKey        = mkPreludeClassUnique 7
 500 monadClassKey           = mkPreludeClassUnique 8
 501 monadZeroClassKey       = mkPreludeClassUnique 9
 502 monadPlusClassKey       = mkPreludeClassUnique 10
 503 functorClassKey         = mkPreludeClassUnique 11
 504 numClassKey             = mkPreludeClassUnique 12
 505 ordClassKey             = mkPreludeClassUnique 13
 506 readClassKey            = mkPreludeClassUnique 14
 507 realClassKey            = mkPreludeClassUnique 15
 508 realFloatClassKey       = mkPreludeClassUnique 16
 509 realFracClassKey        = mkPreludeClassUnique 17
 510 showClassKey            = mkPreludeClassUnique 18
 511
 512 cCallableClassKey       = mkPreludeClassUnique 19
 513 cReturnableClassKey     = mkPreludeClassUnique 20
 514
 515 ixClassKey              = mkPreludeClassUnique 21
 516 allClassKey             = mkPreludeClassUnique 22       -- Pseudo class used for universal quantification
 517 \end{code}
 518
 519 %************************************************************************
 520 %*                                                                      *
 521 \subsubsection[Uniques-prelude-TyCons]{@Uniques@ for wired-in @TyCons@}
 522 %*                                                                      *
 523 %************************************************************************
 524
 525 \begin{code}
 526 addrPrimTyConKey                        = mkPreludeTyConUnique  1
 527 addrTyConKey                            = mkPreludeTyConUnique  2
 528 arrayPrimTyConKey                       = mkPreludeTyConUnique  3
 529 boolTyConKey                            = mkPreludeTyConUnique  4
 530 byteArrayPrimTyConKey                   = mkPreludeTyConUnique  5
 531 charPrimTyConKey                        = mkPreludeTyConUnique  7
 532 charTyConKey                            = mkPreludeTyConUnique  8
 533 doublePrimTyConKey                      = mkPreludeTyConUnique  9
 534 doubleTyConKey                          = mkPreludeTyConUnique 10
 535 floatPrimTyConKey                       = mkPreludeTyConUnique 11
 536 floatTyConKey                           = mkPreludeTyConUnique 12
 537 funTyConKey                             = mkPreludeTyConUnique 13
 538 intPrimTyConKey                         = mkPreludeTyConUnique 14
 539 intTyConKey                             = mkPreludeTyConUnique 15
 540 integerTyConKey                         = mkPreludeTyConUnique 16
 541 liftTyConKey                            = mkPreludeTyConUnique 17
 542 listTyConKey                            = mkPreludeTyConUnique 18
 543 foreignObjPrimTyConKey                  = mkPreludeTyConUnique 19
 544 foreignObjTyConKey                      = mkPreludeTyConUnique 20
 545 mutableArrayPrimTyConKey                = mkPreludeTyConUnique 21
 546 mutableByteArrayPrimTyConKey            = mkPreludeTyConUnique 22
 547 orderingTyConKey                        = mkPreludeTyConUnique 23
 548 synchVarPrimTyConKey                    = mkPreludeTyConUnique 24
 549 ratioTyConKey                           = mkPreludeTyConUnique 25
 550 rationalTyConKey                        = mkPreludeTyConUnique 26
 551 realWorldTyConKey                       = mkPreludeTyConUnique 27
 552 return2GMPsTyConKey                     = mkPreludeTyConUnique 28
 553 returnIntAndGMPTyConKey                 = mkPreludeTyConUnique 29
 554 stablePtrPrimTyConKey                   = mkPreludeTyConUnique 30
 555 stablePtrTyConKey                       = mkPreludeTyConUnique 31
 556 stateAndAddrPrimTyConKey                = mkPreludeTyConUnique 32
 557 stateAndArrayPrimTyConKey               = mkPreludeTyConUnique 33
 558 stateAndByteArrayPrimTyConKey           = mkPreludeTyConUnique 34
 559 stateAndCharPrimTyConKey                = mkPreludeTyConUnique 35
 560 stateAndDoublePrimTyConKey              = mkPreludeTyConUnique 36
 561 stateAndFloatPrimTyConKey               = mkPreludeTyConUnique 37
 562 stateAndIntPrimTyConKey                 = mkPreludeTyConUnique 38
 563 stateAndForeignObjPrimTyConKey          = mkPreludeTyConUnique 39
 564 stateAndMutableArrayPrimTyConKey        = mkPreludeTyConUnique 40
 565 stateAndMutableByteArrayPrimTyConKey    = mkPreludeTyConUnique 41
 566 stateAndSynchVarPrimTyConKey            = mkPreludeTyConUnique 42
 567 stateAndPtrPrimTyConKey                 = mkPreludeTyConUnique 43
 568 stateAndStablePtrPrimTyConKey           = mkPreludeTyConUnique 44
 569 stateAndWordPrimTyConKey                = mkPreludeTyConUnique 45
 570 statePrimTyConKey                       = mkPreludeTyConUnique 46
 571 stateTyConKey                           = mkPreludeTyConUnique 47
 572 mutableByteArrayTyConKey                = mkPreludeTyConUnique 48
 573 stTyConKey                              = mkPreludeTyConUnique 49
 574 stRetTyConKey                           = mkPreludeTyConUnique 50
 575 ioTyConKey                              = mkPreludeTyConUnique 51
 576 ioResultTyConKey                        = mkPreludeTyConUnique 52
 577 byteArrayTyConKey                       = mkPreludeTyConUnique 53
 578 wordPrimTyConKey                        = mkPreludeTyConUnique 54
 579 wordTyConKey                            = mkPreludeTyConUnique 55
 580 voidTyConKey                            = mkPreludeTyConUnique 56
 581 \end{code}
 582
 583 %************************************************************************
 584 %*                                                                      *
 585 \subsubsection[Uniques-prelude-DataCons]{@Uniques@ for wired-in @DataCons@}
 586 %*                                                                      *
 587 %************************************************************************
 588
 589 \begin{code}
 590 addrDataConKey                          = mkPreludeDataConUnique  1
 591 buildDataConKey                         = mkPreludeDataConUnique  2
 592 charDataConKey                          = mkPreludeDataConUnique  4
 593 consDataConKey                          = mkPreludeDataConUnique  5
 594 doubleDataConKey                        = mkPreludeDataConUnique  6
 595 eqDataConKey                            = mkPreludeDataConUnique  7
 596 falseDataConKey                         = mkPreludeDataConUnique  8
 597 floatDataConKey                         = mkPreludeDataConUnique  9
 598 gtDataConKey                            = mkPreludeDataConUnique 10
 599 intDataConKey                           = mkPreludeDataConUnique 11
 600 integerDataConKey                       = mkPreludeDataConUnique 12
 601 liftDataConKey                          = mkPreludeDataConUnique 13
 602 ltDataConKey                            = mkPreludeDataConUnique 14
 603 foreignObjDataConKey                    = mkPreludeDataConUnique 15
 604 nilDataConKey                           = mkPreludeDataConUnique 18
 605 ratioDataConKey                         = mkPreludeDataConUnique 21
 606 return2GMPsDataConKey                   = mkPreludeDataConUnique 22
 607 returnIntAndGMPDataConKey               = mkPreludeDataConUnique 23
 608 stablePtrDataConKey                     = mkPreludeDataConUnique 24
 609 stateAndAddrPrimDataConKey              = mkPreludeDataConUnique 25
 610 stateAndArrayPrimDataConKey             = mkPreludeDataConUnique 26
 611 stateAndByteArrayPrimDataConKey         = mkPreludeDataConUnique 27
 612 stateAndCharPrimDataConKey              = mkPreludeDataConUnique 28
 613 stateAndDoublePrimDataConKey            = mkPreludeDataConUnique 29
 614 stateAndFloatPrimDataConKey             = mkPreludeDataConUnique 30
 615 stateAndIntPrimDataConKey               = mkPreludeDataConUnique 31
 616 stateAndForeignObjPrimDataConKey        = mkPreludeDataConUnique 32
 617 stateAndMutableArrayPrimDataConKey      = mkPreludeDataConUnique 33
 618 stateAndMutableByteArrayPrimDataConKey  = mkPreludeDataConUnique 34
 619 stateAndSynchVarPrimDataConKey          = mkPreludeDataConUnique 35
 620 stateAndPtrPrimDataConKey               = mkPreludeDataConUnique 36
 621 stateAndStablePtrPrimDataConKey         = mkPreludeDataConUnique 37
 622 stateAndWordPrimDataConKey              = mkPreludeDataConUnique 38
 623 stateDataConKey                         = mkPreludeDataConUnique 39
 624 trueDataConKey                          = mkPreludeDataConUnique 40
 625 wordDataConKey                          = mkPreludeDataConUnique 41
 626 stDataConKey                            = mkPreludeDataConUnique 42
 627 stRetDataConKey                         = mkPreludeDataConUnique 43
 628 ioDataConKey                            = mkPreludeDataConUnique 44
 629 ioOkDataConKey                          = mkPreludeDataConUnique 45
 630 ioFailDataConKey                        = mkPreludeDataConUnique 46
 631 \end{code}
 632
 633 %************************************************************************
 634 %*                                                                      *
 635 \subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}
 636 %*                                                                      *
 637 %************************************************************************
 638
 639 \begin{code}
 640 absentErrorIdKey              = mkPreludeMiscIdUnique  1
 641 andandIdKey                   = mkPreludeMiscIdUnique  2
 642 appendIdKey                   = mkPreludeMiscIdUnique  3
 643 augmentIdKey                  = mkPreludeMiscIdUnique  4
 644 buildIdKey                    = mkPreludeMiscIdUnique  5
 645 composeIdKey                  = mkPreludeMiscIdUnique  6
 646 errorIdKey                    = mkPreludeMiscIdUnique  7
 647 foldlIdKey                    = mkPreludeMiscIdUnique  8
 648 foldrIdKey                    = mkPreludeMiscIdUnique  9
 649 forkIdKey                     = mkPreludeMiscIdUnique 10
 650 int2IntegerIdKey              = mkPreludeMiscIdUnique 11
 651 integerMinusOneIdKey          = mkPreludeMiscIdUnique 12
 652 integerPlusOneIdKey           = mkPreludeMiscIdUnique 13
 653 integerPlusTwoIdKey           = mkPreludeMiscIdUnique 14
 654 integerZeroIdKey              = mkPreludeMiscIdUnique 15
 655 irrefutPatErrorIdKey          = mkPreludeMiscIdUnique 16
 656 lexIdKey                      = mkPreludeMiscIdUnique 17
 657 noDefaultMethodErrorIdKey     = mkPreludeMiscIdUnique 20
 658 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 21
 659 nonExplicitMethodErrorIdKey   = mkPreludeMiscIdUnique 22
 660 notIdKey                      = mkPreludeMiscIdUnique 23
 661 packCStringIdKey              = mkPreludeMiscIdUnique 24
 662 parErrorIdKey                 = mkPreludeMiscIdUnique 25
 663 parIdKey                      = mkPreludeMiscIdUnique 26
 664 patErrorIdKey                 = mkPreludeMiscIdUnique 27
 665 readParenIdKey                = mkPreludeMiscIdUnique 28
 666 realWorldPrimIdKey            = mkPreludeMiscIdUnique 29
 667 recConErrorIdKey              = mkPreludeMiscIdUnique 30
 668 recUpdErrorIdKey              = mkPreludeMiscIdUnique 31
 669 seqIdKey                      = mkPreludeMiscIdUnique 33
 670 showParenIdKey                = mkPreludeMiscIdUnique 34
 671 showSpaceIdKey                = mkPreludeMiscIdUnique 35
 672 showStringIdKey               = mkPreludeMiscIdUnique 36
 673 traceIdKey                    = mkPreludeMiscIdUnique 37
 674 unpackCString2IdKey           = mkPreludeMiscIdUnique 38
 675 unpackCStringAppendIdKey      = mkPreludeMiscIdUnique 39
 676 unpackCStringFoldrIdKey       = mkPreludeMiscIdUnique 40
 677 unpackCStringIdKey            = mkPreludeMiscIdUnique 41
 678 voidIdKey                     = mkPreludeMiscIdUnique 42
 679 ushowListIdKey                = mkPreludeMiscIdUnique 43
 680 ureadListIdKey                = mkPreludeMiscIdUnique 44
 681
 682 copyableIdKey           = mkPreludeMiscIdUnique 45
 683 noFollowIdKey           = mkPreludeMiscIdUnique 46
 684 parAtAbsIdKey           = mkPreludeMiscIdUnique 47
 685 parAtForNowIdKey        = mkPreludeMiscIdUnique 48
 686 parAtIdKey              = mkPreludeMiscIdUnique 49
 687 parAtRelIdKey           = mkPreludeMiscIdUnique 50
 688 parGlobalIdKey          = mkPreludeMiscIdUnique 51
 689 parLocalIdKey           = mkPreludeMiscIdUnique 52
 690 \end{code}
 691
 692 Certain class operations from Prelude classes.  They get
 693 their own uniques so we can look them up easily when we want
 694 to conjure them up during type checking.
 695 \begin{code}
 696 fromIntClassOpKey       = mkPreludeMiscIdUnique 53
 697 fromIntegerClassOpKey   = mkPreludeMiscIdUnique 54
 698 minusClassOpKey         = mkPreludeMiscIdUnique 55
 699 fromRationalClassOpKey  = mkPreludeMiscIdUnique 56
 700 enumFromClassOpKey      = mkPreludeMiscIdUnique 57
 701 enumFromThenClassOpKey  = mkPreludeMiscIdUnique 58
 702 enumFromToClassOpKey    = mkPreludeMiscIdUnique 59
 703 enumFromThenToClassOpKey= mkPreludeMiscIdUnique 60
 704 eqClassOpKey            = mkPreludeMiscIdUnique 61
 705 geClassOpKey            = mkPreludeMiscIdUnique 62
 706 zeroClassOpKey          = mkPreludeMiscIdUnique 63
 707 thenMClassOpKey         = mkPreludeMiscIdUnique 64 -- (>>=)
 708 unboundKey              = mkPreludeMiscIdUnique 65      -- Just a place holder for unbound
 709                                                         -- variables produced by the renamer
 710 fromEnumClassOpKey      = mkPreludeMiscIdUnique 66
 711
 712 mainKey                 = mkPreludeMiscIdUnique 67
 713 returnMClassOpKey       = mkPreludeMiscIdUnique 68
 714 otherwiseIdKey          = mkPreludeMiscIdUnique 69
 715 toEnumClassOpKey        = mkPreludeMiscIdUnique 70
 716 \end{code}