W3cubDocs

/Haskell 8

Foreign.C.Types

Copyright (c) The FFI task force 2001
License BSD-style (see the file libraries/base/LICENSE)
Maintainer [email protected]
Stability provisional
Portability portable
Safe Haskell Trustworthy
Language Haskell2010

Description

Mapping of C types to corresponding Haskell types.

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.

Platform differences

This module contains platform specific information about types. __/As such the types presented on this page reflect the platform on which the documentation was generated and may not coincide with the types on your platform./__

Integral types

These types are represented as newtypes 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.

newtype CChar Source

Haskell type representing the C char type.

Constructors

CChar Int8

Instances

Bounded CChar
Enum CChar
Eq CChar

Methods

(==) :: CChar -> CChar -> Bool Source

(/=) :: CChar -> CChar -> Bool Source

Integral CChar
Num CChar
Ord CChar
Read CChar
Real CChar
Show CChar
FiniteBits CChar
Bits CChar
Storable CChar

newtype CSChar Source

Haskell type representing the C signed char type.

Constructors

CSChar Int8

Instances

Bounded CSChar
Enum CSChar
Eq CSChar

Methods

(==) :: CSChar -> CSChar -> Bool Source

(/=) :: CSChar -> CSChar -> Bool Source

Integral CSChar
Num CSChar
Ord CSChar
Read CSChar
Real CSChar
Show CSChar
FiniteBits CSChar
Bits CSChar
Storable CSChar

newtype CUChar Source

Haskell type representing the C unsigned char type.

Constructors

CUChar Word8

Instances

Bounded CUChar
Enum CUChar
Eq CUChar

Methods

(==) :: CUChar -> CUChar -> Bool Source

(/=) :: CUChar -> CUChar -> Bool Source

Integral CUChar
Num CUChar
Ord CUChar
Read CUChar
Real CUChar
Show CUChar
FiniteBits CUChar
Bits CUChar
Storable CUChar

newtype CShort Source

Haskell type representing the C short type.

Constructors

CShort Int16

Instances

Bounded CShort
Enum CShort
Eq CShort

Methods

(==) :: CShort -> CShort -> Bool Source

(/=) :: CShort -> CShort -> Bool Source

Integral CShort
Num CShort
Ord CShort
Read CShort
Real CShort
Show CShort
FiniteBits CShort
Bits CShort
Storable CShort

newtype CUShort Source

Haskell type representing the C unsigned short type.

Constructors

CUShort Word16

Instances

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

newtype CInt Source

Haskell type representing the C int type.

Constructors

CInt Int32

Instances

Bounded CInt
Enum CInt
Eq CInt

Methods

(==) :: CInt -> CInt -> Bool Source

(/=) :: CInt -> CInt -> Bool Source

Integral CInt
Num CInt
Ord CInt

Methods

compare :: CInt -> CInt -> Ordering Source

(<) :: CInt -> CInt -> Bool Source

(<=) :: CInt -> CInt -> Bool Source

(>) :: CInt -> CInt -> Bool Source

(>=) :: CInt -> CInt -> Bool Source

max :: CInt -> CInt -> CInt Source

min :: CInt -> CInt -> CInt Source

Read CInt
Real CInt

Methods

toRational :: CInt -> Rational Source

Show CInt
FiniteBits CInt
Bits CInt
Storable CInt

newtype CUInt Source

Haskell type representing the C unsigned int type.

Constructors

CUInt Word32

Instances

Bounded CUInt
Enum CUInt
Eq CUInt

Methods

(==) :: CUInt -> CUInt -> Bool Source

(/=) :: CUInt -> CUInt -> Bool Source

Integral CUInt
Num CUInt
Ord CUInt
Read CUInt
Real CUInt
Show CUInt
FiniteBits CUInt
Bits CUInt
Storable CUInt

newtype CLong Source

Haskell type representing the C long type.

Constructors

CLong Int64

Instances

Bounded CLong
Enum CLong
Eq CLong

Methods

(==) :: CLong -> CLong -> Bool Source

(/=) :: CLong -> CLong -> Bool Source

Integral CLong
Num CLong
Ord CLong
Read CLong
Real CLong
Show CLong
FiniteBits CLong
Bits CLong
Storable CLong

newtype CULong Source

Haskell type representing the C unsigned long type.

Constructors

CULong Word64

Instances

Bounded CULong
Enum CULong
Eq CULong

Methods

(==) :: CULong -> CULong -> Bool Source

(/=) :: CULong -> CULong -> Bool Source

Integral CULong
Num CULong
Ord CULong
Read CULong
Real CULong
Show CULong
FiniteBits CULong
Bits CULong
Storable CULong

newtype CPtrdiff Source

Haskell type representing the C ptrdiff_t type.

Constructors

CPtrdiff Int64

Instances

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

newtype CSize Source

Haskell type representing the C size_t type.

Constructors

CSize Word64

Instances

Bounded CSize
Enum CSize
Eq CSize

Methods

(==) :: CSize -> CSize -> Bool Source

(/=) :: CSize -> CSize -> Bool Source

