ghc/compiler/basicTypes/Unique.lhs

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