basement-0.0.6: Foundation scrap box of array & string

LicenseBSD-style
MaintainerFoundation
Safe HaskellSafe
LanguageHaskell2010

Basement.Compat.C.Types

Description

Literal support for Integral and Fractional {--} {--}

Synopsis

Documentation

newtype CChar :: * #

Haskell type representing the C char type.

Constructors

CChar Int8 

Instances

Bounded CChar 
Enum CChar 
Eq CChar 

Methods

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

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

Integral CChar 
Num CChar 
Ord CChar 

Methods

compare :: CChar -> CChar -> Ordering #

(<) :: CChar -> CChar -> Bool #

(<=) :: CChar -> CChar -> Bool #

(>) :: CChar -> CChar -> Bool #

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

max :: CChar -> CChar -> CChar #

min :: CChar -> CChar -> CChar #

Read CChar 
Real CChar 

Methods

toRational :: CChar -> Rational #

Show CChar 

Methods

showsPrec :: Int -> CChar -> ShowS #

show :: CChar -> String #

showList :: [CChar] -> ShowS #

Storable CChar 

Methods

sizeOf :: CChar -> Int #

alignment :: CChar -> Int #

peekElemOff :: Ptr CChar -> Int -> IO CChar #

pokeElemOff :: Ptr CChar -> Int -> CChar -> IO () #

peekByteOff :: Ptr b -> Int -> IO CChar #

pokeByteOff :: Ptr b -> Int -> CChar -> IO () #

peek :: Ptr CChar -> IO CChar #

poke :: Ptr CChar -> CChar -> IO () #

Bits CChar 
FiniteBits CChar 
HasNegation CChar Source # 

Methods

negate :: CChar -> CChar Source #

Integral CChar Source # 
IsIntegral CChar Source # 
Subtractive CChar Source # 

Associated Types

type Difference CChar :: * Source #

Additive CChar Source # 
IDivisible CChar Source # 
Multiplicative CChar Source # 
PrimMemoryComparable CChar Source # 
PrimType CChar Source # 
NormalForm CChar Source # 

Methods

toNormalForm :: CChar -> () Source #

type Difference CChar Source # 
type PrimSize CChar Source # 
type PrimSize CChar = 1

newtype CSChar :: * #

Haskell type representing the C signed char type.

Constructors

CSChar Int8 

Instances

Bounded CSChar 
Enum CSChar 
Eq CSChar 

Methods

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

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

Integral CSChar 
Num CSChar 
Ord CSChar 
Read CSChar 
Real CSChar 
Show CSChar 
Storable CSChar 
Bits CSChar 
FiniteBits CSChar 
HasNegation CSChar Source # 

Methods

negate :: CSChar -> CSChar Source #

Integral CSChar Source # 
IsIntegral CSChar Source # 
Subtractive CSChar Source # 

Associated Types

type Difference CSChar :: * Source #

Additive CSChar Source # 
IDivisible CSChar Source # 
Multiplicative CSChar Source # 
NormalForm CSChar Source # 

Methods

toNormalForm :: CSChar -> () Source #

type Difference CSChar Source # 

newtype CUChar :: * #

Haskell type representing the C unsigned char type.

Constructors

CUChar Word8 

Instances

Bounded CUChar 
Enum CUChar 
Eq CUChar 

Methods

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

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

Integral CUChar 
Num CUChar 
Ord CUChar 
Read CUChar 
Real CUChar 
Show CUChar 
Storable CUChar 
Bits CUChar 
FiniteBits CUChar 
Integral CUChar Source # 
IsNatural CUChar Source # 
IsIntegral CUChar Source # 
Subtractive CUChar Source # 

Associated Types

type Difference CUChar :: * Source #

Additive CUChar Source # 
IDivisible CUChar Source # 
Multiplicative CUChar Source # 
PrimMemoryComparable CUChar Source # 
PrimType CUChar Source # 
NormalForm CUChar Source # 

Methods

toNormalForm :: CUChar -> () Source #

