137eff14520bbecfd964b8c54e337f22d5d91536
[packages/integer-gmp.git] / GHC / Integer.lhs
1 \begin{code}
2 {-# OPTIONS_GHC -XNoImplicitPrelude #-}
3 {-# OPTIONS_HADDOCK hide #-}
4 -----------------------------------------------------------------------------
5 -- |
6 -- Module      :  GHC.Integer
7 -- Copyright   :  (c) The University of Glasgow 1994-2008
8 -- License     :  see libraries/integer-gmp/LICENSE
9 --
10 -- Maintainer  :  cvs-ghc@haskell.org
11 -- Stability   :  internal
12 -- Portability :  non-portable (GHC Extensions)
13 --
14 -- The 'Integer' type.
15 --
16 -----------------------------------------------------------------------------
17
18 #include "MachDeps.h"
19 #if SIZEOF_HSWORD == 4
20 #define INT_MINBOUND (-2147483648#)
21 #define NEG_INT_MINBOUND (S# 2147483647# `plusInteger` S# 1#)
22 #elif SIZEOF_HSWORD == 8
23 #define INT_MINBOUND (-9223372036854775808#)
24 #define NEG_INT_MINBOUND (S# 9223372036854775807# `plusInteger` S# 1#)
25 #else
26 #error Unknown SIZEOF_HSWORD; can't define INT_MINBOUND and NEG_INT_MINBOUND
27 #endif
28
29 module GHC.Integer (
30     Integer,
31     smallInteger, wordToInteger, integerToWord, toInt#,
32 #if WORD_SIZE_IN_BITS < 64
33     integerToWord64, word64ToInteger,
34     integerToInt64, int64ToInteger,
35 #endif
36     plusInteger, minusInteger, timesInteger, negateInteger,
37     eqInteger, neqInteger, absInteger, signumInteger,
38     leInteger, gtInteger, ltInteger, geInteger, compareInteger,
39     divModInteger, quotRemInteger, quotInteger, remInteger,
40     encodeFloatInteger, decodeFloatInteger, floatFromInteger,
41     encodeDoubleInteger, decodeDoubleInteger, doubleFromInteger,
42     gcdInteger, lcmInteger,
43     andInteger, orInteger, xorInteger, complementInteger,
44     hashInteger,
45  ) where
46
47 import GHC.Prim (
48     -- Other types we use, convert from, or convert to
49     Int#, Word#, Double#, Float#, ByteArray#,
50     -- Conversions between those types
51     int2Word#, int2Double#, int2Float#, word2Int#,
52     -- Operations on Int# that we use for operations on S#
53     quotInt#, remInt#, negateInt#,
54     (==#), (/=#), (<=#), (>=#), (<#), (>#), (*#), (-#), (+#),
55     mulIntMayOflo#, addIntC#, subIntC#, gcdInt#,
56     and#, or#, xor#,
57     indexIntArray#,
58     -- GMP-related primitives in the RTS
59     cmpInteger#, cmpIntegerInt#,
60     plusInteger#, minusInteger#, timesInteger#,
61     quotRemInteger#, quotInteger#, remInteger#, divModInteger#,
62     gcdInteger#, gcdIntegerInt#, divExactInteger#,
63     decodeDouble#, decodeFloat#,
64     int2Integer#, integer2Int#, word2Integer#, integer2Word#,
65     andInteger#, orInteger#, xorInteger#, complementInteger#,
66 #if WORD_SIZE_IN_BITS < 64
67     int64ToInteger#, word64ToInteger#,
68 #endif
69  )
70
71 import GHC.Integer.Internals (Integer(..))
72
73 #if WORD_SIZE_IN_BITS < 64
74 import GHC.IntWord64 (
75             Int64#, Word64#,
76             int64ToWord64#, intToInt64#, integerToWord64#,
77             int64ToInt#, word64ToInt64#, integerToInt64#,
78             geInt64#, leInt64#, leWord64#,
79        )
80 #endif
81
82 import GHC.Bool
83 import GHC.Ordering
84
85 default ()              -- Double isn't available yet,
86                         -- and we shouldn't be using defaults anyway
87 \end{code}
88
89 %*********************************************************
90 %*                                                      *
91 \subsection{The @Integer@ type}
92 %*                                                      *
93 %*********************************************************
94
95 Convenient boxed Integer PrimOps.
96
97 \begin{code}
98 {-# INLINE smallInteger #-}
99 smallInteger :: Int# -> Integer
100 smallInteger i = S# i
101
102 {-# INLINE wordToInteger #-}
103 wordToInteger :: Word# -> Integer
104 wordToInteger w = case word2Integer# w of (# s, d #) -> J# s d
105
106 {-# INLINE integerToWord #-}
107 integerToWord :: Integer -> Word#
108 integerToWord (S# i) = int2Word# i
109 integerToWord (J# s d) = integer2Word# s d
110
111 #if WORD_SIZE_IN_BITS < 64
112 {-# INLINE integerToWord64 #-}
113 integerToWord64 :: Integer -> Word64#
114 integerToWord64 (S# i) = int64ToWord64# (intToInt64# i)
115 integerToWord64 (J# s d) = integerToWord64# s d
116
117 word64ToInteger :: Word64# -> Integer
118 word64ToInteger w = if w `leWord64#` int64ToWord64# (intToInt64# 0x7FFFFFFF#)
119                     then S# (int64ToInt# (word64ToInt64# w))
120                     else case word64ToInteger# w of
121                          (# s, d #) -> J# s d
122
123 integerToInt64 :: Integer -> Int64#
124 integerToInt64 (S# i) = intToInt64# i
125 integerToInt64 (J# s d) = integerToInt64# s d
126
127 int64ToInteger :: Int64# -> Integer
128 int64ToInteger i = if ((i `leInt64#` intToInt64# 0x7FFFFFFF#) && 
129                        (i `geInt64#` intToInt64# -0x80000000#))
130                    then smallInteger (int64ToInt# i)
131                    else case int64ToInteger# i of
132                         (# s, d #) -> J# s d
133     where -- XXX Move the (&&) definition below us?
134           True  && x = x
135           False && _ = False
136 #endif
137
138 toInt# :: Integer -> Int#
139 toInt# (S# i)   = i
140 toInt# (J# s d) = integer2Int# s d
141
142 toBig :: Integer -> Integer
143 toBig (S# i)     = case int2Integer# i of { (# s, d #) -> J# s d }
144 toBig i@(J# _ _) = i
145 \end{code}
146
147
148 %*********************************************************
149 %*                                                      *
150 \subsection{Dividing @Integers@}
151 %*                                                      *
152 %*********************************************************
153
154 \begin{code}
155 -- XXX There's no good reason for us using unboxed tuples for the
156 -- results, but we don't have Data.Tuple available.
157
158 -- Note that we don't check for divide-by-zero here. That needs
159 -- to be done where it's used.
160 -- (we don't have error)
161
162 quotRemInteger :: Integer -> Integer -> (# Integer, Integer #)
163 quotRemInteger a@(S# INT_MINBOUND) b = quotRemInteger (toBig a) b
164 quotRemInteger (S# i) (S# j) = (# S# (i `quotInt#` j), S# (i `remInt#` j) #)
165 quotRemInteger i1@(J# _ _) i2@(S# _) = quotRemInteger i1 (toBig i2)
166 quotRemInteger i1@(S# _) i2@(J# _ _) = quotRemInteger (toBig i1) i2
167 quotRemInteger (J# s1 d1) (J# s2 d2)
168   = case (quotRemInteger# s1 d1 s2 d2) of
169           (# s3, d3, s4, d4 #)
170             -> (# J# s3 d3, J# s4 d4 #)
171
172 divModInteger :: Integer -> Integer -> (# Integer, Integer #)
173 divModInteger a@(S# INT_MINBOUND) b = divModInteger (toBig a) b
174 divModInteger (S# i) (S# j) = (# S# (i `divInt#` j), S# (i `modInt#` j) #)
175     where
176       -- XXX Copied from GHC.Base
177       divInt# :: Int# -> Int# -> Int#
178       x# `divInt#` y#
179        =      if (x# ># 0#) && (y# <# 0#) then ((x# -# 1#) `quotInt#` y#) -# 1#
180          else if (x# <# 0#) && (y# ># 0#) then ((x# +# 1#) `quotInt#` y#) -# 1#
181          else x# `quotInt#` y#
182
183       modInt# :: Int# -> Int# -> Int#
184       x# `modInt#` y#
185        = if ((x# ># 0#) && (y# <# 0#)) ||
186             ((x# <# 0#) && (y# ># 0#))
187          then if r# /=# 0# then r# +# y# else 0#
188          else r#
189           where r# = x# `remInt#` y#
190
191       (&&) :: Bool -> Bool -> Bool
192       True  && x = x
193       False && _ = False
194
195       (||) :: Bool -> Bool -> Bool
196       True  || _ = True
197       False || x = x
198 divModInteger i1@(J# _ _) i2@(S# _) = divModInteger i1 (toBig i2)
199 divModInteger i1@(S# _) i2@(J# _ _) = divModInteger (toBig i1) i2
200 divModInteger (J# s1 d1) (J# s2 d2)
201   = case (divModInteger# s1 d1 s2 d2) of
202           (# s3, d3, s4, d4 #)
203             -> (# J# s3 d3, J# s4 d4 #)
204
205 remInteger :: Integer -> Integer -> Integer
206 remInteger a@(S# INT_MINBOUND) b = remInteger (toBig a) b
207 remInteger (S# a) (S# b) = S# (remInt# a b)
208 {- Special case doesn't work, because a 1-element J# has the range
209    -(2^32-1) -- 2^32-1, whereas S# has the range -2^31 -- (2^31-1)
210 remInteger ia@(S# a) (J# sb b)
211   | sb ==# 1#  = S# (remInt# a (word2Int# (integer2Word# sb b)))
212   | sb ==# -1# = S# (remInt# a (0# -# (word2Int# (integer2Word# sb b))))
213   | 0# <# sb   = ia
214   | otherwise  = S# (0# -# a)
215 -}
216 remInteger ia@(S# _) ib@(J# _ _) = remInteger (toBig ia) ib
217 remInteger (J# sa a) (S# b)
218   = case int2Integer# b of { (# sb, b' #) ->
219     case remInteger# sa a sb b' of { (# sr, r #) ->
220     S# (integer2Int# sr r) }}
221 remInteger (J# sa a) (J# sb b)
222   = case remInteger# sa a sb b of (# sr, r #) -> J# sr r
223
224 quotInteger :: Integer -> Integer -> Integer
225 quotInteger a@(S# INT_MINBOUND) b = quotInteger (toBig a) b
226 quotInteger (S# a) (S# b) = S# (quotInt# a b)
227 {- Special case disabled, see remInteger above
228 quotInteger (S# a) (J# sb b)
229   | sb ==# 1#  = S# (quotInt# a (word2Int# (integer2Word# sb b)))
230   | sb ==# -1# = S# (quotInt# a (0# -# (word2Int# (integer2Word# sb b))))
231   | otherwise  = S# 0
232 -}
233 quotInteger ia@(S# _) ib@(J# _ _) = quotInteger (toBig ia) ib
234 quotInteger (J# sa a) (S# b)
235   = case int2Integer# b of { (# sb, b' #) ->
236     case quotInteger# sa a sb b' of (# sq, q #) -> J# sq q }
237 quotInteger (J# sa a) (J# sb b)
238   = case quotInteger# sa a sb b of (# sg, g #) -> J# sg g
239 \end{code}
240
241
242
243 \begin{code}
244 -- We can't throw an error here, so it is up to our caller to
245 -- not call us with both arguments being 0.
246 gcdInteger :: Integer -> Integer -> Integer
247 -- SUP: Do we really need the first two cases?
248 gcdInteger a@(S# INT_MINBOUND) b = gcdInteger (toBig a) b
249 gcdInteger a b@(S# INT_MINBOUND) = gcdInteger a (toBig b)
250 gcdInteger (S# a) (S# b) = S# (gcdInt a b)
251     where -- XXX Copied from GHC.Base
252           gcdInt :: Int# -> Int# -> Int#
253           gcdInt 0# y  = absInt y
254           gcdInt x  0# = absInt x
255           gcdInt x  y  = gcdInt# (absInt x) (absInt y)
256
257           absInt x = if x <# 0# then negateInt# x else x
258 gcdInteger ia@(S# a)  ib@(J# sb b)
259  =      if a  ==# 0# then absInteger ib
260    else if sb ==# 0# then absInteger ia
261    else                   S# (gcdIntegerInt# absSb b absA)
262        where absA  = if a  <# 0# then negateInt# a  else a
263              absSb = if sb <# 0# then negateInt# sb else sb
264 gcdInteger ia@(J# _ _) ib@(S# _) = gcdInteger ib ia
265 gcdInteger (J# sa a) (J# sb b)
266   = case gcdInteger# sa a sb b of (# sg, g #) -> J# sg g
267
268 lcmInteger :: Integer -> Integer -> Integer
269 lcmInteger a b =      if a `eqInteger` S# 0# then S# 0#
270                  else if b `eqInteger` S# 0# then S# 0#
271                  else (divExact aa (gcdInteger aa ab)) `timesInteger` ab
272   where aa = absInteger a
273         ab = absInteger b
274
275 divExact :: Integer -> Integer -> Integer
276 divExact a@(S# INT_MINBOUND) b = divExact (toBig a) b
277 divExact (S# a) (S# b) = S# (quotInt# a b)
278 divExact (S# a) (J# sb b)
279   = S# (quotInt# a (integer2Int# sb b))
280 divExact (J# sa a) (S# b)
281   = case int2Integer# b of
282     (# sb, b' #) -> case divExactInteger# sa a sb b' of
283                     (# sd, d #) -> J# sd d
284 divExact (J# sa a) (J# sb b)
285   = case divExactInteger# sa a sb b of (# sd, d #) -> J# sd d
286 \end{code}
287
288
289 %*********************************************************
290 %*                                                      *
291 \subsection{The @Integer@ instances for @Eq@, @Ord@}
292 %*                                                      *
293 %*********************************************************
294
295 \begin{code}
296 eqInteger :: Integer -> Integer -> Bool
297 eqInteger (S# i)     (S# j)     = i ==# j
298 eqInteger (S# i)     (J# s d)   = cmpIntegerInt# s d i ==# 0#
299 eqInteger (J# s d)   (S# i)     = cmpIntegerInt# s d i ==# 0#
300 eqInteger (J# s1 d1) (J# s2 d2) = (cmpInteger# s1 d1 s2 d2) ==# 0#
301
302 neqInteger :: Integer -> Integer -> Bool
303 neqInteger (S# i)     (S# j)     = i /=# j
304 neqInteger (S# i)     (J# s d)   = cmpIntegerInt# s d i /=# 0#
305 neqInteger (J# s d)   (S# i)     = cmpIntegerInt# s d i /=# 0#
306 neqInteger (J# s1 d1) (J# s2 d2) = (cmpInteger# s1 d1 s2 d2) /=# 0#
307
308 ------------------------------------------------------------------------
309
310 leInteger :: Integer -> Integer -> Bool
311 leInteger (S# i)     (S# j)     = i <=# j
312 leInteger (J# s d)   (S# i)     = cmpIntegerInt# s d i <=# 0#
313 leInteger (S# i)     (J# s d)   = cmpIntegerInt# s d i >=# 0#
314 leInteger (J# s1 d1) (J# s2 d2) = (cmpInteger# s1 d1 s2 d2) <=# 0#
315
316 gtInteger :: Integer -> Integer -> Bool
317 gtInteger (S# i)     (S# j)     = i ># j
318 gtInteger (J# s d)   (S# i)     = cmpIntegerInt# s d i ># 0#
319 gtInteger (S# i)     (J# s d)   = cmpIntegerInt# s d i <# 0#
320 gtInteger (J# s1 d1) (J# s2 d2) = (cmpInteger# s1 d1 s2 d2) ># 0#
321
322 ltInteger :: Integer -> Integer -> Bool
323 ltInteger (S# i)     (S# j)     = i <# j
324 ltInteger (J# s d)   (S# i)     = cmpIntegerInt# s d i <# 0#
325 ltInteger (S# i)     (J# s d)   = cmpIntegerInt# s d i ># 0#
326 ltInteger (J# s1 d1) (J# s2 d2) = (cmpInteger# s1 d1 s2 d2) <# 0#
327
328 geInteger :: Integer -> Integer -> Bool
329 geInteger (S# i)     (S# j)     = i >=# j
330 geInteger (J# s d)   (S# i)     = cmpIntegerInt# s d i >=# 0#
331 geInteger (S# i)     (J# s d)   = cmpIntegerInt# s d i <=# 0#
332 geInteger (J# s1 d1) (J# s2 d2) = (cmpInteger# s1 d1 s2 d2) >=# 0#
333
334 compareInteger :: Integer -> Integer -> Ordering
335 compareInteger (S# i)  (S# j)
336    =      if i ==# j then EQ
337      else if i <=# j then LT
338      else                 GT
339 compareInteger (J# s d) (S# i)
340    = case cmpIntegerInt# s d i of { res# ->
341      if res# <# 0# then LT else
342      if res# ># 0# then GT else EQ
343      }
344 compareInteger (S# i) (J# s d)
345    = case cmpIntegerInt# s d i of { res# ->
346      if res# ># 0# then LT else
347      if res# <# 0# then GT else EQ
348      }
349 compareInteger (J# s1 d1) (J# s2 d2)
350    = case cmpInteger# s1 d1 s2 d2 of { res# ->
351      if res# <# 0# then LT else
352      if res# ># 0# then GT else EQ
353      }
354 \end{code}
355
356
357 %*********************************************************
358 %*                                                      *
359 \subsection{The @Integer@ instances for @Num@}
360 %*                                                      *
361 %*********************************************************
362
363 \begin{code}
364 {-# INLINE absInteger #-}
365 absInteger :: Integer -> Integer
366 absInteger (S# INT_MINBOUND) = NEG_INT_MINBOUND
367 absInteger n@(S# i) = if i >=# 0# then n else S# (negateInt# i)
368 absInteger n@(J# s d) = if (s >=# 0#) then n else J# (negateInt# s) d
369
370 signumInteger :: Integer -> Integer
371 signumInteger (S# i) = if i <# 0# then S# -1#
372                        else if i ==# 0# then S# 0#
373                        else S# 1#
374 signumInteger (J# s d)
375   = let
376         cmp = cmpIntegerInt# s d 0#
377     in
378     if      cmp >#  0# then S# 1#
379     else if cmp ==# 0# then S# 0#
380     else                    S# (negateInt# 1#)
381
382 plusInteger :: Integer -> Integer -> Integer
383 plusInteger i1@(S# i) i2@(S# j)  = case addIntC# i j of
384                                    (# r, c #) ->
385                                        if c ==# 0#
386                                        then S# r
387                                        else plusInteger (toBig i1) (toBig i2)
388 plusInteger i1@(J# _ _) i2@(S# _) = plusInteger i1 (toBig i2)
389 plusInteger i1@(S# _) i2@(J# _ _) = plusInteger (toBig i1) i2
390 plusInteger (J# s1 d1) (J# s2 d2) = case plusInteger# s1 d1 s2 d2 of
391                                     (# s, d #) -> J# s d
392
393 minusInteger :: Integer -> Integer -> Integer
394 minusInteger i1@(S# i) i2@(S# j)   = case subIntC# i j of
395                                      (# r, c #) ->
396                                          if c ==# 0# then S# r
397                                          else minusInteger (toBig i1)
398                                                            (toBig i2)
399 minusInteger i1@(J# _ _) i2@(S# _) = minusInteger i1 (toBig i2)
400 minusInteger i1@(S# _) i2@(J# _ _) = minusInteger (toBig i1) i2
401 minusInteger (J# s1 d1) (J# s2 d2) = case minusInteger# s1 d1 s2 d2 of
402                                      (# s, d #) -> J# s d
403
404 timesInteger :: Integer -> Integer -> Integer
405 timesInteger i1@(S# i) i2@(S# j)   = if mulIntMayOflo# i j ==# 0#
406                                      then S# (i *# j)
407                                      else timesInteger (toBig i1) (toBig i2)
408 timesInteger i1@(J# _ _) i2@(S# _) = timesInteger i1 (toBig i2)
409 timesInteger i1@(S# _) i2@(J# _ _) = timesInteger (toBig i1) i2
410 timesInteger (J# s1 d1) (J# s2 d2) = case timesInteger# s1 d1 s2 d2 of
411                                      (# s, d #) -> J# s d
412
413 negateInteger :: Integer -> Integer
414 negateInteger (S# INT_MINBOUND) = NEG_INT_MINBOUND
415 negateInteger (S# i)            = S# (negateInt# i)
416 negateInteger (J# s d)          = J# (negateInt# s) d
417 \end{code}
418
419
420 %*********************************************************
421 %*                                                      *
422 \subsection{The @Integer@ stuff for Double@}
423 %*                                                      *
424 %*********************************************************
425
426 \begin{code}
427 encodeFloatInteger :: Integer -> Int# -> Float#
428 encodeFloatInteger (S# i) j     = int_encodeFloat# i j
429 encodeFloatInteger (J# s# d#) e = encodeFloat# s# d# e
430
431 decodeFloatInteger :: Float# -> (# Integer, Int# #)
432 decodeFloatInteger d = case decodeFloat# d of
433                        (# exp#, s#, d# #) -> (# J# s# d#, exp# #)
434
435 encodeDoubleInteger :: Integer -> Int# -> Double#
436 encodeDoubleInteger (S# i) j     = int_encodeDouble# i j
437 encodeDoubleInteger (J# s# d#) e = encodeDouble# s# d# e
438
439 decodeDoubleInteger :: Double# -> (# Integer, Int# #)
440 decodeDoubleInteger d = case decodeDouble# d of
441                         (# exp#, s#, d# #) -> (# J# s# d#, exp# #)
442
443 -- previous code: doubleFromInteger n = fromInteger n = encodeFloat n 0
444 -- doesn't work too well, because encodeFloat is defined in
445 -- terms of ccalls which can never be simplified away.  We
446 -- want simple literals like (fromInteger 3 :: Float) to turn
447 -- into (F# 3.0), hence the special case for S# here.
448
449 doubleFromInteger :: Integer -> Double#
450 doubleFromInteger (S# i#) = int2Double# i#
451 doubleFromInteger (J# s# d#) = encodeDouble# s# d# 0#
452
453 floatFromInteger :: Integer -> Float#
454 floatFromInteger (S# i#) = int2Float# i#
455 floatFromInteger (J# s# d#) = encodeFloat# s# d# 0#
456
457 foreign import ccall unsafe "__encodeFloat"
458         encodeFloat# :: Int# -> ByteArray# -> Int# -> Float#
459 foreign import ccall unsafe "__int_encodeFloat"
460         int_encodeFloat# :: Int# -> Int# -> Float#
461
462 foreign import ccall unsafe "__encodeDouble"
463         encodeDouble# :: Int# -> ByteArray# -> Int# -> Double#
464 foreign import ccall unsafe "__int_encodeDouble"
465         int_encodeDouble# :: Int# -> Int# -> Double#
466 \end{code}
467
468 %*********************************************************
469 %*                                                      *
470 \subsection{The @Integer@ Bit definitions@}
471 %*                                                      *
472 %*********************************************************
473
474 \begin{code}
475 andInteger :: Integer -> Integer -> Integer
476 (S# x) `andInteger` (S# y) = S# (word2Int# (int2Word# x `and#` int2Word# y))
477 x@(S# _) `andInteger` y = toBig x `andInteger` y
478 x `andInteger` y@(S# _) = x `andInteger` toBig y
479 (J# s1 d1) `andInteger` (J# s2 d2) =
480      case andInteger# s1 d1 s2 d2 of
481        (# s, d #) -> J# s d
482
483 orInteger :: Integer -> Integer -> Integer
484 (S# x) `orInteger` (S# y) = S# (word2Int# (int2Word# x `or#` int2Word# y))
485 x@(S# _) `orInteger` y = toBig x `orInteger` y
486 x `orInteger` y@(S# _) = x `orInteger` toBig y
487 (J# s1 d1) `orInteger` (J# s2 d2) =
488      case orInteger# s1 d1 s2 d2 of
489        (# s, d #) -> J# s d
490
491 xorInteger :: Integer -> Integer -> Integer
492 (S# x) `xorInteger` (S# y) = S# (word2Int# (int2Word# x `xor#` int2Word# y))
493 x@(S# _) `xorInteger` y = toBig x `xorInteger` y
494 x `xorInteger` y@(S# _) = x `xorInteger` toBig y
495 (J# s1 d1) `xorInteger` (J# s2 d2) =
496      case xorInteger# s1 d1 s2 d2 of
497        (# s, d #) -> J# s d
498
499 complementInteger :: Integer -> Integer
500 complementInteger (S# x)
501     = S# (word2Int# (int2Word# x `xor#` int2Word# (0# -# 1#)))
502 complementInteger (J# s d)
503     = case complementInteger# s d of (# s', d' #) -> J# s' d'
504 \end{code}
505
506 %*********************************************************
507 %*                                                      *
508 \subsection{The @Integer@ hashing@}
509 %*                                                      *
510 %*********************************************************
511
512 \begin{code}
513 -- This is used by hashUnique
514
515 hashInteger :: Integer -> Int#
516 hashInteger (S# i) = i
517 hashInteger (J# s d) = if s ==# 0#
518                        then 0#
519                        else indexIntArray# d 0#
520 \end{code}
521