haskell2010-1.1.2.0: Compatibility with Haskell 2010

Safe Haskell | Safe
Language | Haskell2010

Foreign.C.Types

Contents

- Representations of C types
  - Integral types
  - Numeric types
  - Floating types
  - Other 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 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`, `Storable`, `Bounded`, `Real`, `Integral` and `Bits`.

data CChar :: * Source

Haskell type representing the C `char` type.

Instances

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

data CSChar :: * Source

Haskell type representing the C `signed char` type.

Instances

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

data CUChar :: * Source

Haskell type representing the C `unsigned char` type.

Instances

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

data CShort :: * Source

Haskell type representing the C `short` type.

Instances

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

data CUShort :: * Source

Haskell type representing the C `unsigned short` type.

Instances

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

data CInt :: * Source

Haskell type representing the C `int` type.

Instances

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

data CUInt :: * Source

Haskell type representing the C `unsigned int` type.

Instances

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

data CLong :: * Source

Haskell type representing the C `long` type.

Instances

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

data CULong :: * Source

Haskell type representing the C `unsigned long` type.

Instances

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

data CPtrdiff :: * Source

Haskell type representing the C `ptrdiff_t` type.

Instances

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

data CSize :: * Source

Haskell type representing the C `size_t` type.

Instances

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

data CWchar :: * Source

Haskell type representing the C `wchar_t` type.

Instances

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

data CSigAtomic :: * Source

Haskell type representing the C `sig_atomic_t` type.

Instances

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

data CLLong :: * Source

Haskell type representing the C `long long` type.

Instances

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

data CULLong :: * Source

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

Instances

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

data CIntPtr :: * Source

Instances

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

data CUIntPtr :: * Source

Instances

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

data CIntMax :: * Source

Instances

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

data CUIntMax :: * Source

Instances

Bounded CUIntMax |
Enum CUIntMax |
Eq CUIntMax |
Integral CUIntMax |
Num CUIntMax |
Ord CUIntMax |
Read CUIntMax |
Real CUIntMax |
Show CUIntMax |
Storable CUIntMax |
Bits CUIntMax |
FiniteBits 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` 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.

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

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