type Difference CUChar Source # 
type PrimSize CUChar Source # 
type PrimSize CUChar = 1

newtype CShort :: * #

Haskell type representing the C short type.

Constructors

CShort Int16 

Instances

Bounded CShort 
Enum CShort 
Eq CShort 

Methods

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

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

Integral CShort 
Num CShort 
Ord CShort 
Read CShort 
Real CShort 
Show CShort 
Storable CShort 
Bits CShort 
FiniteBits CShort 
HasNegation CShort Source # 

Methods

negate :: CShort -> CShort Source #

Integral CShort Source # 
IsIntegral CShort Source # 
Subtractive CShort Source # 

Associated Types

type Difference CShort :: * Source #

Additive CShort Source # 
IDivisible CShort Source # 
Multiplicative CShort Source # 
NormalForm CShort Source # 

Methods

toNormalForm :: CShort -> () Source #

type Difference CShort Source # 

newtype CUShort :: * #

Haskell type representing the C unsigned short type.

Constructors

CUShort Word16 

Instances

Bounded CUShort 
Enum CUShort 
Eq CUShort 

Methods

(==) :: CUShort -> CUShort -> Bool #

(/=) :: CUShort -> CUShort -> Bool #

Integral CUShort 
Num CUShort 
Ord CUShort 
Read CUShort 
Real CUShort 
Show CUShort 
Storable CUShort 
Bits CUShort 
FiniteBits CUShort 
Integral CUShort Source # 
IsNatural CUShort Source # 
IsIntegral CUShort Source # 
Subtractive CUShort Source # 

Associated Types

type Difference CUShort :: * Source #

Additive CUShort Source # 
IDivisible CUShort Source # 
Multiplicative CUShort Source # 
NormalForm CUShort Source # 

Methods

toNormalForm :: CUShort -> () Source #

type Difference CUShort Source # 

newtype CInt :: * #

Haskell type representing the C int type.

Constructors

CInt Int32 

Instances

Bounded CInt 
Enum CInt 

Methods

succ :: CInt -> CInt #

pred :: CInt -> CInt #

toEnum :: Int -> CInt #

fromEnum :: CInt -> Int #

enumFrom :: CInt -> [CInt] #

enumFromThen :: CInt -> CInt -> [CInt] #

enumFromTo :: CInt -> CInt -> [CInt] #

enumFromThenTo :: CInt -> CInt -> CInt -> [CInt] #

Eq CInt 

Methods

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

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

Integral CInt 

Methods

quot :: CInt -> CInt -> CInt #

rem :: CInt -> CInt -> CInt #

div :: CInt -> CInt -> CInt #

mod :: CInt -> CInt -> CInt #

quotRem :: CInt -> CInt -> (CInt, CInt) #

divMod :: CInt -> CInt -> (CInt, CInt) #

toInteger :: CInt -> Integer #

Num CInt 

Methods

(+) :: CInt -> CInt -> CInt #

(-) :: CInt -> CInt -> CInt #

(*) :: CInt -> CInt -> CInt #

negate :: CInt -> CInt #

abs :: CInt -> CInt #

signum :: CInt -> CInt #

fromInteger :: Integer -> CInt #

Ord CInt 

Methods

compare :: CInt -> CInt -> Ordering #

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

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

(>) :: CInt -> CInt -> Bool #

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

max :: CInt -> CInt -> CInt #

min :: CInt -> CInt -> CInt #

Read CInt 
Real CInt 

Methods

toRational :: CInt -> Rational #

Show CInt 

Methods

showsPrec :: Int -> CInt -> ShowS #

show :: CInt -> String #

showList :: [CInt] -> ShowS #

Storable CInt 

Methods

sizeOf :: CInt -> Int #

alignment :: CInt -> Int #

peekElemOff :: Ptr CInt -> Int -> IO CInt #

pokeElemOff :: Ptr CInt -> Int -> CInt -> IO () #

