| base-3.0.1.0: Basic libraries | Source code | 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 CIntPtr
data CUIntPtr
data CIntMax
data CUIntMax
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 | Source

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 | Source

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 | Source

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 | Source

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 | Source

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 | Source

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 | Source

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 | Source

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 | Source

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 | Source

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 | Source

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 | Source

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 | Source

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 | Source

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 | Source

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

data CIntPtr | Source

Instances

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

data CUIntPtr | Source

Instances

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

data CIntMax | Source

Instances

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

data CUIntMax | Source

Instances

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

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 | Source

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 | Source

Haskell type representing the C `time_t` type. To convert to a `Data.Time.UTCTime`, use the following formula:
      posixSecondsToUTCTime (realToFrac :: POSIXTime)
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 | Source

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 | Source

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 | Source

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 | Source

Haskell type representing the C `FILE` type.

data CFpos | Source

Haskell type representing the C `fpos_t` type.

data CJmpBuf | Source

Haskell type representing the C `jmp_buf` type.

Produced by Haddock version 0.8