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