peekByteOff :: Ptr b -> Int -> IO CInt #

pokeByteOff :: Ptr b -> Int -> CInt -> IO () #

peek :: Ptr CInt -> IO CInt #

poke :: Ptr CInt -> CInt -> IO () #

Bits CInt 
FiniteBits CInt 
HasNegation CInt Source # 

Methods

negate :: CInt -> CInt Source #

Integral CInt Source # 
IsIntegral CInt Source # 
Subtractive CInt Source # 

Associated Types

type Difference CInt :: * Source #

Methods

(-) :: CInt -> CInt -> Difference CInt Source #

Additive CInt Source # 

Methods

azero :: CInt Source #

(+) :: CInt -> CInt -> CInt Source #

scale :: IsNatural n => n -> CInt -> CInt Source #

IDivisible CInt Source # 

Methods

div :: CInt -> CInt -> CInt Source #

mod :: CInt -> CInt -> CInt Source #

divMod :: CInt -> CInt -> (CInt, CInt) Source #

Multiplicative CInt Source # 

Methods

midentity :: CInt Source #

(*) :: CInt -> CInt -> CInt Source #

(^) :: (IsNatural n, IDivisible n) => CInt -> n -> CInt Source #

NormalForm CInt Source # 

Methods

toNormalForm :: CInt -> () Source #

type Difference CInt Source # 

newtype CUInt :: * #

Haskell type representing the C unsigned int type.

Constructors

CUInt Word32 

Instances

Bounded CUInt 
Enum CUInt 
Eq CUInt 

Methods

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

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

Integral CUInt 
Num CUInt 
Ord CUInt 

Methods

compare :: CUInt -> CUInt -> Ordering #

(<) :: CUInt -> CUInt -> Bool #

(<=) :: CUInt -> CUInt -> Bool #

(>) :: CUInt -> CUInt -> Bool #

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

max :: CUInt -> CUInt -> CUInt #

min :: CUInt -> CUInt -> CUInt #

Read CUInt 
Real CUInt 

Methods

toRational :: CUInt -> Rational #

Show CUInt 

Methods

showsPrec :: Int -> CUInt -> ShowS #

show :: CUInt -> String #

showList :: [CUInt] -> ShowS #

Storable CUInt 

Methods

sizeOf :: CUInt -> Int #

alignment :: CUInt -> Int #

peekElemOff :: Ptr CUInt -> Int -> IO CUInt #

pokeElemOff :: Ptr CUInt -> Int -> CUInt -> IO () #

peekByteOff :: Ptr b -> Int -> IO CUInt #

pokeByteOff :: Ptr b -> Int -> CUInt -> IO () #

peek :: Ptr CUInt -> IO CUInt #

poke :: Ptr CUInt -> CUInt -> IO () #

Bits CUInt 
FiniteBits CUInt 
Integral CUInt Source # 
IsNatural CUInt Source # 
IsIntegral CUInt Source # 
Subtractive CUInt Source # 

Associated Types

type Difference CUInt :: * Source #

Additive CUInt Source # 
IDivisible CUInt Source # 
Multiplicative CUInt Source # 
NormalForm CUInt Source # 

Methods

toNormalForm :: CUInt -> () Source #

type Difference CUInt Source # 

newtype CLong :: * #

Haskell type representing the C long type.

Constructors

CLong Int64 

Instances

Bounded CLong 
Enum CLong 
Eq CLong 

Methods

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

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

Integral CLong 
Num CLong 
Ord CLong 

Methods

compare :: CLong -> CLong -> Ordering #

(<) :: CLong -> CLong -> Bool #

(<=) :: CLong -> CLong -> Bool #

(>) :: CLong -> CLong -> Bool #

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

max :: CLong -> CLong -> CLong #

min :: CLong -> CLong -> CLong #

Read CLong 
Real CLong 

Methods

toRational :: CLong -> Rational #

Show CLong 

Methods

showsPrec :: Int -> CLong -> ShowS #

show :: CLong -> String #

