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