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