showList :: [CLong] -> ShowS #

Storable CLong 

Methods

sizeOf :: CLong -> Int #

alignment :: CLong -> Int #

peekElemOff :: Ptr CLong -> Int -> IO CLong #

pokeElemOff :: Ptr CLong -> Int -> CLong -> IO () #

peekByteOff :: Ptr b -> Int -> IO CLong #

pokeByteOff :: Ptr b -> Int -> CLong -> IO () #

peek :: Ptr CLong -> IO CLong #

poke :: Ptr CLong -> CLong -> IO () #

Bits CLong 
FiniteBits CLong 
HasNegation CLong Source # 

Methods

negate :: CLong -> CLong Source #

Integral CLong Source # 
IsIntegral CLong Source # 
Subtractive CLong Source # 

Associated Types

type Difference CLong :: * Source #

Additive CLong Source # 
IDivisible CLong Source # 
Multiplicative CLong Source # 
NormalForm CLong Source # 

Methods

toNormalForm :: CLong -> () Source #

type Difference CLong Source # 

newtype CULong :: * #

Haskell type representing the C unsigned long type.

Constructors

CULong Word64 

Instances

Bounded CULong 
Enum CULong 
Eq CULong 

Methods

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

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

Integral CULong 
Num CULong 
Ord CULong 
Read CULong 
Real CULong 
Show CULong 
Storable CULong 
Bits CULong 
FiniteBits CULong 
Integral CULong Source # 
IsNatural CULong Source # 
IsIntegral CULong Source # 
Subtractive CULong Source # 

Associated Types

type Difference CULong :: * Source #

Additive CULong Source # 
IDivisible CULong Source # 
Multiplicative CULong Source # 
NormalForm CULong Source # 

Methods

toNormalForm :: CULong -> () Source #

type Difference CULong Source # 

newtype CPtrdiff :: * #

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 
Storable CPtrdiff 
Bits CPtrdiff 
FiniteBits CPtrdiff 
HasNegation CPtrdiff Source # 
Integral CPtrdiff Source # 
IsIntegral CPtrdiff Source # 
Subtractive CPtrdiff Source # 

Associated Types

type Difference CPtrdiff :: * Source #

Additive CPtrdiff Source # 
IDivisible CPtrdiff Source # 
Multiplicative CPtrdiff Source # 
type Difference CPtrdiff Source # 

newtype CSize :: * #

Haskell type representing the C size_t type.

Constructors

CSize Word64 

Instances

Bounded CSize 
Enum CSize 
Eq CSize 

Methods

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

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

Integral CSize 
Num CSize 
Ord CSize 

Methods

compare :: CSize -> CSize -> Ordering #

(<) :: CSize -> CSize -> Bool #

(<=) :: CSize -> CSize -> Bool #

(>) :: CSize -> CSize -> Bool #

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

max :: CSize -> CSize -> CSize #

min :: CSize -> CSize -> CSize #

Read CSize 
Real CSize 

Methods

toRational :: CSize -> Rational #

Show CSize 

Methods

showsPrec :: Int -> CSize -> ShowS #

show :: CSize -> String #

showList :: [CSize] -> ShowS #

Storable CSize 

Methods

sizeOf :: CSize -> Int #

alignment :: CSize -> Int #

peekElemOff :: Ptr CSize -> Int -> IO CSize #

pokeElemOff :: Ptr CSize -> Int -> CSize -> IO () #

peekByteOff :: Ptr b -> Int -> IO CSize #

pokeByteOff :: Ptr b -> Int -> CSize -> IO () #

peek :: Ptr CSize -> IO CSize #

poke :: Ptr CSize -> CSize -> IO () #

Bits CSize 
FiniteBits CSize 
Integral CSize Source # 
IsNatural CSize Source # 
IsIntegral CSize Source # 
Subtractive CSize Source # 

Associated Types

type Difference CSize :: * Source #

Additive CSize Source # 
IDivisible CSize Source # 
Multiplicative CSize Source # 
type Difference CSize Source # 

