X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2FbasicTypes%2FUnique.lhs;h=2f2b1c81d13841c8bd667db5d57b10d6359eb5e0;hb=26741ec416bae2c502ef00a2ba0e79050a32cb67;hp=b77ed34ece603f53bf56b38cb3122fc5ccfb41c6;hpb=7b0181919416d8f04324575b7e17031ca692f5b0;p=ghc-hetmet.git diff --git a/ghc/compiler/basicTypes/Unique.lhs b/ghc/compiler/basicTypes/Unique.lhs index b77ed34..2f2b1c8 100644 --- a/ghc/compiler/basicTypes/Unique.lhs +++ b/ghc/compiler/basicTypes/Unique.lhs @@ -29,6 +29,9 @@ module Unique ( mkUnique, -- Used in UniqSupply mkUniqueGrimily, -- Used in UniqSupply only! + incrUnique, -- Used for renumbering + initRenumberingUniques, + -- now all the built-in Uniques (and functions to make them) -- [the Oh-So-Wonderful Haskell module system wins again...] mkAlphaTyVarUnique, @@ -36,15 +39,19 @@ module Unique ( mkTupleDataConUnique, mkTupleTyConUnique, + getBuiltinUniques, mkBuiltinUnique, + mkPseudoUnique1, mkPseudoUnique2, mkPseudoUnique3, + absentErrorIdKey, -- alphabetical... addrDataConKey, addrPrimTyConKey, addrTyConKey, + andandIdKey, appendIdKey, arrayPrimTyConKey, augmentIdKey, - binaryClassKey, boolTyConKey, + boundedClassKey, buildDataConKey, buildIdKey, byteArrayPrimTyConKey, @@ -53,8 +60,8 @@ module Unique ( charDataConKey, charPrimTyConKey, charTyConKey, + composeIdKey, consDataConKey, - dataClassKey, doubleDataConKey, doublePrimTyConKey, doubleTyConKey, @@ -67,6 +74,7 @@ module Unique ( eqClassOpKey, eqDataConKey, errorIdKey, + evalClassKey, falseDataConKey, floatDataConKey, floatPrimTyConKey, @@ -74,12 +82,16 @@ module Unique ( floatingClassKey, foldlIdKey, foldrIdKey, + foreignObjDataConKey, + foreignObjPrimTyConKey, + foreignObjTyConKey, forkIdKey, fractionalClassKey, fromIntClassOpKey, fromIntegerClassOpKey, fromRationalClassOpKey, funTyConKey, + functorClassKey, geClassOpKey, gtDataConKey, iOTyConKey, @@ -93,21 +105,25 @@ module Unique ( integerTyConKey, integerZeroIdKey, integralClassKey, + irrefutPatErrorIdKey, ixClassKey, + lexIdKey, liftDataConKey, liftTyConKey, listTyConKey, ltDataConKey, mainIdKey, mainPrimIOIdKey, - mallocPtrDataConKey, - mallocPtrPrimTyConKey, - mallocPtrTyConKey, monadClassKey, + monadPlusClassKey, monadZeroClassKey, mutableArrayPrimTyConKey, mutableByteArrayPrimTyConKey, nilDataConKey, + noDefaultMethodErrorIdKey, + nonExhaustiveGuardsErrorIdKey, + nonExplicitMethodErrorIdKey, + notIdKey, numClassKey, ordClassKey, orderingTyConKey, @@ -115,20 +131,20 @@ module Unique ( parErrorIdKey, parIdKey, patErrorIdKey, - recConErrorIdKey, - recUpdErrorIdKey, - irrefutPatErrorIdKey, - nonExhaustiveGuardsErrorIdKey, primIoTyConKey, + primIoDataConKey, ratioDataConKey, ratioTyConKey, rationalTyConKey, readClassKey, + readParenIdKey, realClassKey, realFloatClassKey, realFracClassKey, realWorldPrimIdKey, realWorldTyConKey, + recConErrorIdKey, + recUpdErrorIdKey, return2GMPsDataConKey, return2GMPsTyConKey, returnIntAndGMPDataConKey, @@ -136,7 +152,11 @@ module Unique ( runSTIdKey, seqIdKey, showClassKey, + showParenIdKey, + showSpaceIdKey, + showStringIdKey, stTyConKey, + stDataConKey, stablePtrDataConKey, stablePtrPrimTyConKey, stablePtrTyConKey, @@ -152,10 +172,10 @@ module Unique ( stateAndDoublePrimTyConKey, stateAndFloatPrimDataConKey, stateAndFloatPrimTyConKey, + stateAndForeignObjPrimDataConKey, + stateAndForeignObjPrimTyConKey, stateAndIntPrimDataConKey, stateAndIntPrimTyConKey, - stateAndMallocPtrPrimDataConKey, - stateAndMallocPtrPrimTyConKey, stateAndMutableArrayPrimDataConKey, stateAndMutableArrayPrimTyConKey, stateAndMutableByteArrayPrimDataConKey, @@ -171,31 +191,35 @@ module Unique ( stateDataConKey, statePrimTyConKey, stateTyConKey, - stringTyConKey, synchVarPrimTyConKey, + thenMClassOpKey, traceIdKey, trueDataConKey, unpackCString2IdKey, unpackCStringAppendIdKey, unpackCStringFoldrIdKey, unpackCStringIdKey, - voidPrimIdKey, - voidPrimTyConKey, + ureadListIdKey, + ushowListIdKey, + voidIdKey, + voidTyConKey, wordDataConKey, wordPrimTyConKey, - wordTyConKey -#ifdef GRAN + wordTyConKey, + zeroClassOpKey , copyableIdKey , noFollowIdKey + , parAtAbsIdKey + , parAtForNowIdKey + , parAtIdKey + , parAtRelIdKey , parGlobalIdKey , parLocalIdKey -#endif - -- to make interface self-sufficient ) where import PreludeGlaST -import Ubiq{-uitous-} +IMP_Ubiq(){-uitous-} import Pretty import Util @@ -221,25 +245,19 @@ Now come the functions which construct uniques from their pieces, and vice versa The stuff about unique *supplies* is handled further down this module. \begin{code} -mkUnique :: Char -> Int -> Unique -- Builds a unique from pieces -unpkUnique :: Unique -> (Char, Int) -- The reverse - -mkUnifiableTyVarUnique :: Int -> Unique -- Injects a subst-array index into the Unique type -unpkUnifiableTyVarUnique :: Unique -> Int -- The reverse process +mkUnique :: Char -> Int -> Unique -- Builds a unique from pieces +unpkUnique :: Unique -> (Char, Int) -- The reverse mkUniqueGrimily :: Int# -> Unique -- A trap-door for UniqSupply + +incrUnique :: Unique -> Unique \end{code} \begin{code} mkUniqueGrimily x = MkUnique x -mkUnifiableTyVarUnique i = mkUnique '_'{-MAGIC CHAR-} i - -unpkUnifiableTyVarUnique uniq - = case (unpkUnique uniq) of { (tag, i) -> - ASSERT(tag == '_'{-MAGIC CHAR-}) - i } +incrUnique (MkUnique i) = MkUnique (i +# 1#) -- pop the Char in the top 8 bits of the Unique(Supply) @@ -249,13 +267,13 @@ w2i x = word2Int# x i2w x = int2Word# x i2w_s x = (x::Int#) -mkUnique (MkChar c#) (MkInt i#) - = MkUnique (w2i (((i2w (ord# c#)) `shiftL#` (i2w_s 24#)) `or#` (i2w i#))) +mkUnique (C# c) (I# i) + = MkUnique (w2i (((i2w (ord# c)) `shiftL#` (i2w_s 24#)) `or#` (i2w i))) unpkUnique (MkUnique u) = let - tag = MkChar (chr# (w2i ((i2w u) `shiftr` (i2w_s 24#)))) - i = MkInt (w2i ((i2w u) `and#` (i2w 16777215#){-``0x00ffffff''-})) + tag = C# (chr# (w2i ((i2w u) `shiftr` (i2w_s 24#)))) + i = I# (w2i ((i2w u) `and#` (i2w 16777215#){-``0x00ffffff''-})) in (tag, i) where @@ -305,11 +323,25 @@ pprUnique, pprUnique10 :: Unique -> Pretty pprUnique uniq = case unpkUnique uniq of - (tag, u) -> ppBeside (ppChar tag) (iToBase62 u) + (tag, u) -> finish_ppr tag u (iToBase62 u) pprUnique10 uniq -- in base-10, dudes = case unpkUnique uniq of - (tag, u) -> ppBeside (ppChar tag) (ppInt u) + (tag, u) -> finish_ppr tag u (ppInt u) + +finish_ppr tag u pp_u + = if tag /= 't' -- this is just to make v common tyvars, t1, t2, ... + -- come out as a, b, ... (shorter, easier to read) + then pp_all + else case u of + 1 -> ppChar 'a' + 2 -> ppChar 'b' + 3 -> ppChar 'c' + 4 -> ppChar 'd' + 5 -> ppChar 'e' + _ -> pp_all + where + pp_all = ppBeside (ppChar tag) pp_u showUnique :: Unique -> FAST_STRING showUnique uniq = _PK_ (ppShow 80 (pprUnique uniq)) @@ -319,7 +351,6 @@ instance Outputable Unique where instance Text Unique where showsPrec p uniq rest = _UNPK_ (showUnique uniq) - readsPrec p = panic "no readsPrec for Unique" \end{code} %************************************************************************ @@ -332,12 +363,26 @@ A character-stingy way to read/write numbers (notably Uniques). The ``62-its'' are \tr{[0-9a-zA-Z]}. We don't handle negative Ints. Code stolen from Lennart. \begin{code} +#if __GLASGOW_HASKELL__ >= 200 +# define BYTE_ARRAY GHCbase.ByteArray +# define RUN_ST GHCbase.runST +# define AND_THEN >>= +# define AND_THEN_ >> +# define RETURN return +#else +# define BYTE_ARRAY _ByteArray +# define RUN_ST _runST +# define AND_THEN `thenStrictlyST` +# define AND_THEN_ `seqStrictlyST` +# define RETURN returnStrictlyST +#endif + iToBase62 :: Int -> Pretty iToBase62 n@(I# n#) = ASSERT(n >= 0) let - bytes = case chars62 of { _ByteArray bounds_who_needs_'em bytes -> bytes } + bytes = case chars62 of { BYTE_ARRAY bounds_who_needs_'em bytes -> bytes } in if n# <# 62# then case (indexCharArray# bytes n#) of { c -> @@ -348,20 +393,20 @@ iToBase62 n@(I# n#) ppBeside (iToBase62 q) (ppChar (C# c)) }} -- keep this at top level! (bug on 94/10/24 WDP) -chars62 :: _ByteArray Int +chars62 :: BYTE_ARRAY Int chars62 - = _runST ( - newCharArray (0, 61) `thenStrictlyST` \ ch_array -> + = RUN_ST ( + newCharArray (0, 61) AND_THEN \ ch_array -> fill_in ch_array 0 62 "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" - `seqStrictlyST` + AND_THEN_ unsafeFreezeByteArray ch_array ) where fill_in ch_array i lim str | i == lim - = returnStrictlyST () + = RETURN () | otherwise - = writeCharArray ch_array i (str !! i) `seqStrictlyST` + = writeCharArray ch_array i (str !! i) AND_THEN_ fill_in ch_array (i+1) lim str \end{code} @@ -372,9 +417,10 @@ chars62 %************************************************************************ Allocation of unique supply characters: - a-z: lower case chars for unique supplies (see Main.lhs) - B: builtin (see UniqSupply.lhs) - C-E: pseudo uniques (see UniqSupply.lhs) + v,t,u : for renumbering value-, type- and usage- vars. + other a-z: lower case chars for unique supplies (see Main.lhs) + B: builtin + C-E: pseudo uniques (used in native-code generator) _: unifiable tyvars (above) 1-8: prelude things below @@ -390,6 +436,19 @@ mkTupleDataConUnique a = mkUnique '6' a -- ditto (*may* be used in C labels) mkPrimOpIdUnique op = mkUnique '7' op mkPreludeMiscIdUnique i = mkUnique '8' i + +initRenumberingUniques = (mkUnique 'v' 1, mkUnique 't' 1, mkUnique 'u' 1) + +mkPseudoUnique1, mkPseudoUnique2, mkPseudoUnique3, + mkBuiltinUnique :: Int -> Unique + +mkBuiltinUnique i = mkUnique 'B' i +mkPseudoUnique1 i = mkUnique 'C' i -- used for uniqueOf on Regs +mkPseudoUnique2 i = mkUnique 'D' i -- ditto +mkPseudoUnique3 i = mkUnique 'E' i -- ditto + +getBuiltinUniques :: Int -> [Unique] +getBuiltinUniques n = map (mkUnique 'B') [1 .. n] \end{code} %************************************************************************ @@ -399,25 +458,29 @@ mkPreludeMiscIdUnique i = mkUnique '8' i %************************************************************************ \begin{code} -eqClassKey = mkPreludeClassUnique 1 -ordClassKey = mkPreludeClassUnique 2 -numClassKey = mkPreludeClassUnique 3 -integralClassKey = mkPreludeClassUnique 4 -fractionalClassKey = mkPreludeClassUnique 5 -floatingClassKey = mkPreludeClassUnique 6 -realClassKey = mkPreludeClassUnique 7 -realFracClassKey = mkPreludeClassUnique 8 -realFloatClassKey = mkPreludeClassUnique 9 -ixClassKey = mkPreludeClassUnique 10 -enumClassKey = mkPreludeClassUnique 11 -showClassKey = mkPreludeClassUnique 12 -readClassKey = mkPreludeClassUnique 13 -monadClassKey = mkPreludeClassUnique 14 -monadZeroClassKey = mkPreludeClassUnique 15 -binaryClassKey = mkPreludeClassUnique 16 -cCallableClassKey = mkPreludeClassUnique 17 -cReturnableClassKey = mkPreludeClassUnique 18 -dataClassKey = mkPreludeClassUnique 19 +boundedClassKey = mkPreludeClassUnique 1 +enumClassKey = mkPreludeClassUnique 2 +eqClassKey = mkPreludeClassUnique 3 +evalClassKey = mkPreludeClassUnique 4 +floatingClassKey = mkPreludeClassUnique 5 +fractionalClassKey = mkPreludeClassUnique 6 +integralClassKey = mkPreludeClassUnique 7 +monadClassKey = mkPreludeClassUnique 8 +monadZeroClassKey = mkPreludeClassUnique 9 +monadPlusClassKey = mkPreludeClassUnique 10 +functorClassKey = mkPreludeClassUnique 11 +numClassKey = mkPreludeClassUnique 12 +ordClassKey = mkPreludeClassUnique 13 +readClassKey = mkPreludeClassUnique 14 +realClassKey = mkPreludeClassUnique 15 +realFloatClassKey = mkPreludeClassUnique 16 +realFracClassKey = mkPreludeClassUnique 17 +showClassKey = mkPreludeClassUnique 18 + +cCallableClassKey = mkPreludeClassUnique 19 +cReturnableClassKey = mkPreludeClassUnique 20 + +ixClassKey = mkPreludeClassUnique 21 \end{code} %************************************************************************ @@ -445,8 +508,8 @@ intTyConKey = mkPreludeTyConUnique 16 integerTyConKey = mkPreludeTyConUnique 17 liftTyConKey = mkPreludeTyConUnique 18 listTyConKey = mkPreludeTyConUnique 19 -mallocPtrPrimTyConKey = mkPreludeTyConUnique 20 -mallocPtrTyConKey = mkPreludeTyConUnique 21 +foreignObjPrimTyConKey = mkPreludeTyConUnique 20 +foreignObjTyConKey = mkPreludeTyConUnique 21 mutableArrayPrimTyConKey = mkPreludeTyConUnique 22 mutableByteArrayPrimTyConKey = mkPreludeTyConUnique 23 orderingTyConKey = mkPreludeTyConUnique 24 @@ -465,7 +528,7 @@ stateAndCharPrimTyConKey = mkPreludeTyConUnique 36 stateAndDoublePrimTyConKey = mkPreludeTyConUnique 37 stateAndFloatPrimTyConKey = mkPreludeTyConUnique 38 stateAndIntPrimTyConKey = mkPreludeTyConUnique 39 -stateAndMallocPtrPrimTyConKey = mkPreludeTyConUnique 40 +stateAndForeignObjPrimTyConKey = mkPreludeTyConUnique 40 stateAndMutableArrayPrimTyConKey = mkPreludeTyConUnique 41 stateAndMutableByteArrayPrimTyConKey = mkPreludeTyConUnique 42 stateAndSynchVarPrimTyConKey = mkPreludeTyConUnique 43 @@ -474,12 +537,13 @@ stateAndStablePtrPrimTyConKey = mkPreludeTyConUnique 45 stateAndWordPrimTyConKey = mkPreludeTyConUnique 46 statePrimTyConKey = mkPreludeTyConUnique 47 stateTyConKey = mkPreludeTyConUnique 48 -stringTyConKey = mkPreludeTyConUnique 49 + -- 49 is spare stTyConKey = mkPreludeTyConUnique 50 primIoTyConKey = mkPreludeTyConUnique 51 -voidPrimTyConKey = mkPreludeTyConUnique 52 + -- 52 is spare wordPrimTyConKey = mkPreludeTyConUnique 53 wordTyConKey = mkPreludeTyConUnique 54 +voidTyConKey = mkPreludeTyConUnique 55 \end{code} %************************************************************************ @@ -502,7 +566,7 @@ intDataConKey = mkPreludeDataConUnique 11 integerDataConKey = mkPreludeDataConUnique 12 liftDataConKey = mkPreludeDataConUnique 13 ltDataConKey = mkPreludeDataConUnique 14 -mallocPtrDataConKey = mkPreludeDataConUnique 15 +foreignObjDataConKey = mkPreludeDataConUnique 15 nilDataConKey = mkPreludeDataConUnique 18 ratioDataConKey = mkPreludeDataConUnique 21 return2GMPsDataConKey = mkPreludeDataConUnique 22 @@ -515,7 +579,7 @@ stateAndCharPrimDataConKey = mkPreludeDataConUnique 28 stateAndDoublePrimDataConKey = mkPreludeDataConUnique 29 stateAndFloatPrimDataConKey = mkPreludeDataConUnique 30 stateAndIntPrimDataConKey = mkPreludeDataConUnique 31 -stateAndMallocPtrPrimDataConKey = mkPreludeDataConUnique 32 +stateAndForeignObjPrimDataConKey = mkPreludeDataConUnique 32 stateAndMutableArrayPrimDataConKey = mkPreludeDataConUnique 33 stateAndMutableByteArrayPrimDataConKey = mkPreludeDataConUnique 34 stateAndSynchVarPrimDataConKey = mkPreludeDataConUnique 35 @@ -525,6 +589,8 @@ stateAndWordPrimDataConKey = mkPreludeDataConUnique 38 stateDataConKey = mkPreludeDataConUnique 39 trueDataConKey = mkPreludeDataConUnique 40 wordDataConKey = mkPreludeDataConUnique 41 +stDataConKey = mkPreludeDataConUnique 42 +primIoDataConKey = mkPreludeDataConUnique 43 \end{code} %************************************************************************ @@ -535,61 +601,73 @@ wordDataConKey = mkPreludeDataConUnique 41 \begin{code} absentErrorIdKey = mkPreludeMiscIdUnique 1 -appendIdKey = mkPreludeMiscIdUnique 2 -augmentIdKey = mkPreludeMiscIdUnique 3 -buildIdKey = mkPreludeMiscIdUnique 4 -errorIdKey = mkPreludeMiscIdUnique 5 -foldlIdKey = mkPreludeMiscIdUnique 6 -foldrIdKey = mkPreludeMiscIdUnique 7 -forkIdKey = mkPreludeMiscIdUnique 8 -int2IntegerIdKey = mkPreludeMiscIdUnique 9 -integerMinusOneIdKey = mkPreludeMiscIdUnique 10 -integerPlusOneIdKey = mkPreludeMiscIdUnique 11 -integerPlusTwoIdKey = mkPreludeMiscIdUnique 12 -integerZeroIdKey = mkPreludeMiscIdUnique 13 -packCStringIdKey = mkPreludeMiscIdUnique 14 -parErrorIdKey = mkPreludeMiscIdUnique 15 -parIdKey = mkPreludeMiscIdUnique 16 -patErrorIdKey = mkPreludeMiscIdUnique 17 -realWorldPrimIdKey = mkPreludeMiscIdUnique 18 -runSTIdKey = mkPreludeMiscIdUnique 19 -seqIdKey = mkPreludeMiscIdUnique 20 -traceIdKey = mkPreludeMiscIdUnique 21 -unpackCString2IdKey = mkPreludeMiscIdUnique 22 -unpackCStringAppendIdKey = mkPreludeMiscIdUnique 23 -unpackCStringFoldrIdKey = mkPreludeMiscIdUnique 24 -unpackCStringIdKey = mkPreludeMiscIdUnique 25 -voidPrimIdKey = mkPreludeMiscIdUnique 26 -mainIdKey = mkPreludeMiscIdUnique 27 -mainPrimIOIdKey = mkPreludeMiscIdUnique 28 -recConErrorIdKey = mkPreludeMiscIdUnique 29 -recUpdErrorIdKey = mkPreludeMiscIdUnique 30 -irrefutPatErrorIdKey = mkPreludeMiscIdUnique 31 -nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 32 - -#ifdef GRAN -parLocalIdKey = mkPreludeMiscIdUnique 33 -parGlobalIdKey = mkPreludeMiscIdUnique 34 -noFollowIdKey = mkPreludeMiscIdUnique 35 -copyableIdKey = mkPreludeMiscIdUnique 36 -#endif +andandIdKey = mkPreludeMiscIdUnique 2 +appendIdKey = mkPreludeMiscIdUnique 3 +augmentIdKey = mkPreludeMiscIdUnique 4 +buildIdKey = mkPreludeMiscIdUnique 5 +composeIdKey = mkPreludeMiscIdUnique 6 +errorIdKey = mkPreludeMiscIdUnique 7 +foldlIdKey = mkPreludeMiscIdUnique 8 +foldrIdKey = mkPreludeMiscIdUnique 9 +forkIdKey = mkPreludeMiscIdUnique 10 +int2IntegerIdKey = mkPreludeMiscIdUnique 11 +integerMinusOneIdKey = mkPreludeMiscIdUnique 12 +integerPlusOneIdKey = mkPreludeMiscIdUnique 13 +integerPlusTwoIdKey = mkPreludeMiscIdUnique 14 +integerZeroIdKey = mkPreludeMiscIdUnique 15 +irrefutPatErrorIdKey = mkPreludeMiscIdUnique 16 +lexIdKey = mkPreludeMiscIdUnique 17 +mainIdKey = mkPreludeMiscIdUnique 18 +mainPrimIOIdKey = mkPreludeMiscIdUnique 19 +noDefaultMethodErrorIdKey = mkPreludeMiscIdUnique 20 +nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 21 +nonExplicitMethodErrorIdKey = mkPreludeMiscIdUnique 22 +notIdKey = mkPreludeMiscIdUnique 23 +packCStringIdKey = mkPreludeMiscIdUnique 24 +parErrorIdKey = mkPreludeMiscIdUnique 25 +parIdKey = mkPreludeMiscIdUnique 26 +patErrorIdKey = mkPreludeMiscIdUnique 27 +readParenIdKey = mkPreludeMiscIdUnique 28 +realWorldPrimIdKey = mkPreludeMiscIdUnique 29 +recConErrorIdKey = mkPreludeMiscIdUnique 30 +recUpdErrorIdKey = mkPreludeMiscIdUnique 31 +runSTIdKey = mkPreludeMiscIdUnique 32 +seqIdKey = mkPreludeMiscIdUnique 33 +showParenIdKey = mkPreludeMiscIdUnique 34 +showSpaceIdKey = mkPreludeMiscIdUnique 35 +showStringIdKey = mkPreludeMiscIdUnique 36 +traceIdKey = mkPreludeMiscIdUnique 37 +unpackCString2IdKey = mkPreludeMiscIdUnique 38 +unpackCStringAppendIdKey = mkPreludeMiscIdUnique 39 +unpackCStringFoldrIdKey = mkPreludeMiscIdUnique 40 +unpackCStringIdKey = mkPreludeMiscIdUnique 41 +voidIdKey = mkPreludeMiscIdUnique 42 +ushowListIdKey = mkPreludeMiscIdUnique 43 +ureadListIdKey = mkPreludeMiscIdUnique 44 + +copyableIdKey = mkPreludeMiscIdUnique 45 +noFollowIdKey = mkPreludeMiscIdUnique 46 +parAtAbsIdKey = mkPreludeMiscIdUnique 47 +parAtForNowIdKey = mkPreludeMiscIdUnique 48 +parAtIdKey = mkPreludeMiscIdUnique 49 +parAtRelIdKey = mkPreludeMiscIdUnique 50 +parGlobalIdKey = mkPreludeMiscIdUnique 51 +parLocalIdKey = mkPreludeMiscIdUnique 52 \end{code} Certain class operations from Prelude classes. They get their own uniques so we can look them up easily when we want to conjure them up during type checking. \begin{code} -fromIntClassOpKey = mkPreludeMiscIdUnique 37 -fromIntegerClassOpKey = mkPreludeMiscIdUnique 38 -fromRationalClassOpKey = mkPreludeMiscIdUnique 39 -enumFromClassOpKey = mkPreludeMiscIdUnique 40 -enumFromThenClassOpKey = mkPreludeMiscIdUnique 41 -enumFromToClassOpKey = mkPreludeMiscIdUnique 42 -enumFromThenToClassOpKey= mkPreludeMiscIdUnique 43 -eqClassOpKey = mkPreludeMiscIdUnique 44 -geClassOpKey = mkPreludeMiscIdUnique 45 +fromIntClassOpKey = mkPreludeMiscIdUnique 53 +fromIntegerClassOpKey = mkPreludeMiscIdUnique 54 +fromRationalClassOpKey = mkPreludeMiscIdUnique 55 +enumFromClassOpKey = mkPreludeMiscIdUnique 56 +enumFromThenClassOpKey = mkPreludeMiscIdUnique 57 +enumFromToClassOpKey = mkPreludeMiscIdUnique 58 +enumFromThenToClassOpKey= mkPreludeMiscIdUnique 59 +eqClassOpKey = mkPreludeMiscIdUnique 60 +geClassOpKey = mkPreludeMiscIdUnique 61 +zeroClassOpKey = mkPreludeMiscIdUnique 62 +thenMClassOpKey = mkPreludeMiscIdUnique 63 -- (>>=) \end{code} - - - -