Chapter 28
Foreign.C.Types

28.1 Representations of C types

These types are needed to accurately represent C function prototypes, in order to access C library interfaces in Haskell. The Haskell system is not required to represent those types exactly as C does, but the following guarantees are provided concerning a Haskell type CT representing a C type t:

• If a C function prototype has t as an argument or result type, the use of CT in the corresponding position in a foreign declaration permits the Haskell program to access the full range of values encoded by the C type; and conversely, any Haskell value for CT has a valid representation in C.
• sizeOf (undefined :: CT) will yield the same value as sizeof (t) in C.
• alignment (undefined :: CT) matches the alignment constraint enforced by the C implementation for t.
• The members peek and poke of the Storable class map all values of CT to the corresponding value of t and vice versa.
• When an instance of Bounded is defined for CT, the values of minBound and maxBound coincide with t_MIN and t_MAX in C.
• When an instance of Eq or Ord is defined for CT, the predicates defined by the type class implement the same relation as the corresponding predicate in C on t.
• When an instance of Num, Read, Integral, Fractional, Floating, RealFrac, or RealFloat is defined for CT, the arithmetic operations defined by the type class implement the same function as the corresponding arithmetic operations (if available) in C on t.
• When an instance of Bits is defined for CT, the bitwise operation defined by the type class implement the same function as the corresponding bitwise operation in C on t.

28.1.1 Integral types

These types are are represented as newtypes of types in Data.Int and Data.Word, and are instances of Eq, Ord, Num, Read, Show, Enum, Storable, Bounded, Real, Integral and Bits.

data CChar

Haskell type representing the C char type.

instance Bounded CChar

instance Enum CChar

instance Eq CChar

instance Integral CChar

instance Num CChar

instance Ord CChar

instance Read CChar

instance Real CChar

instance Show CChar

instance Storable CChar

instance Bits CChar

data CSChar

Haskell type representing the C signed char type.

instance Bounded CSChar

instance Enum CSChar

instance Eq CSChar

instance Integral CSChar

instance Num CSChar

instance Ord CSChar

instance Read CSChar

instance Real CSChar

instance Show CSChar

instance Storable CSChar

instance Bits CSChar

data CUChar

Haskell type representing the C unsigned char type.

instance Bounded CUChar

instance Enum CUChar

instance Eq CUChar

instance Integral CUChar

instance Num CUChar

instance Ord CUChar

instance Read CUChar

instance Real CUChar

instance Show CUChar

instance Storable CUChar

instance Bits CUChar

data CShort

Haskell type representing the C short type.

instance Bounded CShort

instance Enum CShort

instance Eq CShort

instance Integral CShort

instance Num CShort

instance Ord CShort

instance Read CShort

instance Real CShort

instance Show CShort

instance Storable CShort

instance Bits CShort

data CUShort

Haskell type representing the C unsigned short type.

instance Bounded CUShort

instance Enum CUShort

instance Eq CUShort

instance Integral CUShort

instance Num CUShort

instance Ord CUShort

instance Read CUShort

instance Real CUShort

instance Show CUShort

instance Storable CUShort

instance Bits CUShort

data CInt

Haskell type representing the C int type.

instance Bounded CInt

instance Enum CInt

instance Eq CInt

instance Integral CInt

instance Num CInt

instance Ord CInt

instance Read CInt

instance Real CInt

instance Show CInt

instance Storable CInt

instance Bits CInt

data CUInt

Haskell type representing the C unsigned int type.

instance Bounded CUInt

instance Enum CUInt

instance Eq CUInt

instance Integral CUInt

instance Num CUInt

instance Ord CUInt

instance Read CUInt

instance Real CUInt

instance Show CUInt

instance Storable CUInt

instance Bits CUInt

data CLong

Haskell type representing the C long type.

instance Bounded CLong

instance Enum CLong

instance Eq CLong

instance Integral CLong

instance Num CLong

instance Ord CLong

instance Read CLong

instance Real CLong

instance Show CLong

instance Storable CLong

instance Bits CLong

data CULong

Haskell type representing the C unsigned long type.

instance Bounded CULong

instance Enum CULong

instance Eq CULong

instance Integral CULong

instance Num CULong

instance Ord CULong

instance Read CULong

instance Real CULong

instance Show CULong

instance Storable CULong

instance Bits CULong

data CPtrdiff

Haskell type representing the C ptrdiff_t type.

instance Bounded CPtrdiff

instance Enum CPtrdiff

instance Eq CPtrdiff

instance Integral CPtrdiff

instance Num CPtrdiff

instance Ord CPtrdiff

instance Read CPtrdiff

instance Real CPtrdiff

instance Show CPtrdiff

instance Storable CPtrdiff

instance Bits CPtrdiff

data CSize