newtype CWchar :: * #

Haskell type representing the C wchar_t type.

Constructors

CWchar Int32 

Instances

Bounded CWchar 
Enum CWchar 
Eq CWchar 

Methods

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

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

Integral CWchar 
Num CWchar 
Ord CWchar 
Read CWchar 
Real CWchar 
Show CWchar 
Storable CWchar 
Bits CWchar 
FiniteBits CWchar 
HasNegation CWchar Source # 

Methods

negate :: CWchar -> CWchar Source #

Integral CWchar Source # 
IsIntegral CWchar Source # 
Subtractive CWchar Source # 

Associated Types

type Difference CWchar :: * Source #

Additive CWchar Source # 
IDivisible CWchar Source # 
Multiplicative CWchar Source # 
type Difference CWchar Source # 

newtype CSigAtomic :: * #

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 
Storable CSigAtomic 
Bits CSigAtomic 
FiniteBits CSigAtomic 
Integral CSigAtomic Source # 
IsIntegral CSigAtomic Source # 
Subtractive CSigAtomic Source # 
Additive CSigAtomic Source # 
IDivisible CSigAtomic Source # 
Multiplicative CSigAtomic Source # 
type Difference CSigAtomic Source # 

newtype CLLong :: * #

Haskell type representing the C long long type.

Constructors

CLLong Int64 

Instances

Bounded CLLong 
Enum CLLong 
Eq CLLong 

Methods

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

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

Integral CLLong 
Num CLLong 
Ord CLLong 
Read CLLong 
Real CLLong 
Show CLLong 
Storable CLLong 
Bits CLLong 
FiniteBits CLLong 
HasNegation CLLong Source # 

Methods

negate :: CLLong -> CLLong Source #

Integral CLLong Source # 
IsIntegral CLLong Source # 
Subtractive CLLong Source # 

Associated Types

type Difference CLLong :: * Source #

Additive CLLong Source # 
IDivisible CLLong Source # 
Multiplicative CLLong Source # 
NormalForm CLLong Source # 

Methods

toNormalForm :: CLLong -> () Source #

type Difference CLLong Source # 

newtype CULLong :: * #

Haskell type representing the C unsigned long long type.

Constructors

CULLong Word64 

Instances

Bounded CULLong 
Enum CULLong 
Eq CULLong 

Methods

(==) :: CULLong -> CULLong -> Bool #

(/=) :: CULLong -> CULLong -> Bool #

Integral CULLong 
Num CULLong 
Ord CULLong 
Read CULLong 
Real CULLong 
Show CULLong 
Storable CULLong 
Bits CULLong 
FiniteBits CULLong 
Integral CULLong Source # 
IsNatural CULLong Source # 
IsIntegral CULLong Source # 
Subtractive CULLong Source # 

Associated Types

type Difference CULLong :: * Source #

Additive CULLong Source # 
IDivisible CULLong Source # 
Multiplicative CULLong Source # 
NormalForm CULLong Source # 

Methods

toNormalForm :: CULLong -> () Source #

type Difference CULLong Source # 

newtype CBool :: * #

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 #

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

Integral CBool 
Num CBool 
Ord CBool 

Methods

compare :: CBool -> CBool -> Ordering #

(<) :: CBool -> CBool -> Bool #

(<=) :: CBool -> CBool -> Bool #

(>) :: CBool -> CBool -> Bool #

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

max :: CBool -> CBool -> CBool #

min :: CBool -> CBool -> CBool #

Read CBool 
Real CBool 

Methods

toRational :: CBool -> Rational #

Show CBool 

Methods

showsPrec :: Int -> CBool -> ShowS #

show :: CBool -> String #

showList :: [CBool] -> ShowS #

Storable CBool 

Methods

sizeOf :: CBool -> Int #

alignment :: CBool -> Int #

peekElemOff :: Ptr CBool -> Int -> IO CBool #

