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