Haskell type representing the C size_t type.

instance Bounded CSize

instance Enum CSize

instance Eq CSize

instance Integral CSize

instance Num CSize

instance Ord CSize

instance Read CSize

instance Real CSize

instance Show CSize

instance Storable CSize

instance Bits CSize

data CWchar

Haskell type representing the C wchar_t type.

instance Bounded CWchar

instance Enum CWchar

instance Eq CWchar

instance Integral CWchar

instance Num CWchar

instance Ord CWchar

instance Read CWchar

instance Real CWchar

instance Show CWchar

instance Storable CWchar

instance Bits CWchar

data CSigAtomic

Haskell type representing the C sig_atomic_t type.

instance Bounded CSigAtomic

instance Enum CSigAtomic

instance Eq CSigAtomic

instance Integral CSigAtomic

instance Num CSigAtomic

instance Ord CSigAtomic

instance Read CSigAtomic

instance Real CSigAtomic

instance Show CSigAtomic

instance Storable CSigAtomic

instance Bits CSigAtomic

data CLLong

Haskell type representing the C long long type.

instance Bounded CLLong

instance Enum CLLong

instance Eq CLLong

instance Integral CLLong

instance Num CLLong

instance Ord CLLong

instance Read CLLong

instance Real CLLong

instance Show CLLong

instance Storable CLLong

instance Bits CLLong

data CULLong

Haskell type representing the C unsigned long long type.

instance Bounded CULLong

instance Enum CULLong

instance Eq CULLong

instance Integral CULLong

instance Num CULLong

instance Ord CULLong

instance Read CULLong

instance Real CULLong

instance Show CULLong

instance Storable CULLong

instance Bits CULLong

data CIntPtr

instance Bounded CIntPtr

instance Enum CIntPtr

instance Eq CIntPtr

instance Integral CIntPtr

instance Num CIntPtr

instance Ord CIntPtr

instance Read CIntPtr

instance Real CIntPtr

instance Show CIntPtr

instance Storable CIntPtr

instance Bits CIntPtr

data CUIntPtr

instance Bounded CUIntPtr

instance Enum CUIntPtr

instance Eq CUIntPtr

instance Integral CUIntPtr

instance Num CUIntPtr

instance Ord CUIntPtr

instance Read CUIntPtr

instance Real CUIntPtr

instance Show CUIntPtr

instance Storable CUIntPtr

instance Bits CUIntPtr

data CIntMax

instance Bounded CIntMax

instance Enum CIntMax

instance Eq CIntMax

instance Integral CIntMax

instance Num CIntMax

instance Ord CIntMax

instance Read CIntMax

instance Real CIntMax

instance Show CIntMax

instance Storable CIntMax

instance Bits CIntMax

data CUIntMax

instance Bounded CUIntMax

instance Enum CUIntMax

instance Eq CUIntMax

instance Integral CUIntMax

instance Num CUIntMax

instance Ord CUIntMax

instance Read CUIntMax

instance Real CUIntMax

instance Show CUIntMax

instance Storable CUIntMax

instance Bits CUIntMax

28.1.2 Numeric types

These types are are represented as newtypes of basic foreign types, and are instances of Eq, Ord, Num, Read, Show, Enum and Storable.

data CClock

Haskell type representing the C clock_t type.

instance Enum CClock

instance Eq CClock

instance Num CClock

instance Ord CClock

instance Read CClock

instance Real CClock

instance Show CClock

instance Storable CClock

data CTime

Haskell type representing the C time_t type.

instance Enum CTime

instance Eq CTime

instance Num CTime

instance Ord CTime

instance Read CTime

instance Real CTime

instance Show CTime

instance Storable CTime

28.1.3 Floating types

These types are are represented as newtypes of Float and Double, and are instances of Eq, Ord, Num, Read, Show, Enum, Storable, Real, Fractional, Floating, RealFrac and RealFloat.

data CFloat

Haskell type representing the C float type.

instance Enum CFloat

instance Eq CFloat

instance Floating CFloat

instance Fractional CFloat

instance Num CFloat

instance Ord CFloat

instance Read CFloat

instance Real CFloat

instance RealFloat CFloat

instance RealFrac CFloat

instance Show CFloat

instance Storable CFloat

data CDouble

Haskell type representing the C double type.

instance Enum CDouble

instance Eq CDouble

instance Floating CDouble

instance Fractional CDouble

instance Num CDouble

instance Ord CDouble

instance Read CDouble

instance Real CDouble

instance RealFloat CDouble

instance RealFrac CDouble

instance Show CDouble

instance Storable CDouble

28.1.4 Other types

data CFile

Haskell type representing the C FILE type.

data CFpos

Haskell type representing the C fpos_t type.

data CJmpBuf

Haskell type representing the C jmp_buf type.