pokeElemOff :: Ptr CBool -> Int -> CBool -> IO () #

peekByteOff :: Ptr b -> Int -> IO CBool #

pokeByteOff :: Ptr b -> Int -> CBool -> IO () #

peek :: Ptr CBool -> IO CBool #

poke :: Ptr CBool -> CBool -> IO () #

Bits CBool 
FiniteBits CBool 
Integral CBool Source # 
IsIntegral CBool Source # 
Subtractive CBool Source # 

Associated Types

type Difference CBool :: * Source #

type Difference CBool Source # 

newtype CIntPtr :: * #

Constructors

CIntPtr Int64 

Instances

Bounded CIntPtr 
Enum CIntPtr 
Eq CIntPtr 

Methods

(==) :: CIntPtr -> CIntPtr -> Bool #

(/=) :: CIntPtr -> CIntPtr -> Bool #

Integral CIntPtr 
Num CIntPtr 
Ord CIntPtr 
Read CIntPtr 
Real CIntPtr 
Show CIntPtr 
Storable CIntPtr 
Bits CIntPtr 
FiniteBits CIntPtr 
Integral CIntPtr Source # 
IsIntegral CIntPtr Source # 
Subtractive CIntPtr Source # 

Associated Types

type Difference CIntPtr :: * Source #

Additive CIntPtr Source # 
IDivisible CIntPtr Source # 
Multiplicative CIntPtr Source # 
type Difference CIntPtr Source # 

newtype CUIntPtr :: * #

Constructors

CUIntPtr Word64 

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 
Integral CUIntPtr Source # 
IsNatural CUIntPtr Source # 
IsIntegral CUIntPtr Source # 
Subtractive CUIntPtr Source # 

Associated Types

type Difference CUIntPtr :: * Source #

Additive CUIntPtr Source # 
IDivisible CUIntPtr Source # 
Multiplicative CUIntPtr Source # 
type Difference CUIntPtr Source # 

newtype CIntMax :: * #

Constructors

CIntMax Int64 

Instances

Bounded CIntMax 
Enum CIntMax 
Eq CIntMax 

Methods

(==) :: CIntMax -> CIntMax -> Bool #

(/=) :: CIntMax -> CIntMax -> Bool #

Integral CIntMax 
Num CIntMax 
Ord CIntMax 
Read CIntMax 
Real CIntMax 
Show CIntMax 
Storable CIntMax 
Bits CIntMax 
FiniteBits CIntMax 
HasNegation CIntMax Source # 
Integral CIntMax Source # 
IsIntegral CIntMax Source # 
Subtractive CIntMax Source # 

Associated Types

type Difference CIntMax :: * Source #

Additive CIntMax Source # 
IDivisible CIntMax Source # 
Multiplicative CIntMax Source # 
type Difference CIntMax Source # 

newtype CUIntMax :: * #

Constructors

CUIntMax Word64 

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 
Integral CUIntMax Source # 
IsNatural CUIntMax Source # 
IsIntegral CUIntMax Source # 
Subtractive CUIntMax Source # 

Associated Types

type Difference CUIntMax :: * Source #

Additive CUIntMax Source # 
IDivisible CUIntMax Source # 
Multiplicative CUIntMax Source # 
type Difference CUIntMax Source # 

newtype CClock :: * #

Haskell type representing the C clock_t type.

Constructors

CClock Int64 

Instances

Enum CClock 
Eq CClock 

Methods

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

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

Num CClock 
Ord CClock 
Read CClock 
Real CClock 
Show CClock 
Storable CClock 
Integral CClock Source # 
Subtractive CClock Source # 

Associated Types

type Difference CClock :: * Source #

Additive CClock Source # 
Multiplicative CClock Source # 
type Difference CClock Source # 

newtype CTime :: * #

Haskell type representing the C time_t type.

Constructors

CTime Int64 

Instances

Enum CTime 
Eq CTime 

Methods

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

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

Num CTime 
Ord CTime 

Methods

