base-4.3.1.0: Basic libraries

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

Foreign.C.Types

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 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` (`Prelude.undefined` :: CT)` will yield the same value as `sizeof (t)` in C.
- ``alignment` (`Prelude.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 `Prelude.Bounded` is defined for `CT`, the values of `Prelude.minBound` and `Prelude.maxBound` coincide with `t_MIN` and `t_MAX` in C.
- When an instance of `Prelude.Eq` or `Prelude.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 `Prelude.Num`, `Prelude.Read`, `Prelude.Integral`, `Prelude.Fractional`, `Prelude.Floating`, `Prelude.RealFrac`, or `Prelude.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 `Prelude.Eq`, `Prelude.Ord`, `Prelude.Num`, `Prelude.Read`, `Prelude.Show`, `Prelude.Enum`, `Typeable`, `Storable`, `Prelude.Bounded`, `Prelude.Real`, `Prelude.Integral` and `Bits`.

data CChar

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 |
Typeable CChar |
Bits CChar |
Storable CChar |

data CSChar

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 |
Typeable CSChar |
Bits CSChar |
Storable CSChar |

data CUChar

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 |
Typeable CUChar |
Bits CUChar |
Storable CUChar |

data CShort

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 |
Typeable CShort |
Bits CShort |
Storable CShort |

data CUShort

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 |
Typeable CUShort |
Bits CUShort |
Storable CUShort |

data CInt

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 |
Typeable CInt |
Bits CInt |
Storable CInt |

data CUInt

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 |
Typeable CUInt |
Bits CUInt |
Storable CUInt |

data CLong

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 |
Typeable CLong |
Bits CLong |
Storable CLong |

data CULong

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 |
Typeable CULong |
Bits CULong |
Storable CULong |

data CPtrdiff

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 |
Typeable CPtrdiff |
Bits CPtrdiff |
Storable CPtrdiff |

data CSize

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 |
Typeable CSize |
Bits CSize |
Storable CSize |

data CWchar

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 |
Typeable CWchar |
Bits CWchar |
Storable CWchar |

data CSigAtomic

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 |
Typeable CSigAtomic |
Bits CSigAtomic |
Storable CSigAtomic |

data CLLong

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 |
Typeable CLLong |
Bits CLLong |
Storable CLLong |

data CULLong

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 |
Typeable CULLong |
Bits CULLong |
Storable CULLong |

data CIntPtr

Instances

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

data CUIntPtr

Instances

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

data CIntMax

Instances

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

data CUIntMax

Instances

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

## Numeric types

These types are are represented as `newtype`s of basic foreign types, and are instances of `Prelude.Eq`, `Prelude.Ord`, `Prelude.Num`, `Prelude.Read`, `Prelude.Show`, `Prelude.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 |
Typeable CClock |
Storable 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 |
Typeable CTime |
Storable CTime |

To convert `CTime` to `Data.Time.UTCTime`, use the following formula:

      posixSecondsToUTCTime (realToFrac :: POSIXTime)

## Floating types

These types are are represented as `newtype`s of `Prelude.Float` and `Prelude.Double`, and are instances of `Prelude.Eq`, `Prelude.Ord`, `Prelude.Num`, `Prelude.Read`, `Prelude.Show`, `Prelude.Enum`, `Typeable`, `Storable`, `Prelude.Real`, `Prelude.Fractional`, `Prelude.Floating`, `Prelude.RealFrac` and `Prelude.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 |
Typeable CFloat |
Storable 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 |
Typeable CDouble |
Storable CDouble |

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