-%
-% (c) The GRASP/AQUA Project, Glasgow University, 1992-1996
-%
-\section[Unique]{The @Unique@ data type}
+
@Uniques@ are used to distinguish entities in the compiler (@Ids@,
@Classes@, etc.) from each other. Thus, @Uniques@ are the basic
Haskell).
\begin{code}
-#include "HsVersions.h"
-
---<mkdependHS:friends> UniqSupply
-
module Unique (
- Unique,
+ Unique, Uniquable(..),
u2i, -- hack: used in UniqFM
pprUnique, pprUnique10, showUnique,
mkUnique, -- Used in UniqSupply
mkUniqueGrimily, -- Used in UniqSupply only!
+ incrUnique, -- Used for renumbering
+ initTyVarUnique, mkTyVarUnique,
+ initTidyUniques,
+
-- now all the built-in Uniques (and functions to make them)
-- [the Oh-So-Wonderful Haskell module system wins again...]
mkAlphaTyVarUnique,
mkTupleDataConUnique,
mkTupleTyConUnique,
+ getBuiltinUniques, mkBuiltinUnique,
+ mkPseudoUnique1, mkPseudoUnique2, mkPseudoUnique3,
+
absentErrorIdKey, -- alphabetical...
addrDataConKey,
addrPrimTyConKey,
addrTyConKey,
+ andandIdKey,
appendIdKey,
arrayPrimTyConKey,
+ assertIdKey,
augmentIdKey,
- binaryClassKey,
boolTyConKey,
boundedClassKey,
buildDataConKey,
charDataConKey,
charPrimTyConKey,
charTyConKey,
+ coerceIdKey,
+ composeIdKey,
consDataConKey,
- evalClassKey,
doubleDataConKey,
doublePrimTyConKey,
doubleTyConKey,
eqClassOpKey,
eqDataConKey,
errorIdKey,
+ evalClassKey,
falseDataConKey,
floatDataConKey,
floatPrimTyConKey,
floatingClassKey,
foldlIdKey,
foldrIdKey,
+ foreignObjDataConKey,
+ foreignObjPrimTyConKey,
+ foreignObjTyConKey,
forkIdKey,
fractionalClassKey,
+ fromEnumClassOpKey,
fromIntClassOpKey,
fromIntegerClassOpKey,
fromRationalClassOpKey,
funTyConKey,
+ functorClassKey,
geClassOpKey,
gtDataConKey,
- iOTyConKey,
+ inlineIdKey,
intDataConKey,
intPrimTyConKey,
intTyConKey,
integerTyConKey,
integerZeroIdKey,
integralClassKey,
+ irrefutPatErrorIdKey,
ixClassKey,
+ lexIdKey,
liftDataConKey,
liftTyConKey,
listTyConKey,
ltDataConKey,
- mainIdKey,
- mainPrimIOIdKey,
- mallocPtrDataConKey,
- mallocPtrPrimTyConKey,
- mallocPtrTyConKey,
+ mainKey,
+ minusClassOpKey,
monadClassKey,
+ monadPlusClassKey,
monadZeroClassKey,
mutableArrayPrimTyConKey,
mutableByteArrayPrimTyConKey,
nilDataConKey,
+ noMethodBindingErrorIdKey,
+ nonExhaustiveGuardsErrorIdKey,
+ notIdKey,
numClassKey,
ordClassKey,
orderingTyConKey,
+ otherwiseIdKey,
packCStringIdKey,
parErrorIdKey,
parIdKey,
patErrorIdKey,
- recConErrorIdKey,
- recUpdErrorIdKey,
- irrefutPatErrorIdKey,
- nonExhaustiveGuardsErrorIdKey,
- primIoTyConKey,
ratioDataConKey,
ratioTyConKey,
rationalTyConKey,
readClassKey,
+ readParenIdKey,
realClassKey,
realFloatClassKey,
realFracClassKey,
realWorldPrimIdKey,
realWorldTyConKey,
+ recConErrorIdKey,
+ recSelErrIdKey,
+ recUpdErrorIdKey,
return2GMPsDataConKey,
return2GMPsTyConKey,
returnIntAndGMPDataConKey,
returnIntAndGMPTyConKey,
- runSTIdKey,
+ returnMClassOpKey,
seqIdKey,
showClassKey,
+ showParenIdKey,
+ showSpaceIdKey,
+ showStringIdKey,
stTyConKey,
+ stDataConKey,
+ ioTyConKey,
+ ioDataConKey,
+ ioResultTyConKey,
+ ioOkDataConKey,
+ ioFailDataConKey,
stablePtrDataConKey,
stablePtrPrimTyConKey,
stablePtrTyConKey,
stateAndDoublePrimTyConKey,
stateAndFloatPrimDataConKey,
stateAndFloatPrimTyConKey,
+ stateAndForeignObjPrimDataConKey,
+ stateAndForeignObjPrimTyConKey,
stateAndIntPrimDataConKey,
stateAndIntPrimTyConKey,
- stateAndMallocPtrPrimDataConKey,
- stateAndMallocPtrPrimTyConKey,
stateAndMutableArrayPrimDataConKey,
stateAndMutableArrayPrimTyConKey,
stateAndMutableByteArrayPrimDataConKey,
stateAndWordPrimDataConKey,
stateAndWordPrimTyConKey,
stateDataConKey,
+ stRetDataConKey,
statePrimTyConKey,
stateTyConKey,
- stringTyConKey,
+ stRetTyConKey,
synchVarPrimTyConKey,
+ thenMClassOpKey,
+ toEnumClassOpKey,
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
+ , unboundKey
+ , byteArrayTyConKey
+ , mutableByteArrayTyConKey
+ , allClassKey
) where
-import PreludeGlaST
+#include "HsVersions.h"
-import Ubiq{-uitous-}
+import FastString ( uniqueOfFS )
+import GlaExts
+import ST
+import PrelBase ( Char(..), chr, ord )
-import Pretty
+import Outputable
import Util
\end{code}
Fast comparison is everything on @Uniques@:
\begin{code}
-u2i :: Unique -> FAST_INT
-
data Unique = MkUnique Int#
+\end{code}
+
+\begin{code}
+u2i :: Unique -> FAST_INT
u2i (MkUnique i) = i
\end{code}
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)
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
shiftr x y = shiftRA# x y
\end{code}
+
+
+%************************************************************************
+%* *
+\subsection[Uniquable-class]{The @Uniquable@ class}
+%* *
+%************************************************************************
+
+\begin{code}
+class Uniquable a where
+ uniqueOf :: a -> Unique
+
+instance Uniquable FastString where
+ uniqueOf fs = mkUniqueGrimily (uniqueOfFS fs)
+
+instance Uniquable Int where
+ uniqueOf (I# i#) = mkUniqueGrimily i#
+\end{code}
+
+
%************************************************************************
%* *
\subsection[Unique-instances]{Instance declarations for @Unique@}
leUnique (MkUnique u1) (MkUnique u2) = u1 <=# u2
cmpUnique (MkUnique u1) (MkUnique u2)
- = if u1 ==# u2 then EQ_ else if u1 <# u2 then LT_ else GT_
+ = if u1 ==# u2 then EQ else if u1 <# u2 then LT else GT
instance Eq Unique where
a == b = eqUnique a b
a <= b = leUnique a b
a > b = not (leUnique a b)
a >= b = not (ltUnique a b)
- _tagCmp a b = case cmpUnique a b of { LT_ -> _LT; EQ_ -> _EQ; GT__ -> _GT }
-
-instance Ord3 Unique where
- cmp = cmpUnique
+ compare a b = cmpUnique a b
-----------------
instance Uniquable Unique where
We do sometimes make strings with @Uniques@ in them:
\begin{code}
-pprUnique, pprUnique10 :: Unique -> Pretty
+pprUnique, pprUnique10 :: Unique -> SDoc
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 (int u)
+
+finish_ppr 't' u pp_u | u < 26
+ = -- Special case to make v common tyvars, t1, t2, ...
+ -- come out as a, b, ... (shorter, easier to read)
+ char (chr (ord 'a' + u))
+finish_ppr tag u pp_u = char tag <> pp_u
-showUnique :: Unique -> FAST_STRING
-showUnique uniq = _PK_ (ppShow 80 (pprUnique uniq))
+showUnique :: Unique -> String
+showUnique uniq = showSDoc (pprUnique uniq)
instance Outputable Unique where
- ppr sty u = pprUnique u
+ ppr u = pprUnique u
instance Text Unique where
- showsPrec p uniq rest = _UNPK_ (showUnique uniq)
- readsPrec p = panic "no readsPrec for Unique"
+ showsPrec p uniq rest = showUnique uniq
\end{code}
%************************************************************************
The ``62-its'' are \tr{[0-9a-zA-Z]}. We don't handle negative Ints.
Code stolen from Lennart.
\begin{code}
-iToBase62 :: Int -> Pretty
+# define BYTE_ARRAY GlaExts.ByteArray
+# define RUN_ST ST.runST
+# define AND_THEN >>=
+# define AND_THEN_ >>
+# define RETURN return
+
+iToBase62 :: Int -> SDoc
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 ->
- ppChar (C# c) }
+ char (C# c) }
else
case (quotRem n 62) of { (q, I# r#) ->
case (indexCharArray# bytes r#) of { c ->
- ppBeside (iToBase62 q) (ppChar (C# c)) }}
+ (<>) (iToBase62 q) (char (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}
%************************************************************************
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
mkPrimOpIdUnique op = mkUnique '7' op
mkPreludeMiscIdUnique i = mkUnique '8' i
+
+-- The "tyvar uniques" print specially nicely: a, b, c, etc.
+-- See pprUnique for details
+
+initTyVarUnique :: Unique
+initTyVarUnique = mkUnique 't' 0
+
+mkTyVarUnique :: Int -> Unique
+mkTyVarUnique n = mkUnique 't' n
+
+initTidyUniques :: (Unique, Unique) -- Global and local
+initTidyUniques = (mkUnique 'g' 0, mkUnique 'x' 0)
+
+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}
%************************************************************************
%************************************************************************
\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
-evalClassKey = mkPreludeClassUnique 19
-boundedClassKey = mkPreludeClassUnique 20
+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
+allClassKey = mkPreludeClassUnique 22 -- Pseudo class used for universal quantification
\end{code}
%************************************************************************
floatPrimTyConKey = mkPreludeTyConUnique 11
floatTyConKey = mkPreludeTyConUnique 12
funTyConKey = mkPreludeTyConUnique 13
-iOTyConKey = mkPreludeTyConUnique 14
-intPrimTyConKey = mkPreludeTyConUnique 15
-intTyConKey = mkPreludeTyConUnique 16
-integerTyConKey = mkPreludeTyConUnique 17
-liftTyConKey = mkPreludeTyConUnique 18
-listTyConKey = mkPreludeTyConUnique 19
-mallocPtrPrimTyConKey = mkPreludeTyConUnique 20
-mallocPtrTyConKey = mkPreludeTyConUnique 21
-mutableArrayPrimTyConKey = mkPreludeTyConUnique 22
-mutableByteArrayPrimTyConKey = mkPreludeTyConUnique 23
-orderingTyConKey = mkPreludeTyConUnique 24
-synchVarPrimTyConKey = mkPreludeTyConUnique 25
-ratioTyConKey = mkPreludeTyConUnique 26
-rationalTyConKey = mkPreludeTyConUnique 27
-realWorldTyConKey = mkPreludeTyConUnique 28
-return2GMPsTyConKey = mkPreludeTyConUnique 29
-returnIntAndGMPTyConKey = mkPreludeTyConUnique 30
-stablePtrPrimTyConKey = mkPreludeTyConUnique 31
-stablePtrTyConKey = mkPreludeTyConUnique 32
-stateAndAddrPrimTyConKey = mkPreludeTyConUnique 33
-stateAndArrayPrimTyConKey = mkPreludeTyConUnique 34
-stateAndByteArrayPrimTyConKey = mkPreludeTyConUnique 35
-stateAndCharPrimTyConKey = mkPreludeTyConUnique 36
-stateAndDoublePrimTyConKey = mkPreludeTyConUnique 37
-stateAndFloatPrimTyConKey = mkPreludeTyConUnique 38
-stateAndIntPrimTyConKey = mkPreludeTyConUnique 39
-stateAndMallocPtrPrimTyConKey = mkPreludeTyConUnique 40
-stateAndMutableArrayPrimTyConKey = mkPreludeTyConUnique 41
-stateAndMutableByteArrayPrimTyConKey = mkPreludeTyConUnique 42
-stateAndSynchVarPrimTyConKey = mkPreludeTyConUnique 43
-stateAndPtrPrimTyConKey = mkPreludeTyConUnique 44
-stateAndStablePtrPrimTyConKey = mkPreludeTyConUnique 45
-stateAndWordPrimTyConKey = mkPreludeTyConUnique 46
-statePrimTyConKey = mkPreludeTyConUnique 47
-stateTyConKey = mkPreludeTyConUnique 48
-stringTyConKey = mkPreludeTyConUnique 49
-stTyConKey = mkPreludeTyConUnique 50
-primIoTyConKey = mkPreludeTyConUnique 51
-voidPrimTyConKey = mkPreludeTyConUnique 52
-wordPrimTyConKey = mkPreludeTyConUnique 53
-wordTyConKey = mkPreludeTyConUnique 54
+intPrimTyConKey = mkPreludeTyConUnique 14
+intTyConKey = mkPreludeTyConUnique 15
+integerTyConKey = mkPreludeTyConUnique 16
+liftTyConKey = mkPreludeTyConUnique 17
+listTyConKey = mkPreludeTyConUnique 18
+foreignObjPrimTyConKey = mkPreludeTyConUnique 19
+foreignObjTyConKey = mkPreludeTyConUnique 20
+mutableArrayPrimTyConKey = mkPreludeTyConUnique 21
+mutableByteArrayPrimTyConKey = mkPreludeTyConUnique 22
+orderingTyConKey = mkPreludeTyConUnique 23
+synchVarPrimTyConKey = mkPreludeTyConUnique 24
+ratioTyConKey = mkPreludeTyConUnique 25
+rationalTyConKey = mkPreludeTyConUnique 26
+realWorldTyConKey = mkPreludeTyConUnique 27
+return2GMPsTyConKey = mkPreludeTyConUnique 28
+returnIntAndGMPTyConKey = mkPreludeTyConUnique 29
+stablePtrPrimTyConKey = mkPreludeTyConUnique 30
+stablePtrTyConKey = mkPreludeTyConUnique 31
+stateAndAddrPrimTyConKey = mkPreludeTyConUnique 32
+stateAndArrayPrimTyConKey = mkPreludeTyConUnique 33
+stateAndByteArrayPrimTyConKey = mkPreludeTyConUnique 34
+stateAndCharPrimTyConKey = mkPreludeTyConUnique 35
+stateAndDoublePrimTyConKey = mkPreludeTyConUnique 36
+stateAndFloatPrimTyConKey = mkPreludeTyConUnique 37
+stateAndIntPrimTyConKey = mkPreludeTyConUnique 38
+stateAndForeignObjPrimTyConKey = mkPreludeTyConUnique 39
+stateAndMutableArrayPrimTyConKey = mkPreludeTyConUnique 40
+stateAndMutableByteArrayPrimTyConKey = mkPreludeTyConUnique 41
+stateAndSynchVarPrimTyConKey = mkPreludeTyConUnique 42
+stateAndPtrPrimTyConKey = mkPreludeTyConUnique 43
+stateAndStablePtrPrimTyConKey = mkPreludeTyConUnique 44
+stateAndWordPrimTyConKey = mkPreludeTyConUnique 45
+statePrimTyConKey = mkPreludeTyConUnique 46
+stateTyConKey = mkPreludeTyConUnique 47
+mutableByteArrayTyConKey = mkPreludeTyConUnique 48
+stTyConKey = mkPreludeTyConUnique 49
+stRetTyConKey = mkPreludeTyConUnique 50
+ioTyConKey = mkPreludeTyConUnique 51
+ioResultTyConKey = mkPreludeTyConUnique 52
+byteArrayTyConKey = mkPreludeTyConUnique 53
+wordPrimTyConKey = mkPreludeTyConUnique 54
+wordTyConKey = mkPreludeTyConUnique 55
+voidTyConKey = mkPreludeTyConUnique 56
\end{code}
%************************************************************************
integerDataConKey = mkPreludeDataConUnique 12
liftDataConKey = mkPreludeDataConUnique 13
ltDataConKey = mkPreludeDataConUnique 14
-mallocPtrDataConKey = mkPreludeDataConUnique 15
+foreignObjDataConKey = mkPreludeDataConUnique 15
nilDataConKey = mkPreludeDataConUnique 18
ratioDataConKey = mkPreludeDataConUnique 21
return2GMPsDataConKey = mkPreludeDataConUnique 22
stateAndDoublePrimDataConKey = mkPreludeDataConUnique 29
stateAndFloatPrimDataConKey = mkPreludeDataConUnique 30
stateAndIntPrimDataConKey = mkPreludeDataConUnique 31
-stateAndMallocPtrPrimDataConKey = mkPreludeDataConUnique 32
+stateAndForeignObjPrimDataConKey = mkPreludeDataConUnique 32
stateAndMutableArrayPrimDataConKey = mkPreludeDataConUnique 33
stateAndMutableByteArrayPrimDataConKey = mkPreludeDataConUnique 34
stateAndSynchVarPrimDataConKey = mkPreludeDataConUnique 35
stateDataConKey = mkPreludeDataConUnique 39
trueDataConKey = mkPreludeDataConUnique 40
wordDataConKey = mkPreludeDataConUnique 41
+stDataConKey = mkPreludeDataConUnique 42
+stRetDataConKey = mkPreludeDataConUnique 43
+ioDataConKey = mkPreludeDataConUnique 44
+ioOkDataConKey = mkPreludeDataConUnique 45
+ioFailDataConKey = mkPreludeDataConUnique 46
\end{code}
%************************************************************************
\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
+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
+recSelErrIdKey = mkPreludeMiscIdUnique 11
+integerMinusOneIdKey = mkPreludeMiscIdUnique 12
+integerPlusOneIdKey = mkPreludeMiscIdUnique 13
+integerPlusTwoIdKey = mkPreludeMiscIdUnique 14
+integerZeroIdKey = mkPreludeMiscIdUnique 15
+irrefutPatErrorIdKey = mkPreludeMiscIdUnique 16
+lexIdKey = mkPreludeMiscIdUnique 17
+noMethodBindingErrorIdKey = mkPreludeMiscIdUnique 20
+nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 21
+notIdKey = mkPreludeMiscIdUnique 22
+packCStringIdKey = mkPreludeMiscIdUnique 23
+parErrorIdKey = mkPreludeMiscIdUnique 24
+parIdKey = mkPreludeMiscIdUnique 25
+patErrorIdKey = mkPreludeMiscIdUnique 26
+readParenIdKey = mkPreludeMiscIdUnique 27
+realWorldPrimIdKey = 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
+seqIdKey = mkPreludeMiscIdUnique 31
+showParenIdKey = mkPreludeMiscIdUnique 32
+showSpaceIdKey = mkPreludeMiscIdUnique 33
+showStringIdKey = mkPreludeMiscIdUnique 34
+traceIdKey = mkPreludeMiscIdUnique 35
+unpackCString2IdKey = mkPreludeMiscIdUnique 36
+unpackCStringAppendIdKey = mkPreludeMiscIdUnique 37
+unpackCStringFoldrIdKey = mkPreludeMiscIdUnique 38
+unpackCStringIdKey = mkPreludeMiscIdUnique 39
+voidIdKey = mkPreludeMiscIdUnique 40
+ushowListIdKey = mkPreludeMiscIdUnique 41
+ureadListIdKey = mkPreludeMiscIdUnique 42
+
+copyableIdKey = mkPreludeMiscIdUnique 43
+noFollowIdKey = mkPreludeMiscIdUnique 44
+parAtAbsIdKey = mkPreludeMiscIdUnique 45
+parAtForNowIdKey = mkPreludeMiscIdUnique 46
+parAtIdKey = mkPreludeMiscIdUnique 47
+parAtRelIdKey = mkPreludeMiscIdUnique 48
+parGlobalIdKey = mkPreludeMiscIdUnique 49
+parLocalIdKey = mkPreludeMiscIdUnique 50
\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 51
+fromIntegerClassOpKey = mkPreludeMiscIdUnique 52
+minusClassOpKey = mkPreludeMiscIdUnique 53
+fromRationalClassOpKey = mkPreludeMiscIdUnique 54
+enumFromClassOpKey = mkPreludeMiscIdUnique 55
+enumFromThenClassOpKey = mkPreludeMiscIdUnique 56
+enumFromToClassOpKey = mkPreludeMiscIdUnique 57
+enumFromThenToClassOpKey= mkPreludeMiscIdUnique 58
+eqClassOpKey = mkPreludeMiscIdUnique 59
+geClassOpKey = mkPreludeMiscIdUnique 60
+zeroClassOpKey = mkPreludeMiscIdUnique 61
+thenMClassOpKey = mkPreludeMiscIdUnique 62 -- (>>=)
+unboundKey = mkPreludeMiscIdUnique 63 -- Just a place holder for unbound
+ -- variables produced by the renamer
+fromEnumClassOpKey = mkPreludeMiscIdUnique 64
+
+mainKey = mkPreludeMiscIdUnique 65
+returnMClassOpKey = mkPreludeMiscIdUnique 66
+otherwiseIdKey = mkPreludeMiscIdUnique 67
+toEnumClassOpKey = mkPreludeMiscIdUnique 68
+\end{code}
+
+\begin{code}
+inlineIdKey = mkPreludeMiscIdUnique 69
+coerceIdKey = mkPreludeMiscIdUnique 70
+assertIdKey = mkPreludeMiscIdUnique 71
\end{code}
projects / ghc-hetmet.git / blobdiff