compare :: CTime -> CTime -> Ordering #

(<) :: CTime -> CTime -> Bool #

(<=) :: CTime -> CTime -> Bool #

(>) :: CTime -> CTime -> Bool #

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

max :: CTime -> CTime -> CTime #

min :: CTime -> CTime -> CTime #

Read CTime 
Real CTime 

Methods

toRational :: CTime -> Rational #

Show CTime 

Methods

showsPrec :: Int -> CTime -> ShowS #

show :: CTime -> String #

showList :: [CTime] -> ShowS #

Storable CTime 

Methods

sizeOf :: CTime -> Int #

alignment :: CTime -> Int #

peekElemOff :: Ptr CTime -> Int -> IO CTime #

pokeElemOff :: Ptr CTime -> Int -> CTime -> IO () #

peekByteOff :: Ptr b -> Int -> IO CTime #

pokeByteOff :: Ptr b -> Int -> CTime -> IO () #

peek :: Ptr CTime -> IO CTime #

poke :: Ptr CTime -> CTime -> IO () #

Integral CTime Source # 
Subtractive CTime Source # 

Associated Types

type Difference CTime :: * Source #

Additive CTime Source # 
Multiplicative CTime Source # 
type Difference CTime Source # 

newtype CUSeconds :: * #

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 
Integral CUSeconds Source # 
Subtractive CUSeconds Source # 

Associated Types

type Difference CUSeconds :: * Source #

Additive CUSeconds Source # 
Multiplicative CUSeconds Source # 
type Difference CUSeconds Source # 

newtype CSUSeconds :: * #

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 
Integral CSUSeconds Source # 
Subtractive CSUSeconds Source # 
Additive CSUSeconds Source # 
Multiplicative CSUSeconds Source # 
type Difference CSUSeconds Source # 

newtype CFloat :: * #

Haskell type representing the C float type.

Constructors

CFloat Float 

Instances

Enum CFloat 
Eq CFloat 

Methods

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

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

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

Methods

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

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

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

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

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

Show CFloat 
Storable CFloat 
HasNegation CFloat Source # 

Methods

negate :: CFloat -> CFloat Source #

Fractional CFloat Source # 
Integral CFloat Source # 
Subtractive CFloat Source # 

Associated Types

type Difference CFloat :: * Source #

Additive CFloat Source # 
Divisible CFloat Source # 

Methods

(/) :: CFloat -> CFloat -> CFloat Source #

Multiplicative CFloat Source # 
NormalForm CFloat Source # 

Methods

toNormalForm :: CFloat -> () Source #

type Difference CFloat Source # 

data CDouble :: * #

Haskell type representing the C double type.

Instances

Enum CDouble 
Eq CDouble 

Methods

(==) :: CDouble -> CDouble -> Bool #

(/=) :: CDouble -> CDouble -> Bool #

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

Methods

properFraction :: Integral b => CDouble -> (b, CDouble) #

truncate :: Integral b => CDouble -> b #

round :: Integral b => CDouble -> b #

ceiling :: Integral b => CDouble -> b #

floor :: Integral b => CDouble -> b #

Show CDouble 
Storable CDouble 
HasNegation CDouble Source # 
Fractional CDouble Source # 
Integral CDouble Source # 
Subtractive CDouble Source # 

Associated Types

type Difference CDouble :: * Source #

Additive CDouble Source # 
Divisible CDouble Source # 

Methods

(/) :: CDouble -> CDouble -> CDouble Source #

Multiplicative CDouble Source # 
NormalForm CDouble Source # 

Methods

toNormalForm :: CDouble -> () Source #

type Difference CDouble Source # 

newtype COff :: * #

Constructors

COff Int64 

Instances

Bounded COff 
Enum COff 

Methods

succ :: COff -> COff #

pred :: COff -> COff #

toEnum :: Int -> COff #

fromEnum :: COff -> Int #

enumFrom :: COff -> [COff] #

enumFromThen :: COff -> COff -> [COff] #

