Foreign.C.Types

| 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