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