Integral CSize
Num CSize
Ord CSize
Read CSize
Real CSize
Show CSize
FiniteBits CSize
Bits CSize
Storable CSize

newtype CWchar Source

Haskell type representing the C wchar_t type.

Constructors

CWchar Int32

Instances

Bounded CWchar
Enum CWchar
Eq CWchar

Methods

(==) :: CWchar -> CWchar -> Bool Source

(/=) :: CWchar -> CWchar -> Bool Source

Integral CWchar
Num CWchar
Ord CWchar
Read CWchar
Real CWchar
Show CWchar
FiniteBits CWchar
Bits CWchar
Storable CWchar

newtype CSigAtomic Source

Haskell type representing the C sig_atomic_t type.

Constructors

CSigAtomic Int32

Instances

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

newtype CLLong Source

Haskell type representing the C long long type.

Constructors

CLLong Int64

Instances

Bounded CLLong
Enum CLLong
Eq CLLong

Methods

(==) :: CLLong -> CLLong -> Bool Source

(/=) :: CLLong -> CLLong -> Bool Source

Integral CLLong
Num CLLong
Ord CLLong
Read CLLong
Real CLLong
Show CLLong
FiniteBits CLLong
Bits CLLong
Storable CLLong

newtype CULLong Source

Haskell type representing the C unsigned long long type.

Constructors

CULLong Word64

Instances

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

newtype CBool Source

Haskell type representing the C bool type.

Since: 4.10.0.0

Constructors

CBool Word8

Instances

Bounded CBool
Enum CBool
Eq CBool

Methods

(==) :: CBool -> CBool -> Bool Source

(/=) :: CBool -> CBool -> Bool Source

Integral CBool
Num CBool
Ord CBool
Read CBool
Real CBool
Show CBool
FiniteBits CBool
Bits CBool
Storable CBool

newtype CIntPtr Source

Constructors

CIntPtr Int64

Instances

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

newtype CUIntPtr Source

Constructors

CUIntPtr Word64

Instances

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

newtype CIntMax Source

Constructors

CIntMax Int64

Instances

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

newtype CUIntMax Source

Constructors

CUIntMax Word64

Instances

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

Numeric types

These types are represented as newtypes of basic foreign types, and are instances of Eq, Ord, Num, Read, Show, Enum, Typeable and Storable.

newtype CClock Source

Haskell type representing the C clock_t type.

Constructors

CClock Int64

Instances

Enum CClock
Eq CClock

Methods

(==) :: CClock -> CClock -> Bool Source

(/=) :: CClock -> CClock -> Bool Source

Num CClock
Ord CClock
Read CClock
Real CClock
Show CClock
Storable CClock

newtype CTime Source

Haskell type representing the C time_t type.

Constructors

CTime Int64

Instances

Enum CTime
Eq CTime

Methods

(==) :: CTime -> CTime -> Bool Source

(/=) :: CTime -> CTime -> Bool Source

Num CTime
Ord CTime
Read CTime
Real CTime
Show CTime
Storable CTime

newtype CUSeconds Source

Haskell type representing the C useconds_t type.

Since: 4.4.0.0

Constructors

CUSeconds Word32

Instances

Enum CUSeconds
Eq CUSeconds
Num CUSeconds
Ord CUSeconds
Read CUSeconds
Real CUSeconds
Show CUSeconds
Storable CUSeconds

newtype CSUSeconds Source

Haskell type representing the C suseconds_t type.

Since: 4.4.0.0

Constructors

CSUSeconds Int64

Instances

Enum CSUSeconds
Eq CSUSeconds
Num CSUSeconds
Ord CSUSeconds
Read CSUSeconds
Real CSUSeconds
Show CSUSeconds
Storable CSUSeconds

To convert CTime to UTCTime, use the following:

\t -> posixSecondsToUTCTime (realToFrac t :: POSIXTime)

Floating types

These types are represented as newtypes of Float and Double, and are instances of Eq, Ord, Num, Read, Show, Enum, Typeable, Storable, Real, Fractional, Floating, RealFrac and RealFloat.

newtype CFloat Source

Haskell type representing the C float type.

Constructors

CFloat Float

Instances

Enum CFloat
Eq CFloat

Methods

(==) :: CFloat -> CFloat -> Bool Source

(/=) :: CFloat -> CFloat -> Bool Source

Floating CFloat
Fractional CFloat
Num CFloat
Ord CFloat
Read CFloat
Real CFloat
RealFloat CFloat
RealFrac CFloat

Methods

properFraction :: Integral b => CFloat -> (b, CFloat) Source

truncate :: Integral b => CFloat -> b Source

round :: Integral b => CFloat -> b Source

ceiling :: Integral b => CFloat -> b Source

floor :: Integral b => CFloat -> b Source

Show CFloat
Storable CFloat

newtype CDouble Source

Haskell type representing the C double type.

Constructors

CDouble Double

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

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.

© The University of Glasgow and others
Licensed under a BSD-style license (see top of the page).
https://downloads.haskell.org/~ghc/8.2.1/docs/html/libraries/base-4.10.0.0/Foreign-C-Types.html