ghc/compiler/basicTypes/Unique.lhs

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