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         bindIOIdKey,
  53         boolTyConKey,
  54         boundedClassKey,
  55         boxedConKey,
  56         buildIdKey,
  57         byteArrayPrimTyConKey,
  58         byteArrayTyConKey,
  59         cCallableClassKey,
  60         cReturnableClassKey,
  61         charDataConKey,
  62         charPrimTyConKey,
  63         charTyConKey,
  64         concatIdKey,
  65         consDataConKey,
  66         deRefStablePtrIdKey,
  67         doubleDataConKey,
  68         doublePrimTyConKey,
  69         doubleTyConKey,
  70         enumClassKey,
  71         enumFromClassOpKey,
  72         enumFromThenClassOpKey,
  73         enumFromThenToClassOpKey,
  74         enumFromToClassOpKey,
  75         eqClassKey,
  76         eqClassOpKey,
  77         errorIdKey,
  78         falseDataConKey,
  79         failMClassOpKey,
  80         filterIdKey,
  81         floatDataConKey,
  82         floatPrimTyConKey,
  83         floatTyConKey,
  84         floatingClassKey,
  85         foldlIdKey,
  86         foldrIdKey,
  87         foreignObjDataConKey,
  88         foreignObjPrimTyConKey,
  89         foreignObjTyConKey,
  90         fractionalClassKey,
  91         fromEnumClassOpKey,
  92         fromIntClassOpKey,
  93         fromIntegerClassOpKey,
  94         fromRationalClassOpKey,
  95         funTyConKey,
  96         functorClassKey,
  97         geClassOpKey,
  98         intDataConKey,
  99         intPrimTyConKey,
 100         intTyConKey,
 101         int8TyConKey,
 102         int8DataConKey,
 103         int16TyConKey,
 104         int16DataConKey,
 105         int32TyConKey,
 106         int32DataConKey,
 107         int64DataConKey,
 108         int64PrimTyConKey,
 109         int64TyConKey,
 110         smallIntegerDataConKey,
 111         largeIntegerDataConKey,
 112         integerMinusOneIdKey,
 113         integerPlusOneIdKey,
 114         integerPlusTwoIdKey,
 115         int2IntegerIdKey,
 116         addr2IntegerIdKey,
 117         integerTyConKey,
 118         integerZeroIdKey,
 119         integralClassKey,
 120         irrefutPatErrorIdKey,
 121         ixClassKey,
 122         listTyConKey,
 123         mainKey,
 124         makeStablePtrIdKey,
 125         mapIdKey,
 126         minusClassOpKey,
 127         monadClassKey,
 128         monadPlusClassKey,
 129         mutableArrayPrimTyConKey,
 130         mutableByteArrayPrimTyConKey,
 131         mutableByteArrayTyConKey,
 132         mutVarPrimTyConKey,
 133         nilDataConKey,
 134         noMethodBindingErrorIdKey,
 135         nonExhaustiveGuardsErrorIdKey,
 136         numClassKey,
 137         anyBoxConKey,
 138         ordClassKey,
 139         orderingTyConKey,
 140         otherwiseIdKey,
 141         packCStringIdKey,
 142         parErrorIdKey,
 143         parIdKey,
 144         patErrorIdKey,
 145         ratioDataConKey,
 146         ratioTyConKey,
 147         rationalTyConKey,
 148         readClassKey,
 149         realClassKey,
 150         realFloatClassKey,
 151         realFracClassKey,
 152         realWorldPrimIdKey,
 153         realWorldTyConKey,
 154         recConErrorIdKey,
 155         recSelErrIdKey,
 156         recUpdErrorIdKey,
 157         returnMClassOpKey,
 158         showClassKey,
 159         ioTyConKey,
 160         ioDataConKey,
 161         stablePtrDataConKey,
 162         stablePtrPrimTyConKey,
 163         stablePtrTyConKey,
 164         stableNameDataConKey,
 165         stableNamePrimTyConKey,
 166         stableNameTyConKey,
 167
 168         statePrimTyConKey,
 169         typeConKey,
 170         kindConKey,
 171         boxityConKey,
 172         mVarPrimTyConKey,
 173         thenMClassOpKey,
 174         threadIdPrimTyConKey,
 175         toEnumClassOpKey,
 176         traceIdKey,
 177         trueDataConKey,
 178         unboundKey,
 179         unboxedConKey,
 180         unpackCString2IdKey,
 181         unpackCStringAppendIdKey,
 182         unpackCStringFoldrIdKey,
 183         unpackCStringIdKey,
 184         unsafeCoerceIdKey,
 185         ushowListIdKey,
 186         weakPrimTyConKey,
 187         wordDataConKey,
 188         wordPrimTyConKey,
 189         wordTyConKey,
 190         word8TyConKey,
 191         word8DataConKey,
 192         word16TyConKey,
 193         word16DataConKey,
 194         word32TyConKey,
 195         word32DataConKey,
 196         word64DataConKey,
 197         word64PrimTyConKey,
 198         word64TyConKey,
 199         zipIdKey
 200     ) where
 201
 202 #include "HsVersions.h"
 203
 204 import FastString       ( FastString, uniqueOfFS )
 205 import GlaExts
 206 import ST
 207 import PrelBase ( Char(..), chr, ord )
 208
 209 import Outputable
 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 monadPlusClassKey       = mkPreludeClassUnique 9
 467 functorClassKey         = mkPreludeClassUnique 10
 468 numClassKey             = mkPreludeClassUnique 11
 469 ordClassKey             = mkPreludeClassUnique 12
 470 readClassKey            = mkPreludeClassUnique 13
 471 realClassKey            = mkPreludeClassUnique 14
 472 realFloatClassKey       = mkPreludeClassUnique 15
 473 realFracClassKey        = mkPreludeClassUnique 16
 474 showClassKey            = mkPreludeClassUnique 17
 475
 476 cCallableClassKey       = mkPreludeClassUnique 18
 477 cReturnableClassKey     = mkPreludeClassUnique 19
 478
 479 ixClassKey              = mkPreludeClassUnique 20
 480 \end{code}
 481
 482 %************************************************************************
 483 %*                                                                      *
 484 \subsubsection[Uniques-prelude-TyCons]{@Uniques@ for wired-in @TyCons@}
 485 %*                                                                      *
 486 %************************************************************************
 487
 488 \begin{code}
 489 addrPrimTyConKey                        = mkPreludeTyConUnique  1
 490 addrTyConKey                            = mkPreludeTyConUnique  2
 491 arrayPrimTyConKey                       = mkPreludeTyConUnique  3
 492 boolTyConKey                            = mkPreludeTyConUnique  4
 493 byteArrayPrimTyConKey                   = mkPreludeTyConUnique  5
 494 charPrimTyConKey                        = mkPreludeTyConUnique  7
 495 charTyConKey                            = mkPreludeTyConUnique  8
 496 doublePrimTyConKey                      = mkPreludeTyConUnique  9
 497 doubleTyConKey                          = mkPreludeTyConUnique 10
 498 floatPrimTyConKey                       = mkPreludeTyConUnique 11
 499 floatTyConKey                           = mkPreludeTyConUnique 12
 500 funTyConKey                             = mkPreludeTyConUnique 13
 501 intPrimTyConKey                         = mkPreludeTyConUnique 14
 502 intTyConKey                             = mkPreludeTyConUnique 15
 503 int8TyConKey                            = mkPreludeTyConUnique 16
 504 int16TyConKey                           = mkPreludeTyConUnique 17
 505 int32TyConKey                           = mkPreludeTyConUnique 18
 506 int64PrimTyConKey                       = mkPreludeTyConUnique 19
 507 int64TyConKey                           = mkPreludeTyConUnique 20
 508 integerTyConKey                         = mkPreludeTyConUnique 21
 509 listTyConKey                            = mkPreludeTyConUnique 22
 510 foreignObjPrimTyConKey                  = mkPreludeTyConUnique 23
 511 foreignObjTyConKey                      = mkPreludeTyConUnique 24
 512 weakPrimTyConKey                        = mkPreludeTyConUnique 25
 513 mutableArrayPrimTyConKey                = mkPreludeTyConUnique 26
 514 mutableByteArrayPrimTyConKey            = mkPreludeTyConUnique 27
 515 orderingTyConKey                        = mkPreludeTyConUnique 28
 516 mVarPrimTyConKey                        = mkPreludeTyConUnique 29
 517 ratioTyConKey                           = mkPreludeTyConUnique 30
 518 rationalTyConKey                        = mkPreludeTyConUnique 31
 519 realWorldTyConKey                       = mkPreludeTyConUnique 32
 520 stablePtrPrimTyConKey                   = mkPreludeTyConUnique 33
 521 stablePtrTyConKey                       = mkPreludeTyConUnique 34
 522 statePrimTyConKey                       = mkPreludeTyConUnique 35
 523 stableNamePrimTyConKey                  = mkPreludeTyConUnique 50
 524 stableNameTyConKey                      = 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 boxedConKey                             = mkPreludeTyConUnique 64
 537 unboxedConKey                           = mkPreludeTyConUnique 65
 538 anyBoxConKey                            = mkPreludeTyConUnique 66
 539 kindConKey                              = mkPreludeTyConUnique 67
 540 boxityConKey                            = mkPreludeTyConUnique 68
 541 typeConKey                              = mkPreludeTyConUnique 69
 542 threadIdPrimTyConKey                    = mkPreludeTyConUnique 70
 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 smallIntegerDataConKey                  = mkPreludeDataConUnique 12
 564 largeIntegerDataConKey                  = mkPreludeDataConUnique 13
 565 foreignObjDataConKey                    = mkPreludeDataConUnique 14
 566 nilDataConKey                           = mkPreludeDataConUnique 15
 567 ratioDataConKey                         = mkPreludeDataConUnique 16
 568 stablePtrDataConKey                     = mkPreludeDataConUnique 17
 569 stableNameDataConKey                    = mkPreludeDataConUnique 18
 570 trueDataConKey                          = mkPreludeDataConUnique 34
 571 wordDataConKey                          = mkPreludeDataConUnique 35
 572 word8DataConKey                         = mkPreludeDataConUnique 36
 573 word16DataConKey                        = mkPreludeDataConUnique 37
 574 word32DataConKey                        = mkPreludeDataConUnique 38
 575 word64DataConKey                        = mkPreludeDataConUnique 39
 576 stDataConKey                            = mkPreludeDataConUnique 40
 577 ioDataConKey                            = mkPreludeDataConUnique 42
 578 \end{code}
 579
 580 %************************************************************************
 581 %*                                                                      *
 582 \subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}
 583 %*                                                                      *
 584 %************************************************************************
 585
 586 \begin{code}
 587 absentErrorIdKey              = mkPreludeMiscIdUnique  1
 588 appendIdKey                   = mkPreludeMiscIdUnique  2
 589 augmentIdKey                  = mkPreludeMiscIdUnique  3
 590 buildIdKey                    = mkPreludeMiscIdUnique  4
 591 errorIdKey                    = mkPreludeMiscIdUnique  5
 592 foldlIdKey                    = mkPreludeMiscIdUnique  6
 593 foldrIdKey                    = mkPreludeMiscIdUnique  7
 594 recSelErrIdKey                = mkPreludeMiscIdUnique  8
 595 integerMinusOneIdKey          = mkPreludeMiscIdUnique  9
 596 integerPlusOneIdKey           = mkPreludeMiscIdUnique 10
 597 integerPlusTwoIdKey           = mkPreludeMiscIdUnique 11
 598 integerZeroIdKey              = mkPreludeMiscIdUnique 12
 599 int2IntegerIdKey              = mkPreludeMiscIdUnique 13
 600 addr2IntegerIdKey             = mkPreludeMiscIdUnique 14
 601 irrefutPatErrorIdKey          = mkPreludeMiscIdUnique 15
 602 lexIdKey                      = mkPreludeMiscIdUnique 16
 603 noMethodBindingErrorIdKey     = mkPreludeMiscIdUnique 17
 604 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 18
 605 packCStringIdKey              = mkPreludeMiscIdUnique 19
 606 parErrorIdKey                 = mkPreludeMiscIdUnique 20
 607 parIdKey                      = mkPreludeMiscIdUnique 21
 608 patErrorIdKey                 = mkPreludeMiscIdUnique 22
 609 realWorldPrimIdKey            = mkPreludeMiscIdUnique 23
 610 recConErrorIdKey              = mkPreludeMiscIdUnique 24
 611 recUpdErrorIdKey              = mkPreludeMiscIdUnique 25
 612 traceIdKey                    = mkPreludeMiscIdUnique 26
 613 unpackCString2IdKey           = mkPreludeMiscIdUnique 27
 614 unpackCStringAppendIdKey      = mkPreludeMiscIdUnique 28
 615 unpackCStringFoldrIdKey       = mkPreludeMiscIdUnique 29
 616 unpackCStringIdKey            = mkPreludeMiscIdUnique 30
 617 ushowListIdKey                = mkPreludeMiscIdUnique 31
 618 unsafeCoerceIdKey             = mkPreludeMiscIdUnique 32
 619 concatIdKey                   = mkPreludeMiscIdUnique 33
 620 filterIdKey                   = mkPreludeMiscIdUnique 34
 621 zipIdKey                      = mkPreludeMiscIdUnique 35
 622 bindIOIdKey                   = mkPreludeMiscIdUnique 36
 623 deRefStablePtrIdKey           = mkPreludeMiscIdUnique 37
 624 makeStablePtrIdKey            = mkPreludeMiscIdUnique 38
 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 failMClassOpKey               = 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}