enumFromTo :: COff -> COff -> [COff] #

enumFromThenTo :: COff -> COff -> COff -> [COff] #

Eq COff 

Methods

(==) :: COff -> COff -> Bool #

(/=) :: COff -> COff -> Bool #

Integral COff 

Methods

quot :: COff -> COff -> COff #

rem :: COff -> COff -> COff #

div :: COff -> COff -> COff #

mod :: COff -> COff -> COff #

quotRem :: COff -> COff -> (COff, COff) #

divMod :: COff -> COff -> (COff, COff) #

toInteger :: COff -> Integer #

Num COff 

Methods

(+) :: COff -> COff -> COff #

(-) :: COff -> COff -> COff #

(*) :: COff -> COff -> COff #

negate :: COff -> COff #

abs :: COff -> COff #

signum :: COff -> COff #

fromInteger :: Integer -> COff #

Ord COff 

Methods

compare :: COff -> COff -> Ordering #

(<) :: COff -> COff -> Bool #

(<=) :: COff -> COff -> Bool #

(>) :: COff -> COff -> Bool #

(>=) :: COff -> COff -> Bool #

max :: COff -> COff -> COff #

min :: COff -> COff -> COff #

Read COff 
Real COff 

Methods

toRational :: COff -> Rational #

Show COff 

Methods

showsPrec :: Int -> COff -> ShowS #

show :: COff -> String #

showList :: [COff] -> ShowS #

Storable COff 

Methods

sizeOf :: COff -> Int #

alignment :: COff -> Int #

peekElemOff :: Ptr COff -> Int -> IO COff #

pokeElemOff :: Ptr COff -> Int -> COff -> IO () #

peekByteOff :: Ptr b -> Int -> IO COff #

pokeByteOff :: Ptr b -> Int -> COff -> IO () #

peek :: Ptr COff -> IO COff #

poke :: Ptr COff -> COff -> IO () #

Bits COff 
FiniteBits COff 
Integral COff Source # 
Subtractive COff Source # 

Associated Types

type Difference COff :: * Source #

Methods

(-) :: COff -> COff -> Difference COff Source #

Additive COff Source # 

Methods

azero :: COff Source #

(+) :: COff -> COff -> COff Source #

scale :: IsNatural n => n -> COff -> COff Source #

Multiplicative COff Source # 

Methods

midentity :: COff Source #

(*) :: COff -> COff -> COff Source #

(^) :: (IsNatural n, IDivisible n) => COff -> n -> COff Source #

type Difference COff Source # 

newtype CMode :: * #

Constructors

CMode Word32 

Instances

Bounded CMode 
Enum CMode 
Eq CMode 

Methods

(==) :: CMode -> CMode -> Bool #

(/=) :: CMode -> CMode -> Bool #

Integral CMode 
Num CMode 
Ord CMode 

Methods

compare :: CMode -> CMode -> Ordering #

(<) :: CMode -> CMode -> Bool #

(<=) :: CMode -> CMode -> Bool #

(>) :: CMode -> CMode -> Bool #

(>=) :: CMode -> CMode -> Bool #

max :: CMode -> CMode -> CMode #

min :: CMode -> CMode -> CMode #

Read CMode 
Real CMode 

Methods

toRational :: CMode -> Rational #

Show CMode 

Methods

showsPrec :: Int -> CMode -> ShowS #

show :: CMode -> String #

showList :: [CMode] -> ShowS #

Storable CMode 

Methods

sizeOf :: CMode -> Int #

alignment :: CMode -> Int #

peekElemOff :: Ptr CMode -> Int -> IO CMode #

pokeElemOff :: Ptr CMode -> Int -> CMode -> IO () #

peekByteOff :: Ptr b -> Int -> IO CMode #

pokeByteOff :: Ptr b -> Int -> CMode -> IO () #

peek :: Ptr CMode -> IO CMode #

poke :: Ptr CMode -> CMode -> IO () #

Bits CMode 
FiniteBits CMode