Portability	portable
Stability	experimental
Maintainer	libraries@haskell.org

Data.Int

Contents

Signed integer types
Notes

Description

Signed integer types

Synopsis

data Int
data Int8
data Int16
data Int32
data Int64

Signed integer types

data Int Source

A fixed-precision integer type with at least the range [-2^29 .. 2^29-1]. The exact range for a given implementation can be determined by using Prelude.minBound and Prelude.maxBound from the Prelude.Bounded class.

Instances

Bounded Int

Enum Int

Eq Int

Integral Int

Data Int

Num Int

Ord Int

Read Int

Real Int

Show Int

Ix Int

Typeable Int

Generic Int

Bits Int

Storable Int

PrintfArg Int

data Int8 Source

8-bit signed integer type

Instances

Bounded Int8

Enum Int8

Eq Int8

Integral Int8

Data Int8

Num Int8

Ord Int8

Read Int8

Real Int8

Show Int8

Ix Int8

Typeable Int8

Bits Int8

Storable Int8

PrintfArg Int8

data Int16 Source

16-bit signed integer type

Instances

Bounded Int16

Enum Int16

Eq Int16

Integral Int16

Data Int16

Num Int16

Ord Int16

Read Int16

Real Int16

Show Int16

Ix Int16

Typeable Int16

Bits Int16

Storable Int16

PrintfArg Int16

data Int32 Source

32-bit signed integer type

Instances

Bounded Int32

Enum Int32

Eq Int32

Integral Int32

Data Int32

Num Int32

Ord Int32

Read Int32

Real Int32

Show Int32

Ix Int32

Typeable Int32

Bits Int32

Storable Int32

PrintfArg Int32

data Int64 Source

64-bit signed integer type

Instances

Bounded Int64

Enum Int64

Eq Int64

Integral Int64

Data Int64

Num Int64

Ord Int64

Read Int64

Real Int64

Show Int64

Ix Int64

Typeable Int64

Bits Int64

Storable Int64

PrintfArg Int64

Notes

All arithmetic is performed modulo 2^n, where n is the number of bits in the type.
For coercing between any two integer types, use Prelude.fromIntegral, which is specialized for all the common cases so should be fast enough. Coercing word types (see Data.Word) to and from integer types preserves representation, not sign.
The rules that hold for Prelude.Enum instances over a bounded type such as Int (see the section of the Haskell report dealing with arithmetic sequences) also hold for the Prelude.Enum instances over the various Int types defined here.
Right and left shifts by amounts greater than or equal to the width of the type result in either zero or -1, depending on the sign of the value being shifted. This is contrary to the behaviour in C, which is undefined; a common interpretation is to truncate the shift count to the width of the type, for example 1 << 32 == 1 in some C implementations.