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         -- now all the built-in Uniques (and functions to make them)
  33         -- [the Oh-So-Wonderful Haskell module system wins again...]
  34         mkAlphaTyVarUnique,
  35         mkPrimOpIdUnique,
  36         mkTupleDataConUnique,
  37         mkTupleTyConUnique,
  38
  39         absentErrorIdKey,       -- alphabetical...
  40         addrDataConKey,
  41         addrPrimTyConKey,
  42         addrTyConKey,
  43         appendIdKey,
  44         arrayPrimTyConKey,
  45         augmentIdKey,
  46         binaryClassKey,
  47         boolTyConKey,
  48         boundedClassKey,
  49         buildDataConKey,
  50         buildIdKey,
  51         byteArrayPrimTyConKey,
  52         cCallableClassKey,
  53         cReturnableClassKey,
  54         charDataConKey,
  55         charPrimTyConKey,
  56         charTyConKey,
  57         consDataConKey,
  58         evalClassKey,
  59         doubleDataConKey,
  60         doublePrimTyConKey,
  61         doubleTyConKey,
  62         enumClassKey,
  63         enumFromClassOpKey,
  64         enumFromThenClassOpKey,
  65         enumFromThenToClassOpKey,
  66         enumFromToClassOpKey,
  67         eqClassKey,
  68         eqClassOpKey,
  69         eqDataConKey,
  70         errorIdKey,
  71         falseDataConKey,
  72         floatDataConKey,
  73         floatPrimTyConKey,
  74         floatTyConKey,
  75         floatingClassKey,
  76         foldlIdKey,
  77         foldrIdKey,
  78         forkIdKey,
  79         fractionalClassKey,
  80         fromIntClassOpKey,
  81         fromIntegerClassOpKey,
  82         fromRationalClassOpKey,
  83         funTyConKey,
  84         geClassOpKey,
  85         gtDataConKey,
  86         iOTyConKey,
  87         intDataConKey,
  88         intPrimTyConKey,
  89         intTyConKey,
  90         integerDataConKey,
  91         integerMinusOneIdKey,
  92         integerPlusOneIdKey,
  93         integerPlusTwoIdKey,
  94         integerTyConKey,
  95         integerZeroIdKey,
  96         integralClassKey,
  97         ixClassKey,
  98         liftDataConKey,
  99         liftTyConKey,
 100         listTyConKey,
 101         ltDataConKey,
 102         mainIdKey,
 103         mainPrimIOIdKey,
 104         mallocPtrDataConKey,
 105         mallocPtrPrimTyConKey,
 106         mallocPtrTyConKey,
 107         monadClassKey,
 108         monadZeroClassKey,
 109         mutableArrayPrimTyConKey,
 110         mutableByteArrayPrimTyConKey,
 111         nilDataConKey,
 112         numClassKey,
 113         ordClassKey,
 114         orderingTyConKey,
 115         packCStringIdKey,
 116         parErrorIdKey,
 117         parIdKey,
 118         patErrorIdKey,
 119         recConErrorIdKey,
 120         recUpdErrorIdKey,
 121         irrefutPatErrorIdKey,
 122         nonExhaustiveGuardsErrorIdKey,
 123         noDefaultMethodErrorIdKey,
 124         nonExplicitMethodErrorIdKey,
 125         primIoTyConKey,
 126         ratioDataConKey,
 127         ratioTyConKey,
 128         rationalTyConKey,
 129         readClassKey,
 130         realClassKey,
 131         realFloatClassKey,
 132         realFracClassKey,
 133         realWorldPrimIdKey,
 134         realWorldTyConKey,
 135         return2GMPsDataConKey,
 136         return2GMPsTyConKey,
 137         returnIntAndGMPDataConKey,
 138         returnIntAndGMPTyConKey,
 139         runSTIdKey,
 140         seqIdKey,
 141         showClassKey,
 142         stTyConKey,
 143         stablePtrDataConKey,
 144         stablePtrPrimTyConKey,
 145         stablePtrTyConKey,
 146         stateAndAddrPrimDataConKey,
 147         stateAndAddrPrimTyConKey,
 148         stateAndArrayPrimDataConKey,
 149         stateAndArrayPrimTyConKey,
 150         stateAndByteArrayPrimDataConKey,
 151         stateAndByteArrayPrimTyConKey,
 152         stateAndCharPrimDataConKey,
 153         stateAndCharPrimTyConKey,
 154         stateAndDoublePrimDataConKey,
 155         stateAndDoublePrimTyConKey,
 156         stateAndFloatPrimDataConKey,
 157         stateAndFloatPrimTyConKey,
 158         stateAndIntPrimDataConKey,
 159         stateAndIntPrimTyConKey,
 160         stateAndMallocPtrPrimDataConKey,
 161         stateAndMallocPtrPrimTyConKey,
 162         stateAndMutableArrayPrimDataConKey,
 163         stateAndMutableArrayPrimTyConKey,
 164         stateAndMutableByteArrayPrimDataConKey,
 165         stateAndMutableByteArrayPrimTyConKey,
 166         stateAndPtrPrimDataConKey,
 167         stateAndPtrPrimTyConKey,
 168         stateAndStablePtrPrimDataConKey,
 169         stateAndStablePtrPrimTyConKey,
 170         stateAndSynchVarPrimDataConKey,
 171         stateAndSynchVarPrimTyConKey,
 172         stateAndWordPrimDataConKey,
 173         stateAndWordPrimTyConKey,
 174         stateDataConKey,
 175         statePrimTyConKey,
 176         stateTyConKey,
 177         stringTyConKey,
 178         synchVarPrimTyConKey,
 179         traceIdKey,
 180         trueDataConKey,
 181         unpackCString2IdKey,
 182         unpackCStringAppendIdKey,
 183         unpackCStringFoldrIdKey,
 184         unpackCStringIdKey,
 185         voidPrimIdKey,
 186         voidPrimTyConKey,
 187         wordDataConKey,
 188         wordPrimTyConKey,
 189         wordTyConKey
 190 #ifdef GRAN
 191         , copyableIdKey
 192         , noFollowIdKey
 193         , parGlobalIdKey
 194         , parLocalIdKey
 195 #endif
 196         -- to make interface self-sufficient
 197     ) where
 198
 199 import PreludeGlaST
 200
 201 import Ubiq{-uitous-}
 202
 203 import Pretty
 204 import Util
 205 \end{code}
 206
 207 %************************************************************************
 208 %*                                                                      *
 209 \subsection[Unique-type]{@Unique@ type and operations}
 210 %*                                                                      *
 211 %************************************************************************
 212
 213 The @Chars@ are ``tag letters'' that identify the @UniqueSupply@.
 214 Fast comparison is everything on @Uniques@:
 215
 216 \begin{code}
 217 u2i :: Unique -> FAST_INT
 218
 219 data Unique = MkUnique Int#
 220 u2i (MkUnique i) = i
 221 \end{code}
 222
 223 Now come the functions which construct uniques from their pieces, and vice versa.
 224 The stuff about unique *supplies* is handled further down this module.
 225
 226 \begin{code}
 227 mkUnique                 :: Char -> Int -> Unique       -- Builds a unique from pieces
 228 unpkUnique               :: Unique -> (Char, Int)       -- The reverse
 229
 230 mkUnifiableTyVarUnique   :: Int -> Unique       -- Injects a subst-array index into the Unique type
 231 unpkUnifiableTyVarUnique :: Unique -> Int       -- The reverse process
 232
 233 mkUniqueGrimily :: Int# -> Unique               -- A trap-door for UniqSupply
 234 \end{code}
 235
 236
 237 \begin{code}
 238 mkUniqueGrimily x = MkUnique x
 239
 240 mkUnifiableTyVarUnique i = mkUnique '_'{-MAGIC CHAR-} i
 241
 242 unpkUnifiableTyVarUnique uniq
 243   = case (unpkUnique uniq) of { (tag, i) ->
 244     ASSERT(tag == '_'{-MAGIC CHAR-})
 245     i }
 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         a-z: lower case chars for unique supplies (see Main.lhs)
 379         B:   builtin            (see UniqSupply.lhs)
 380         C-E: pseudo uniques     (see UniqSupply.lhs)
 381         _:   unifiable tyvars   (above)
 382         1-8: prelude things below
 383
 384 \begin{code}
 385 mkAlphaTyVarUnique i            = mkUnique '1' i
 386
 387 mkPreludeClassUnique i          = mkUnique '2' i
 388 mkPreludeTyConUnique i          = mkUnique '3' i
 389 mkTupleTyConUnique a            = mkUnique '4' a
 390
 391 mkPreludeDataConUnique i        = mkUnique '5' i        -- must be alphabetic
 392 mkTupleDataConUnique a          = mkUnique '6' a        -- ditto (*may* be used in C labels)
 393
 394 mkPrimOpIdUnique op             = mkUnique '7' op
 395 mkPreludeMiscIdUnique i         = mkUnique '8' i
 396 \end{code}
 397
 398 %************************************************************************
 399 %*                                                                      *
 400 \subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@}
 401 %*                                                                      *
 402 %************************************************************************
 403
 404 \begin{code}
 405 eqClassKey              = mkPreludeClassUnique 1
 406 ordClassKey             = mkPreludeClassUnique 2
 407 numClassKey             = mkPreludeClassUnique 3
 408 integralClassKey        = mkPreludeClassUnique 4
 409 fractionalClassKey      = mkPreludeClassUnique 5
 410 floatingClassKey        = mkPreludeClassUnique 6
 411 realClassKey            = mkPreludeClassUnique 7
 412 realFracClassKey        = mkPreludeClassUnique 8
 413 realFloatClassKey       = mkPreludeClassUnique 9
 414 ixClassKey              = mkPreludeClassUnique 10
 415 enumClassKey            = mkPreludeClassUnique 11
 416 showClassKey            = mkPreludeClassUnique 12
 417 readClassKey            = mkPreludeClassUnique 13
 418 monadClassKey           = mkPreludeClassUnique 14
 419 monadZeroClassKey       = mkPreludeClassUnique 15
 420 binaryClassKey          = mkPreludeClassUnique 16
 421 cCallableClassKey       = mkPreludeClassUnique 17
 422 cReturnableClassKey     = mkPreludeClassUnique 18
 423 evalClassKey            = mkPreludeClassUnique 19
 424 boundedClassKey         = mkPreludeClassUnique 20
 425 \end{code}
 426
 427 %************************************************************************
 428 %*                                                                      *
 429 \subsubsection[Uniques-prelude-TyCons]{@Uniques@ for wired-in @TyCons@}
 430 %*                                                                      *
 431 %************************************************************************
 432
 433 \begin{code}
 434 addrPrimTyConKey                        = mkPreludeTyConUnique  1
 435 addrTyConKey                            = mkPreludeTyConUnique  2
 436 arrayPrimTyConKey                       = mkPreludeTyConUnique  3
 437 boolTyConKey                            = mkPreludeTyConUnique  4
 438 byteArrayPrimTyConKey                   = mkPreludeTyConUnique  5
 439 charPrimTyConKey                        = mkPreludeTyConUnique  7
 440 charTyConKey                            = mkPreludeTyConUnique  8
 441 doublePrimTyConKey                      = mkPreludeTyConUnique  9
 442 doubleTyConKey                          = mkPreludeTyConUnique 10
 443 floatPrimTyConKey                       = mkPreludeTyConUnique 11
 444 floatTyConKey                           = mkPreludeTyConUnique 12
 445 funTyConKey                             = mkPreludeTyConUnique 13
 446 iOTyConKey                              = mkPreludeTyConUnique 14
 447 intPrimTyConKey                         = mkPreludeTyConUnique 15
 448 intTyConKey                             = mkPreludeTyConUnique 16
 449 integerTyConKey                         = mkPreludeTyConUnique 17
 450 liftTyConKey                            = mkPreludeTyConUnique 18
 451 listTyConKey                            = mkPreludeTyConUnique 19
 452 mallocPtrPrimTyConKey                   = mkPreludeTyConUnique 20
 453 mallocPtrTyConKey                       = mkPreludeTyConUnique 21
 454 mutableArrayPrimTyConKey                = mkPreludeTyConUnique 22
 455 mutableByteArrayPrimTyConKey            = mkPreludeTyConUnique 23
 456 orderingTyConKey                        = mkPreludeTyConUnique 24
 457 synchVarPrimTyConKey                    = mkPreludeTyConUnique 25
 458 ratioTyConKey                           = mkPreludeTyConUnique 26
 459 rationalTyConKey                        = mkPreludeTyConUnique 27
 460 realWorldTyConKey                       = mkPreludeTyConUnique 28
 461 return2GMPsTyConKey                     = mkPreludeTyConUnique 29
 462 returnIntAndGMPTyConKey                 = mkPreludeTyConUnique 30
 463 stablePtrPrimTyConKey                   = mkPreludeTyConUnique 31
 464 stablePtrTyConKey                       = mkPreludeTyConUnique 32
 465 stateAndAddrPrimTyConKey                = mkPreludeTyConUnique 33
 466 stateAndArrayPrimTyConKey               = mkPreludeTyConUnique 34
 467 stateAndByteArrayPrimTyConKey           = mkPreludeTyConUnique 35
 468 stateAndCharPrimTyConKey                = mkPreludeTyConUnique 36
 469 stateAndDoublePrimTyConKey              = mkPreludeTyConUnique 37
 470 stateAndFloatPrimTyConKey               = mkPreludeTyConUnique 38
 471 stateAndIntPrimTyConKey                 = mkPreludeTyConUnique 39
 472 stateAndMallocPtrPrimTyConKey           = mkPreludeTyConUnique 40
 473 stateAndMutableArrayPrimTyConKey        = mkPreludeTyConUnique 41
 474 stateAndMutableByteArrayPrimTyConKey    = mkPreludeTyConUnique 42
 475 stateAndSynchVarPrimTyConKey            = mkPreludeTyConUnique 43
 476 stateAndPtrPrimTyConKey                 = mkPreludeTyConUnique 44
 477 stateAndStablePtrPrimTyConKey           = mkPreludeTyConUnique 45
 478 stateAndWordPrimTyConKey                = mkPreludeTyConUnique 46
 479 statePrimTyConKey                       = mkPreludeTyConUnique 47
 480 stateTyConKey                           = mkPreludeTyConUnique 48
 481 stringTyConKey                          = mkPreludeTyConUnique 49
 482 stTyConKey                              = mkPreludeTyConUnique 50
 483 primIoTyConKey                          = mkPreludeTyConUnique 51
 484 voidPrimTyConKey                        = mkPreludeTyConUnique 52
 485 wordPrimTyConKey                        = mkPreludeTyConUnique 53
 486 wordTyConKey                            = mkPreludeTyConUnique 54
 487 \end{code}
 488
 489 %************************************************************************
 490 %*                                                                      *
 491 \subsubsection[Uniques-prelude-DataCons]{@Uniques@ for wired-in @DataCons@}
 492 %*                                                                      *
 493 %************************************************************************
 494
 495 \begin{code}
 496 addrDataConKey                          = mkPreludeDataConUnique  1
 497 buildDataConKey                         = mkPreludeDataConUnique  2
 498 charDataConKey                          = mkPreludeDataConUnique  4
 499 consDataConKey                          = mkPreludeDataConUnique  5
 500 doubleDataConKey                        = mkPreludeDataConUnique  6
 501 eqDataConKey                            = mkPreludeDataConUnique  7
 502 falseDataConKey                         = mkPreludeDataConUnique  8
 503 floatDataConKey                         = mkPreludeDataConUnique  9
 504 gtDataConKey                            = mkPreludeDataConUnique 10
 505 intDataConKey                           = mkPreludeDataConUnique 11
 506 integerDataConKey                       = mkPreludeDataConUnique 12
 507 liftDataConKey                          = mkPreludeDataConUnique 13
 508 ltDataConKey                            = mkPreludeDataConUnique 14
 509 mallocPtrDataConKey                     = mkPreludeDataConUnique 15
 510 nilDataConKey                           = mkPreludeDataConUnique 18
 511 ratioDataConKey                         = mkPreludeDataConUnique 21
 512 return2GMPsDataConKey                   = mkPreludeDataConUnique 22
 513 returnIntAndGMPDataConKey               = mkPreludeDataConUnique 23
 514 stablePtrDataConKey                     = mkPreludeDataConUnique 24
 515 stateAndAddrPrimDataConKey              = mkPreludeDataConUnique 25
 516 stateAndArrayPrimDataConKey             = mkPreludeDataConUnique 26
 517 stateAndByteArrayPrimDataConKey         = mkPreludeDataConUnique 27
 518 stateAndCharPrimDataConKey              = mkPreludeDataConUnique 28
 519 stateAndDoublePrimDataConKey            = mkPreludeDataConUnique 29
 520 stateAndFloatPrimDataConKey             = mkPreludeDataConUnique 30
 521 stateAndIntPrimDataConKey               = mkPreludeDataConUnique 31
 522 stateAndMallocPtrPrimDataConKey         = mkPreludeDataConUnique 32
 523 stateAndMutableArrayPrimDataConKey      = mkPreludeDataConUnique 33
 524 stateAndMutableByteArrayPrimDataConKey  = mkPreludeDataConUnique 34
 525 stateAndSynchVarPrimDataConKey          = mkPreludeDataConUnique 35
 526 stateAndPtrPrimDataConKey               = mkPreludeDataConUnique 36
 527 stateAndStablePtrPrimDataConKey         = mkPreludeDataConUnique 37
 528 stateAndWordPrimDataConKey              = mkPreludeDataConUnique 38
 529 stateDataConKey                         = mkPreludeDataConUnique 39
 530 trueDataConKey                          = mkPreludeDataConUnique 40
 531 wordDataConKey                          = mkPreludeDataConUnique 41
 532 \end{code}
 533
 534 %************************************************************************
 535 %*                                                                      *
 536 \subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}
 537 %*                                                                      *
 538 %************************************************************************
 539
 540 \begin{code}
 541 absentErrorIdKey              = mkPreludeMiscIdUnique  1
 542 appendIdKey                   = mkPreludeMiscIdUnique  2
 543 augmentIdKey                  = mkPreludeMiscIdUnique  3
 544 buildIdKey                    = mkPreludeMiscIdUnique  4
 545 errorIdKey                    = mkPreludeMiscIdUnique  5
 546 foldlIdKey                    = mkPreludeMiscIdUnique  6
 547 foldrIdKey                    = mkPreludeMiscIdUnique  7
 548 forkIdKey                     = mkPreludeMiscIdUnique  8
 549 int2IntegerIdKey              = mkPreludeMiscIdUnique  9
 550 integerMinusOneIdKey          = mkPreludeMiscIdUnique 10
 551 integerPlusOneIdKey           = mkPreludeMiscIdUnique 11
 552 integerPlusTwoIdKey           = mkPreludeMiscIdUnique 12
 553 integerZeroIdKey              = mkPreludeMiscIdUnique 13
 554 packCStringIdKey              = mkPreludeMiscIdUnique 14
 555 parErrorIdKey                 = mkPreludeMiscIdUnique 15
 556 parIdKey                      = mkPreludeMiscIdUnique 16
 557 patErrorIdKey                 = mkPreludeMiscIdUnique 17
 558 realWorldPrimIdKey            = mkPreludeMiscIdUnique 18
 559 runSTIdKey                    = mkPreludeMiscIdUnique 19
 560 seqIdKey                      = mkPreludeMiscIdUnique 20
 561 traceIdKey                    = mkPreludeMiscIdUnique 21
 562 unpackCString2IdKey           = mkPreludeMiscIdUnique 22
 563 unpackCStringAppendIdKey      = mkPreludeMiscIdUnique 23
 564 unpackCStringFoldrIdKey       = mkPreludeMiscIdUnique 24
 565 unpackCStringIdKey            = mkPreludeMiscIdUnique 25
 566 voidPrimIdKey                 = mkPreludeMiscIdUnique 26
 567 mainIdKey                     = mkPreludeMiscIdUnique 27
 568 mainPrimIOIdKey               = mkPreludeMiscIdUnique 28
 569 recConErrorIdKey              = mkPreludeMiscIdUnique 29
 570 recUpdErrorIdKey              = mkPreludeMiscIdUnique 30
 571 irrefutPatErrorIdKey          = mkPreludeMiscIdUnique 31
 572 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 32
 573 noDefaultMethodErrorIdKey     = mkPreludeMiscIdUnique 33
 574 nonExplicitMethodErrorIdKey   = mkPreludeMiscIdUnique 34
 575
 576 #ifdef GRAN
 577 parLocalIdKey           = mkPreludeMiscIdUnique 35
 578 parGlobalIdKey          = mkPreludeMiscIdUnique 36
 579 noFollowIdKey           = mkPreludeMiscIdUnique 37
 580 copyableIdKey           = mkPreludeMiscIdUnique 38
 581 #endif
 582 \end{code}
 583
 584 Certain class operations from Prelude classes.  They get
 585 their own uniques so we can look them up easily when we want
 586 to conjure them up during type checking.
 587 \begin{code}
 588 fromIntClassOpKey       = mkPreludeMiscIdUnique 37
 589 fromIntegerClassOpKey   = mkPreludeMiscIdUnique 38
 590 fromRationalClassOpKey  = mkPreludeMiscIdUnique 39
 591 enumFromClassOpKey      = mkPreludeMiscIdUnique 40
 592 enumFromThenClassOpKey  = mkPreludeMiscIdUnique 41
 593 enumFromToClassOpKey    = mkPreludeMiscIdUnique 42
 594 enumFromThenToClassOpKey= mkPreludeMiscIdUnique 43
 595 eqClassOpKey            = mkPreludeMiscIdUnique 44
 596 geClassOpKey            = mkPreludeMiscIdUnique 45
 597 \end{code}