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