| Haskell Hierarchical Libraries (base package) | Contents | Index

Foreign.C.Types

Portability | portable
Stability | provisional
Maintainer | ffi@haskell.org

Contents

Representations of C types
  Integral types
  Numeric types
  Floating types
  Other types

Description
Mapping of C types to corresponding Haskell types.
Synopsis

data CChar
data CSChar
data CUChar
data CShort
data CUShort
data CInt
data CUInt
data CLong
data CULong
data CPtrdiff
data CSize
data CWchar
data CSigAtomic
data CLLong
data CULLong
data CClock
data CTime
data CFloat
data CDouble
data CLDouble
data CFile
data CFpos
data CJmpBuf

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`.

Integral types
These types are are represented as `newtype`s of types in Data.Int and Data.Word, and are instances of `Eq`, `Ord`, `Num`, `Read`, `Show`, `Enum`, `Typeable`, `Storable`, `Bounded`, `Real`, `Integral` and `Bits`.
data CChar

Haskell type representing the C `char` type.
Instances

Bits CChar
Bounded CChar
Enum CChar
Eq CChar
Integral CChar
Num CChar
Ord CChar
Read CChar
Real CChar
Show CChar
Storable CChar
Typeable CChar

data CSChar

Haskell type representing the C `signed char` type.
Instances

Bits CSChar
Bounded CSChar
Enum CSChar
Eq CSChar
Integral CSChar
Num CSChar
Ord CSChar
Read CSChar
Real CSChar
Show CSChar
Storable CSChar
Typeable CSChar

data CUChar

Haskell type representing the C `unsigned char` type.
Instances

Bits CUChar
Bounded CUChar
Enum CUChar
Eq CUChar
Integral CUChar
Num CUChar
Ord CUChar
Read CUChar
Real CUChar
Show CUChar
Storable CUChar
Typeable CUChar

data CShort

Haskell type representing the C `short` type.
Instances

Bits CShort
Bounded CShort
Enum CShort
Eq CShort
Integral CShort
Num CShort
Ord CShort
Read CShort
Real CShort
Show CShort
Storable CShort
Typeable CShort

data CUShort

Haskell type representing the C `unsigned short` type.
Instances

Bits CUShort
Bounded CUShort
Enum CUShort
Eq CUShort
Integral CUShort
Num CUShort
Ord CUShort
Read CUShort
Real CUShort
Show CUShort
Storable CUShort
Typeable CUShort

data CInt

Haskell type representing the C `int` type.
Instances

Bits CInt
Bounded CInt
Enum CInt
Eq CInt
Integral CInt
Num CInt
Ord CInt
Read CInt
Real CInt
Show CInt
Storable CInt
Typeable CInt

data CUInt

Haskell type representing the C `unsigned int` type.
Instances

Bits CUInt
Bounded CUInt
Enum CUInt
Eq CUInt
Integral CUInt
Num CUInt
Ord CUInt
Read CUInt
Real CUInt
Show CUInt
Storable CUInt
Typeable CUInt

data CLong

Haskell type representing the C `long` type.
Instances

Bits CLong
Bounded CLong
Enum CLong
Eq CLong
Integral CLong
Num CLong
Ord CLong
Read CLong
Real CLong
Show CLong
Storable CLong
Typeable CLong

data CULong

Haskell type representing the C `unsigned long` type.
Instances

Bits CULong
Bounded CULong
Enum CULong
Eq CULong
Integral CULong
Num CULong
Ord CULong
Read CULong
Real CULong
Show CULong
Storable CULong
Typeable CULong

data CPtrdiff

Haskell type representing the C `ptrdiff_t` type.
Instances

Bits CPtrdiff
Bounded CPtrdiff
Enum CPtrdiff
Eq CPtrdiff
Integral CPtrdiff
Num CPtrdiff
Ord CPtrdiff
Read CPtrdiff
Real CPtrdiff
Show CPtrdiff
Storable CPtrdiff
Typeable CPtrdiff

data CSize

Haskell type representing the C `size_t` type.
Instances

Bits CSize
Bounded CSize
Enum CSize
Eq CSize
Integral CSize
Num CSize
Ord CSize
Read CSize
Real CSize
Show CSize
Storable CSize
Typeable CSize

data CWchar

Haskell type representing the C `wchar_t` type.
Instances

Bits CWchar
Bounded CWchar
Enum CWchar
Eq CWchar
Integral CWchar
Num CWchar
Ord CWchar
Read CWchar
Real CWchar
Show CWchar
Storable CWchar
Typeable CWchar

data CSigAtomic

Haskell type representing the C `sig_atomic_t` type.
Instances

Bits CSigAtomic
Bounded CSigAtomic
Enum CSigAtomic
Eq CSigAtomic
Integral CSigAtomic
Num CSigAtomic
Ord CSigAtomic
Read CSigAtomic
Real CSigAtomic
Show CSigAtomic
Storable CSigAtomic
Typeable CSigAtomic

data CLLong

Haskell type representing the C `long long` type.
Instances

Bits CLLong
Bounded CLLong
Enum CLLong
Eq CLLong
Integral CLLong
Num CLLong
Ord CLLong
Read CLLong
Real CLLong
Show CLLong
Storable CLLong
Typeable CLLong

data CULLong

Haskell type representing the C `unsigned long long` type.
Instances

Bits CULLong
Bounded CULLong
Enum CULLong
Eq CULLong
Integral CULLong
Num CULLong
Ord CULLong
Read CULLong
Real CULLong
Show CULLong
Storable CULLong
Typeable CULLong

Numeric types
These types are are represented as `newtype`s of basic foreign types, and are instances of `Eq`, `Ord`, `Num`, `Read`, `Show`, `Enum`, `Typeable` and `Storable`.
data CClock

Haskell type representing the C `clock_t` type.
Instances

Enum CClock
Eq CClock
Num CClock
Ord CClock
Read CClock
Real CClock
Show CClock
Storable CClock
Typeable CClock

data CTime

Haskell type representing the C `time_t` type.
Instances

Enum CTime
Eq CTime
Num CTime
Ord CTime
Read CTime
Real CTime
Show CTime
Storable CTime
Typeable CTime

Floating types
These types are are represented as `newtype`s of `Float` and `Double`, and are instances of `Eq`, `Ord`, `Num`, `Read`, `Show`, `Enum`, `Typeable`, `Storable`, `Real`, `Fractional`, `Floating`, `RealFrac` and `RealFloat`.
data CFloat

Haskell type representing the C `float` type.
Instances

Enum CFloat
Eq CFloat
Floating CFloat
Fractional CFloat
Num CFloat
Ord CFloat
Read CFloat
Real CFloat
RealFloat CFloat
RealFrac CFloat
Show CFloat
Storable CFloat
Typeable CFloat

data CDouble

Haskell type representing the C `double` type.
Instances

Enum CDouble
Eq CDouble
Floating CDouble
Fractional CDouble
Num CDouble
Ord CDouble
Read CDouble
Real CDouble
RealFloat CDouble
RealFrac CDouble
Show CDouble
Storable CDouble
Typeable CDouble

data CLDouble

Haskell type representing the C `long double` type.
Instances

Enum CLDouble
Eq CLDouble
Floating CLDouble
Fractional CLDouble
Num CLDouble
Ord CLDouble
Read CLDouble
Real CLDouble
RealFloat CLDouble
RealFrac CLDouble
Show CLDouble
Storable CLDouble
Typeable CLDouble

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.

Produced by Haddock version 0.7