2 % (c) The University of Glasgow, 1997-2001
4 \section[PrelInt]{Module @PrelInt@}
10 Int8(..), Int16(..), Int32(..), Int64(..))
22 ------------------------------------------------------------------------
24 ------------------------------------------------------------------------
26 -- Int8 is represented in the same way as Int. Operations may assume
27 -- and must ensure that it holds only values from its logical range.
29 data Int8 = I8# Int# deriving (Eq, Ord)
31 instance CCallable Int8
32 instance CReturnable Int8
34 instance Show Int8 where
35 showsPrec p x = showsPrec p (fromIntegral x :: Int)
37 instance Num Int8 where
38 (I8# x#) + (I8# y#) = I8# (intToInt8# (x# +# y#))
39 (I8# x#) - (I8# y#) = I8# (intToInt8# (x# -# y#))
40 (I8# x#) * (I8# y#) = I8# (intToInt8# (x# *# y#))
41 negate (I8# x#) = I8# (intToInt8# (negateInt# x#))
43 | otherwise = negate x
47 fromInteger (S# i#) = I8# (intToInt8# i#)
48 fromInteger (J# s# d#) = I8# (intToInt8# (integer2Int# s# d#))
50 instance Real Int8 where
51 toRational x = toInteger x % 1
53 instance Enum Int8 where
55 | x /= maxBound = x + 1
56 | otherwise = succError "Int8"
58 | x /= minBound = x - 1
59 | otherwise = predError "Int8"
61 | i >= fromIntegral (minBound::Int8) && i <= fromIntegral (maxBound::Int8)
63 | otherwise = toEnumError "Int8" i (minBound::Int8, maxBound::Int8)
64 fromEnum (I8# x#) = I# x#
65 enumFrom = boundedEnumFrom
66 enumFromThen = boundedEnumFromThen
68 instance Integral Int8 where
69 quot x@(I8# x#) y@(I8# y#)
70 | y /= 0 = I8# (intToInt8# (x# `quotInt#` y#))
71 | otherwise = divZeroError "quot{Int8}" x
72 rem x@(I8# x#) y@(I8# y#)
73 | y /= 0 = I8# (intToInt8# (x# `remInt#` y#))
74 | otherwise = divZeroError "rem{Int8}" x
75 div x@(I8# x#) y@(I8# y#)
76 | y /= 0 = I8# (intToInt8# (x# `divInt#` y#))
77 | otherwise = divZeroError "div{Int8}" x
78 mod x@(I8# x#) y@(I8# y#)
79 | y /= 0 = I8# (intToInt8# (x# `modInt#` y#))
80 | otherwise = divZeroError "mod{Int8}" x
81 quotRem x@(I8# x#) y@(I8# y#)
82 | y /= 0 = (I8# (intToInt8# (x# `quotInt#` y#)),
83 I8# (intToInt8# (x# `remInt#` y#)))
84 | otherwise = divZeroError "quotRem{Int8}" x
85 divMod x@(I8# x#) y@(I8# y#)
86 | y /= 0 = (I8# (intToInt8# (x# `divInt#` y#)),
87 I8# (intToInt8# (x# `modInt#` y#)))
88 | otherwise = divZeroError "divMod{Int8}" x
89 toInteger (I8# x#) = S# x#
91 instance Bounded Int8 where
95 instance Ix Int8 where
98 | inRange b i = fromIntegral (i - m)
99 | otherwise = indexError b i "Int8"
100 inRange (m,n) i = m <= i && i <= n
102 instance Read Int8 where
103 readsPrec p s = [(fromIntegral (x::Int), r) | (x, r) <- readsPrec p s]
105 instance Bits Int8 where
106 (I8# x#) .&. (I8# y#) = I8# (word2Int# (int2Word# x# `and#` int2Word# y#))
107 (I8# x#) .|. (I8# y#) = I8# (word2Int# (int2Word# x# `or#` int2Word# y#))
108 (I8# x#) `xor` (I8# y#) = I8# (word2Int# (int2Word# x# `xor#` int2Word# y#))
109 complement (I8# x#) = I8# (word2Int# (int2Word# x# `xor#` int2Word# (-1#)))
110 (I8# x#) `shift` (I# i#)
111 | i# >=# 0# = I8# (intToInt8# (x# `iShiftL#` i#))
112 | otherwise = I8# (x# `iShiftRA#` negateInt# i#)
113 (I8# x#) `rotate` (I# i#) =
114 I8# (intToInt8# (word2Int# ((x'# `shiftL#` i'#) `or#`
115 (x'# `shiftRL#` (8# -# i'#)))))
117 x'# = wordToWord8# (int2Word# x#)
118 i'# = word2Int# (int2Word# i# `and#` int2Word# 7#)
123 "fromIntegral/Int8->Int8" fromIntegral = id :: Int8 -> Int8
124 "fromIntegral/a->Int8" fromIntegral = \x -> case fromIntegral x of I# x# -> I8# (intToInt8# x#)
125 "fromIntegral/Int8->a" fromIntegral = \(I8# x#) -> fromIntegral (I# x#)
128 ------------------------------------------------------------------------
130 ------------------------------------------------------------------------
132 -- Int16 is represented in the same way as Int. Operations may assume
133 -- and must ensure that it holds only values from its logical range.
135 data Int16 = I16# Int# deriving (Eq, Ord)
137 instance CCallable Int16
138 instance CReturnable Int16
140 instance Show Int16 where
141 showsPrec p x = showsPrec p (fromIntegral x :: Int)
143 instance Num Int16 where
144 (I16# x#) + (I16# y#) = I16# (intToInt16# (x# +# y#))
145 (I16# x#) - (I16# y#) = I16# (intToInt16# (x# -# y#))
146 (I16# x#) * (I16# y#) = I16# (intToInt16# (x# *# y#))
147 negate (I16# x#) = I16# (intToInt16# (negateInt# x#))
149 | otherwise = negate x
153 fromInteger (S# i#) = I16# (intToInt16# i#)
154 fromInteger (J# s# d#) = I16# (intToInt16# (integer2Int# s# d#))
156 instance Real Int16 where
157 toRational x = toInteger x % 1
159 instance Enum Int16 where
161 | x /= maxBound = x + 1
162 | otherwise = succError "Int16"
164 | x /= minBound = x - 1
165 | otherwise = predError "Int16"
167 | i >= fromIntegral (minBound::Int16) && i <= fromIntegral (maxBound::Int16)
169 | otherwise = toEnumError "Int16" i (minBound::Int16, maxBound::Int16)
170 fromEnum (I16# x#) = I# x#
171 enumFrom = boundedEnumFrom
172 enumFromThen = boundedEnumFromThen
174 instance Integral Int16 where
175 quot x@(I16# x#) y@(I16# y#)
176 | y /= 0 = I16# (intToInt16# (x# `quotInt#` y#))
177 | otherwise = divZeroError "quot{Int16}" x
178 rem x@(I16# x#) y@(I16# y#)
179 | y /= 0 = I16# (intToInt16# (x# `remInt#` y#))
180 | otherwise = divZeroError "rem{Int16}" x
181 div x@(I16# x#) y@(I16# y#)
182 | y /= 0 = I16# (intToInt16# (x# `divInt#` y#))
183 | otherwise = divZeroError "div{Int16}" x
184 mod x@(I16# x#) y@(I16# y#)
185 | y /= 0 = I16# (intToInt16# (x# `modInt#` y#))
186 | otherwise = divZeroError "mod{Int16}" x
187 quotRem x@(I16# x#) y@(I16# y#)
188 | y /= 0 = (I16# (intToInt16# (x# `quotInt#` y#)),
189 I16# (intToInt16# (x# `remInt#` y#)))
190 | otherwise = divZeroError "quotRem{Int16}" x
191 divMod x@(I16# x#) y@(I16# y#)
192 | y /= 0 = (I16# (intToInt16# (x# `divInt#` y#)),
193 I16# (intToInt16# (x# `modInt#` y#)))
194 | otherwise = divZeroError "divMod{Int16}" x
195 toInteger (I16# x#) = S# x#
197 instance Bounded Int16 where
201 instance Ix Int16 where
204 | inRange b i = fromIntegral (i - m)
205 | otherwise = indexError b i "Int16"
206 inRange (m,n) i = m <= i && i <= n
208 instance Read Int16 where
209 readsPrec p s = [(fromIntegral (x::Int), r) | (x, r) <- readsPrec p s]
211 instance Bits Int16 where
212 (I16# x#) .&. (I16# y#) = I16# (word2Int# (int2Word# x# `and#` int2Word# y#))
213 (I16# x#) .|. (I16# y#) = I16# (word2Int# (int2Word# x# `or#` int2Word# y#))
214 (I16# x#) `xor` (I16# y#) = I16# (word2Int# (int2Word# x# `xor#` int2Word# y#))
215 complement (I16# x#) = I16# (word2Int# (int2Word# x# `xor#` int2Word# (-1#)))
216 (I16# x#) `shift` (I# i#)
217 | i# >=# 0# = I16# (intToInt16# (x# `iShiftL#` i#))
218 | otherwise = I16# (x# `iShiftRA#` negateInt# i#)
219 (I16# x#) `rotate` (I# i#) =
220 I16# (intToInt16# (word2Int# ((x'# `shiftL#` i'#) `or#`
221 (x'# `shiftRL#` (16# -# i'#)))))
223 x'# = wordToWord16# (int2Word# x#)
224 i'# = word2Int# (int2Word# i# `and#` int2Word# 15#)
229 "fromIntegral/Word8->Int16" fromIntegral = \(W8# x#) -> I16# (word2Int# x#)
230 "fromIntegral/Int8->Int16" fromIntegral = \(I8# x#) -> I16# x#
231 "fromIntegral/Int16->Int16" fromIntegral = id :: Int16 -> Int16
232 "fromIntegral/a->Int16" fromIntegral = \x -> case fromIntegral x of I# x# -> I16# (intToInt16# x#)
233 "fromIntegral/Int16->a" fromIntegral = \(I16# x#) -> fromIntegral (I# x#)
236 ------------------------------------------------------------------------
238 ------------------------------------------------------------------------
240 -- Int32 is represented in the same way as Int.
241 #if WORD_SIZE_IN_BYTES == 8
242 -- Operations may assume and must ensure that it holds only values
243 -- from its logical range.
246 data Int32 = I32# Int# deriving (Eq, Ord)
248 instance CCallable Int32
249 instance CReturnable Int32
251 instance Show Int32 where
252 showsPrec p x = showsPrec p (fromIntegral x :: Int)
254 instance Num Int32 where
255 (I32# x#) + (I32# y#) = I32# (intToInt32# (x# +# y#))
256 (I32# x#) - (I32# y#) = I32# (intToInt32# (x# -# y#))
257 (I32# x#) * (I32# y#) = I32# (intToInt32# (x# *# y#))
258 negate (I32# x#) = I32# (intToInt32# (negateInt# x#))
260 | otherwise = negate x
264 fromInteger (S# i#) = I32# (intToInt32# i#)
265 fromInteger (J# s# d#) = I32# (intToInt32# (integer2Int# s# d#))
267 instance Real Int32 where
268 toRational x = toInteger x % 1
270 instance Enum Int32 where
272 | x /= maxBound = x + 1
273 | otherwise = succError "Int32"
275 | x /= minBound = x - 1
276 | otherwise = predError "Int32"
277 #if WORD_SIZE_IN_BYTES == 4
278 toEnum (I# i#) = I32# i#
281 | i >= fromIntegral (minBound::Int32) && i <= fromIntegral (maxBound::Int32)
283 | otherwise = toEnumError "Int32" i (minBound::Int32, maxBound::Int32)
285 fromEnum (I32# x#) = I# x#
286 enumFrom = boundedEnumFrom
287 enumFromThen = boundedEnumFromThen
289 instance Integral Int32 where
290 quot x@(I32# x#) y@(I32# y#)
291 | y /= 0 = I32# (intToInt32# (x# `quotInt#` y#))
292 | otherwise = divZeroError "quot{Int32}" x
293 rem x@(I32# x#) y@(I32# y#)
294 | y /= 0 = I32# (intToInt32# (x# `remInt#` y#))
295 | otherwise = divZeroError "rem{Int32}" x
296 div x@(I32# x#) y@(I32# y#)
297 | y /= 0 = I32# (intToInt32# (x# `divInt#` y#))
298 | otherwise = divZeroError "div{Int32}" x
299 mod x@(I32# x#) y@(I32# y#)
300 | y /= 0 = I32# (intToInt32# (x# `modInt#` y#))
301 | otherwise = divZeroError "mod{Int32}" x
302 quotRem x@(I32# x#) y@(I32# y#)
303 | y /= 0 = (I32# (intToInt32# (x# `quotInt#` y#)),
304 I32# (intToInt32# (x# `remInt#` y#)))
305 | otherwise = divZeroError "quotRem{Int32}" x
306 divMod x@(I32# x#) y@(I32# y#)
307 | y /= 0 = (I32# (intToInt32# (x# `divInt#` y#)),
308 I32# (intToInt32# (x# `modInt#` y#)))
309 | otherwise = divZeroError "divMod{Int32}" x
310 toInteger (I32# x#) = S# x#
312 instance Bounded Int32 where
313 minBound = -0x80000000
314 maxBound = 0x7FFFFFFF
316 instance Ix Int32 where
319 | inRange b i = fromIntegral (i - m)
320 | otherwise = indexError b i "Int32"
321 inRange (m,n) i = m <= i && i <= n
323 instance Read Int32 where
324 readsPrec p s = [(fromIntegral (x::Int), r) | (x, r) <- readsPrec p s]
326 instance Bits Int32 where
327 (I32# x#) .&. (I32# y#) = I32# (word2Int# (int2Word# x# `and#` int2Word# y#))
328 (I32# x#) .|. (I32# y#) = I32# (word2Int# (int2Word# x# `or#` int2Word# y#))
329 (I32# x#) `xor` (I32# y#) = I32# (word2Int# (int2Word# x# `xor#` int2Word# y#))
330 complement (I32# x#) = I32# (word2Int# (int2Word# x# `xor#` int2Word# (-1#)))
331 (I32# x#) `shift` (I# i#)
332 | i# >=# 0# = I32# (intToInt32# (x# `iShiftL#` i#))
333 | otherwise = I32# (x# `iShiftRA#` negateInt# i#)
334 (I32# x#) `rotate` (I# i#) =
335 I32# (intToInt32# (word2Int# ((x'# `shiftL#` i'#) `or#`
336 (x'# `shiftRL#` (32# -# i'#)))))
338 x'# = wordToWord32# (int2Word# x#)
339 i'# = word2Int# (int2Word# i# `and#` int2Word# 31#)
344 "fromIntegral/Word8->Int32" fromIntegral = \(W8# x#) -> I32# (word2Int# x#)
345 "fromIntegral/Word16->Int32" fromIntegral = \(W16# x#) -> I32# (word2Int# x#)
346 "fromIntegral/Int8->Int32" fromIntegral = \(I8# x#) -> I32# x#
347 "fromIntegral/Int16->Int32" fromIntegral = \(I16# x#) -> I32# x#
348 "fromIntegral/Int32->Int32" fromIntegral = id :: Int32 -> Int32
349 "fromIntegral/a->Int32" fromIntegral = \x -> case fromIntegral x of I# x# -> I32# (intToInt32# x#)
350 "fromIntegral/Int32->a" fromIntegral = \(I32# x#) -> fromIntegral (I# x#)
353 ------------------------------------------------------------------------
355 ------------------------------------------------------------------------
357 #if WORD_SIZE_IN_BYTES == 4
359 data Int64 = I64# Int64#
361 instance Eq Int64 where
362 (I64# x#) == (I64# y#) = x# `eqInt64#` y#
363 (I64# x#) /= (I64# y#) = x# `neInt64#` y#
365 instance Ord Int64 where
366 (I64# x#) < (I64# y#) = x# `ltInt64#` y#
367 (I64# x#) <= (I64# y#) = x# `leInt64#` y#
368 (I64# x#) > (I64# y#) = x# `gtInt64#` y#
369 (I64# x#) >= (I64# y#) = x# `geInt64#` y#
371 instance Show Int64 where
372 showsPrec p x = showsPrec p (toInteger x)
374 instance Num Int64 where
375 (I64# x#) + (I64# y#) = I64# (x# `plusInt64#` y#)
376 (I64# x#) - (I64# y#) = I64# (x# `minusInt64#` y#)
377 (I64# x#) * (I64# y#) = I64# (x# `timesInt64#` y#)
378 negate (I64# x#) = I64# (negateInt64# x#)
380 | otherwise = negate x
384 fromInteger (S# i#) = I64# (intToInt64# i#)
385 fromInteger (J# s# d#) = I64# (integerToInt64# s# d#)
387 instance Enum Int64 where
389 | x /= maxBound = x + 1
390 | otherwise = succError "Int64"
392 | x /= minBound = x - 1
393 | otherwise = predError "Int64"
394 toEnum (I# i#) = I64# (intToInt64# i#)
396 | x >= fromIntegral (minBound::Int) && x <= fromIntegral (maxBound::Int)
397 = I# (int64ToInt# x#)
398 | otherwise = fromEnumError "Int64" x
399 enumFrom = integralEnumFrom
400 enumFromThen = integralEnumFromThen
401 enumFromTo = integralEnumFromTo
402 enumFromThenTo = integralEnumFromThenTo
404 instance Integral Int64 where
405 quot x@(I64# x#) y@(I64# y#)
406 | y /= 0 = I64# (x# `quotInt64#` y#)
407 | otherwise = divZeroError "quot{Int64}" x
408 rem x@(I64# x#) y@(I64# y#)
409 | y /= 0 = I64# (x# `remInt64#` y#)
410 | otherwise = divZeroError "rem{Int64}" x
411 div x@(I64# x#) y@(I64# y#)
412 | y /= 0 = I64# (x# `divInt64#` y#)
413 | otherwise = divZeroError "div{Int64}" x
414 mod x@(I64# x#) y@(I64# y#)
415 | y /= 0 = I64# (x# `modInt64#` y#)
416 | otherwise = divZeroError "mod{Int64}" x
417 quotRem x@(I64# x#) y@(I64# y#)
418 | y /= 0 = (I64# (x# `quotInt64#` y#), I64# (x# `remInt64#` y#))
419 | otherwise = divZeroError "quotRem{Int64}" x
420 divMod x@(I64# x#) y@(I64# y#)
421 | y /= 0 = (I64# (x# `divInt64#` y#), I64# (x# `modInt64#` y#))
422 | otherwise = divZeroError "divMod{Int64}" x
423 toInteger x@(I64# x#)
424 | x >= -0x80000000 && x <= 0x7FFFFFFF
425 = S# (int64ToInt# x#)
426 | otherwise = case int64ToInteger# x# of (# s, d #) -> J# s d
428 divInt64#, modInt64# :: Int64# -> Int64# -> Int64#
430 | (x# `gtInt64#` intToInt64# 0#) && (y# `ltInt64#` intToInt64# 0#)
431 = ((x# `minusInt64#` y#) `minusInt64#` intToInt64# 1#) `quotInt64#` y#
432 | (x# `ltInt64#` intToInt64# 0#) && (y# `gtInt64#` intToInt64# 0#)
433 = ((x# `minusInt64#` y#) `plusInt64#` intToInt64# 1#) `quotInt64#` y#
434 | otherwise = x# `quotInt64#` y#
436 | (x# `gtInt64#` intToInt64# 0#) && (y# `ltInt64#` intToInt64# 0#) ||
437 (x# `ltInt64#` intToInt64# 0#) && (y# `gtInt64#` intToInt64# 0#)
438 = if r# `neInt64#` intToInt64# 0# then r# `plusInt64#` y# else intToInt64# 0#
441 r# = x# `remInt64#` y#
443 instance Read Int64 where
444 readsPrec p s = [(fromInteger x, r) | (x, r) <- readsPrec p s]
446 instance Bits Int64 where
447 (I64# x#) .&. (I64# y#) = I64# (word64ToInt64# (int64ToWord64# x# `and64#` int64ToWord64# y#))
448 (I64# x#) .|. (I64# y#) = I64# (word64ToInt64# (int64ToWord64# x# `or64#` int64ToWord64# y#))
449 (I64# x#) `xor` (I64# y#) = I64# (word64ToInt64# (int64ToWord64# x# `xor64#` int64ToWord64# y#))
450 complement (I64# x#) = I64# (word64ToInt64# (not64# (int64ToWord64# x#)))
451 (I64# x#) `shift` (I# i#)
452 | i# >=# 0# = I64# (x# `iShiftL64#` i#)
453 | otherwise = I64# (x# `iShiftRA64#` negateInt# i#)
454 (I64# x#) `rotate` (I# i#) =
455 I64# (word64ToInt64# ((x'# `shiftL64#` i'#) `or64#`
456 (x'# `shiftRL64#` (64# -# i'#))))
458 x'# = int64ToWord64# x#
459 i'# = word2Int# (int2Word# i# `and#` int2Word# 63#)
463 foreign import "stg_eqInt64" unsafe eqInt64# :: Int64# -> Int64# -> Bool
464 foreign import "stg_neInt64" unsafe neInt64# :: Int64# -> Int64# -> Bool
465 foreign import "stg_ltInt64" unsafe ltInt64# :: Int64# -> Int64# -> Bool
466 foreign import "stg_leInt64" unsafe leInt64# :: Int64# -> Int64# -> Bool
467 foreign import "stg_gtInt64" unsafe gtInt64# :: Int64# -> Int64# -> Bool
468 foreign import "stg_geInt64" unsafe geInt64# :: Int64# -> Int64# -> Bool
469 foreign import "stg_plusInt64" unsafe plusInt64# :: Int64# -> Int64# -> Int64#
470 foreign import "stg_minusInt64" unsafe minusInt64# :: Int64# -> Int64# -> Int64#
471 foreign import "stg_timesInt64" unsafe timesInt64# :: Int64# -> Int64# -> Int64#
472 foreign import "stg_negateInt64" unsafe negateInt64# :: Int64# -> Int64#
473 foreign import "stg_quotInt64" unsafe quotInt64# :: Int64# -> Int64# -> Int64#
474 foreign import "stg_remInt64" unsafe remInt64# :: Int64# -> Int64# -> Int64#
475 foreign import "stg_intToInt64" unsafe intToInt64# :: Int# -> Int64#
476 foreign import "stg_int64ToInt" unsafe int64ToInt# :: Int64# -> Int#
477 foreign import "stg_wordToWord64" unsafe wordToWord64# :: Word# -> Word64#
478 foreign import "stg_int64ToWord64" unsafe int64ToWord64# :: Int64# -> Word64#
479 foreign import "stg_word64ToInt64" unsafe word64ToInt64# :: Word64# -> Int64#
480 foreign import "stg_and64" unsafe and64# :: Word64# -> Word64# -> Word64#
481 foreign import "stg_or64" unsafe or64# :: Word64# -> Word64# -> Word64#
482 foreign import "stg_xor64" unsafe xor64# :: Word64# -> Word64# -> Word64#
483 foreign import "stg_not64" unsafe not64# :: Word64# -> Word64#
484 foreign import "stg_iShiftL64" unsafe iShiftL64# :: Int64# -> Int# -> Int64#
485 foreign import "stg_iShiftRA64" unsafe iShiftRA64# :: Int64# -> Int# -> Int64#
486 foreign import "stg_shiftL64" unsafe shiftL64# :: Word64# -> Int# -> Word64#
487 foreign import "stg_shiftRL64" unsafe shiftRL64# :: Word64# -> Int# -> Word64#
490 "fromIntegral/Int->Int64" fromIntegral = \(I# x#) -> I64# (intToInt64# x#)
491 "fromIntegral/Word->Int64" fromIntegral = \(W# x#) -> I64# (word64ToInt64# (wordToWord64# x#))
492 "fromIntegral/Word64->Int64" fromIntegral = \(W64# x#) -> I64# (word64ToInt64# x#)
493 "fromIntegral/Int64->Int" fromIntegral = \(I64# x#) -> I# (int64ToInt# x#)
494 "fromIntegral/Int64->Word" fromIntegral = \(I64# x#) -> W# (int2Word# (int64ToInt# x#))
495 "fromIntegral/Int64->Word64" fromIntegral = \(I64# x#) -> W64# (int64ToWord64# x#)
496 "fromIntegral/Int64->Int64" fromIntegral = id :: Int64 -> Int64
501 data Int64 = I64# Int# deriving (Eq, Ord)
503 instance Show Int64 where
504 showsPrec p x = showsPrec p (fromIntegral x :: Int)
506 instance Num Int64 where
507 (I64# x#) + (I64# y#) = I64# (x# +# y#)
508 (I64# x#) - (I64# y#) = I64# (x# -# y#)
509 (I64# x#) * (I64# y#) = I64# (x# *# y#)
510 negate (I64# x#) = I64# (negateInt# x#)
512 | otherwise = negate x
516 fromInteger (S# i#) = I64# i#
517 fromInteger (J# s# d#) = I64# (integer2Int# s# d#)
519 instance Enum Int64 where
521 | x /= maxBound = x + 1
522 | otherwise = succError "Int64"
524 | x /= minBound = x - 1
525 | otherwise = predError "Int64"
526 toEnum (I# i#) = I64# i#
527 fromEnum (I64# x#) = I# x#
528 enumFrom = boundedEnumFrom
529 enumFromThen = boundedEnumFromThen
531 instance Integral Int64 where
532 quot x@(I64# x#) y@(I64# y#)
533 | y /= 0 = I64# (x# `quotInt#` y#)
534 | otherwise = divZeroError "quot{Int64}" x
535 rem x@(I64# x#) y@(I64# y#)
536 | y /= 0 = I64# (x# `remInt#` y#)
537 | otherwise = divZeroError "rem{Int64}" x
538 div x@(I64# x#) y@(I64# y#)
539 | y /= 0 = I64# (x# `divInt#` y#)
540 | otherwise = divZeroError "div{Int64}" x
541 mod x@(I64# x#) y@(I64# y#)
542 | y /= 0 = I64# (x# `modInt#` y#)
543 | otherwise = divZeroError "mod{Int64}" x
544 quotRem x@(I64# x#) y@(I64# y#)
545 | y /= 0 = (I64# (x# `quotInt#` y#), I64# (x# `remInt#` y#))
546 | otherwise = divZeroError "quotRem{Int64}" x
547 divMod x@(I64# x#) y@(I64# y#)
548 | y /= 0 = (I64# (x# `divInt#` y#), I64# (x# `modInt#` y#))
549 | otherwise = divZeroError "divMod{Int64}" x
550 toInteger (I64# x#) = S# x#
552 instance Read Int64 where
553 readsPrec p s = [(fromIntegral (x::Int), r) | (x, r) <- readsPrec p s]
555 instance Bits Int64 where
556 (I64# x#) .&. (I64# y#) = I64# (word2Int# (int2Word# x# `and#` int2Word# y#))
557 (I64# x#) .|. (I64# y#) = I64# (word2Int# (int2Word# x# `or#` int2Word# y#))
558 (I64# x#) `xor` (I64# y#) = I64# (word2Int# (int2Word# x# `xor#` int2Word# y#))
559 complement (I64# x#) = I64# (word2Int# (int2Word# x# `xor#` int2Word# (-1#)))
560 (I64# x#) `shift` (I# i#)
561 | i# >=# 0# = I64# (x# `iShiftL#` i#)
562 | otherwise = I64# (x# `iShiftRA#` negateInt# i#)
563 (I64# x#) `rotate` (I# i#) =
564 I64# (word2Int# ((x'# `shiftL#` i'#) `or#`
565 (x'# `shiftRL#` (64# -# i'#))))
568 i'# = word2Int# (int2Word# i# `and#` int2Word# 63#)
573 "fromIntegral/a->Int64" fromIntegral = \x -> case fromIntegral x of I# x# -> I64# (intToInt64# x#)
574 "fromIntegral/Int64->a" fromIntegral = \(I64# x#) -> fromIntegral (I# x#)
579 instance CCallable Int64
580 instance CReturnable Int64
582 instance Real Int64 where
583 toRational x = toInteger x % 1
585 instance Bounded Int64 where
586 minBound = -0x8000000000000000
587 maxBound = 0x7FFFFFFFFFFFFFFF
589 instance Ix Int64 where
592 | inRange b i = fromIntegral (i - m)
593 | otherwise = indexError b i "Int64"
594 inRange (m,n) i = m <= i && i <= n