| base-4.1.0.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 (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 | 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
Typeable CChar
Bits CChar
Storable 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
Typeable CSChar
Bits CSChar
Storable 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
Typeable CUChar
Bits CUChar
Storable 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
Typeable CShort
Bits CShort
Storable 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
Typeable CUShort
Bits CUShort
Storable 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
Typeable CInt
Bits CInt
Storable 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
Typeable CUInt
Bits CUInt
Storable 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
Typeable CLong
Bits CLong
Storable 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
Typeable CULong
Bits CULong
Storable 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
Typeable CPtrdiff
Bits CPtrdiff
Storable 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
Typeable CSize
Bits CSize
Storable 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
Typeable CWchar
Bits CWchar
Storable 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
Typeable CSigAtomic
Bits CSigAtomic
Storable 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
Typeable CLLong
Bits CLLong
Storable 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
Typeable CULLong
Bits CULLong
Storable CULLong

data CIntPtr | Source

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

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

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

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

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 | 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
Typeable CTime
Storable CTime

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 | 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
Typeable CFloat
Storable 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
Typeable CDouble
Storable 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
Typeable CLDouble
Storable 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 2.4.2