basement-0.0.7: 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 Word8 

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 # 

Methods

negate :: CChar -> CChar #

Integral CChar # 

Methods

fromInteger :: Integer -> CChar #

IsIntegral CChar # 

Methods

toInteger :: CChar -> Integer #

Subtractive CChar # 

Associated Types

type Difference CChar :: * #

Methods

(-) :: CChar -> CChar -> Difference CChar #

Additive CChar # 

Methods

azero :: CChar #

(+) :: CChar -> CChar -> CChar #

scale :: IsNatural n => n -> CChar -> CChar #

IDivisible CChar # 

Methods

div :: CChar -> CChar -> CChar #

mod :: CChar -> CChar -> CChar #

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

Multiplicative CChar # 

Methods

midentity :: CChar #

(*) :: CChar -> CChar -> CChar #

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

PrimMemoryComparable CChar # 
PrimType CChar # 
NormalForm CChar # 

Methods

toNormalForm :: CChar -> () #

type Difference CChar # 
type PrimSize CChar # 
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 # 

Methods

negate :: CSChar -> CSChar #

Integral CSChar # 
IsIntegral CSChar # 

Methods

toInteger :: CSChar -> Integer #

Subtractive CSChar # 

Associated Types

type Difference CSChar :: * #

Additive CSChar # 

Methods

azero :: CSChar #

(+) :: CSChar -> CSChar -> CSChar #

scale :: IsNatural n => n -> CSChar -> CSChar #

IDivisible CSChar # 

Methods

div :: CSChar -> CSChar -> CSChar #

mod :: CSChar -> CSChar -> CSChar #

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

Multiplicative CSChar # 

Methods

midentity :: CSChar #

(*) :: CSChar -> CSChar -> CSChar #

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

NormalForm CSChar # 

Methods

toNormalForm :: CSChar -> () #

type Difference CSChar # 

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 # 
IsNatural CUChar # 

Methods

toNatural :: CUChar -> Natural #

IsIntegral CUChar # 

Methods

toInteger :: CUChar -> Integer #

Subtractive CUChar # 

Associated Types

type Difference CUChar :: * #

Additive CUChar # 

Methods

azero :: CUChar #

(+) :: CUChar -> CUChar -> CUChar #

scale :: IsNatural n => n -> CUChar -> CUChar #

IDivisible CUChar # 

Methods

div :: CUChar -> CUChar -> CUChar #

mod :: CUChar -> CUChar -> CUChar #

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

Multiplicative CUChar # 

Methods

midentity :: CUChar #

(*) :: CUChar -> CUChar -> CUChar #

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

PrimMemoryComparable CUChar # 
PrimType CUChar # 
NormalForm CUChar # 

Methods

toNormalForm :: CUChar -> () #

type Difference CUChar # 
type PrimSize CUChar # 
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 # 

Methods

negate :: CShort -> CShort #

Integral CShort # 
IsIntegral CShort # 

Methods

toInteger :: CShort -> Integer #

Subtractive CShort # 

Associated Types

type Difference CShort :: * #

Additive CShort # 

Methods

azero :: CShort #

(+) :: CShort -> CShort -> CShort #

scale :: IsNatural n => n -> CShort -> CShort #

IDivisible CShort # 

Methods

div :: CShort -> CShort -> CShort #

mod :: CShort -> CShort -> CShort #

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

Multiplicative CShort # 

Methods

midentity :: CShort #

(*) :: CShort -> CShort -> CShort #

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

NormalForm CShort # 

Methods

toNormalForm :: CShort -> () #

type Difference CShort # 

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 # 
IsNatural CUShort # 

Methods

toNatural :: CUShort -> Natural #

IsIntegral CUShort # 

Methods

toInteger :: CUShort -> Integer #

Subtractive CUShort # 

Associated Types

type Difference CUShort :: * #

Additive CUShort # 

Methods

azero :: CUShort #

(+) :: CUShort -> CUShort -> CUShort #

scale :: IsNatural n => n -> CUShort -> CUShort #

IDivisible CUShort # 
Multiplicative CUShort # 
NormalForm CUShort # 

Methods

toNormalForm :: CUShort -> () #

type Difference CUShort # 

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 # 

Methods

negate :: CInt -> CInt #

Integral CInt # 

Methods

fromInteger :: Integer -> CInt #

IsIntegral CInt # 

Methods

toInteger :: CInt -> Integer #

Subtractive CInt # 

Associated Types

type Difference CInt :: * #

Methods

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

Additive CInt # 

Methods

azero :: CInt #

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

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

IDivisible CInt # 

Methods

div :: CInt -> CInt -> CInt #

mod :: CInt -> CInt -> CInt #

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

Multiplicative CInt # 

Methods

midentity :: CInt #

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

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

NormalForm CInt # 

Methods

toNormalForm :: CInt -> () #

type Difference CInt # 

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 # 

Methods

fromInteger :: Integer -> CUInt #

IsNatural CUInt # 

Methods

toNatural :: CUInt -> Natural #

IsIntegral CUInt # 

Methods

toInteger :: CUInt -> Integer #

Subtractive CUInt # 

Associated Types

type Difference CUInt :: * #

Methods

(-) :: CUInt -> CUInt -> Difference CUInt #

Additive CUInt # 

Methods

azero :: CUInt #

(+) :: CUInt -> CUInt -> CUInt #

scale :: IsNatural n => n -> CUInt -> CUInt #

IDivisible CUInt # 

Methods

div :: CUInt -> CUInt -> CUInt #

mod :: CUInt -> CUInt -> CUInt #

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

Multiplicative CUInt # 

Methods

midentity :: CUInt #

(*) :: CUInt -> CUInt -> CUInt #

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

NormalForm CUInt # 

Methods

toNormalForm :: CUInt -> () #

type Difference CUInt # 

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 # 

Methods

negate :: CLong -> CLong #

Integral CLong # 

Methods

fromInteger :: Integer -> CLong #

IsIntegral CLong # 

Methods

toInteger :: CLong -> Integer #

Subtractive CLong # 

Associated Types

type Difference CLong :: * #

Methods

(-) :: CLong -> CLong -> Difference CLong #

Additive CLong # 

Methods

azero :: CLong #

(+) :: CLong -> CLong -> CLong #

scale :: IsNatural n => n -> CLong -> CLong #

IDivisible CLong # 

Methods

div :: CLong -> CLong -> CLong #

mod :: CLong -> CLong -> CLong #

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

Multiplicative CLong # 

Methods

midentity :: CLong #

(*) :: CLong -> CLong -> CLong #

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

NormalForm CLong # 

Methods

toNormalForm :: CLong -> () #

type Difference CLong # 

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 # 
IsNatural CULong # 

Methods

toNatural :: CULong -> Natural #

IsIntegral CULong # 

Methods

toInteger :: CULong -> Integer #

Subtractive CULong # 

Associated Types

type Difference CULong :: * #

Additive CULong # 

Methods

azero :: CULong #

(+) :: CULong -> CULong -> CULong #

scale :: IsNatural n => n -> CULong -> CULong #

IDivisible CULong # 

Methods

div :: CULong -> CULong -> CULong #

mod :: CULong -> CULong -> CULong #

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

Multiplicative CULong # 

Methods

midentity :: CULong #

(*) :: CULong -> CULong -> CULong #

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

NormalForm CULong # 

Methods

toNormalForm :: CULong -> () #

type Difference CULong # 

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 # 

Methods

negate :: CPtrdiff -> CPtrdiff #

Integral CPtrdiff # 
IsIntegral CPtrdiff # 
Subtractive CPtrdiff # 

Associated Types

type Difference CPtrdiff :: * #

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

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 # 

Methods

fromInteger :: Integer -> CSize #

IsNatural CSize # 

Methods

toNatural :: CSize -> Natural #

IsIntegral CSize # 

Methods

toInteger :: CSize -> Integer #

Subtractive CSize # 

Associated Types

type Difference CSize :: * #

Methods

(-) :: CSize -> CSize -> Difference CSize #

Additive CSize # 

Methods

azero :: CSize #

(+) :: CSize -> CSize -> CSize #

scale :: IsNatural n => n -> CSize -> CSize #

IDivisible CSize # 

Methods

div :: CSize -> CSize -> CSize #

mod :: CSize -> CSize -> CSize #

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

Multiplicative CSize # 

Methods

midentity :: CSize #

(*) :: CSize -> CSize -> CSize #

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

type Difference CSize # 

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 # 

Methods

negate :: CWchar -> CWchar #

Integral CWchar # 
IsIntegral CWchar # 

Methods

toInteger :: CWchar -> Integer #

Subtractive CWchar # 

Associated Types

type Difference CWchar :: * #

Additive CWchar # 

Methods

azero :: CWchar #

(+) :: CWchar -> CWchar -> CWchar #

scale :: IsNatural n => n -> CWchar -> CWchar #

IDivisible CWchar # 

Methods

div :: CWchar -> CWchar -> CWchar #

mod :: CWchar -> CWchar -> CWchar #

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

Multiplicative CWchar # 

Methods

midentity :: CWchar #

(*) :: CWchar -> CWchar -> CWchar #

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

type Difference CWchar # 

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 # 
IsIntegral CSigAtomic # 
Subtractive CSigAtomic # 

Associated Types

type Difference CSigAtomic :: * #

Additive CSigAtomic # 
IDivisible CSigAtomic # 
Multiplicative CSigAtomic # 
type Difference CSigAtomic # 

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 # 

Methods

negate :: CLLong -> CLLong #

Integral CLLong # 
IsIntegral CLLong # 

Methods

toInteger :: CLLong -> Integer #

Subtractive CLLong # 

Associated Types

type Difference CLLong :: * #

Additive CLLong # 

Methods

azero :: CLLong #

(+) :: CLLong -> CLLong -> CLLong #

scale :: IsNatural n => n -> CLLong -> CLLong #

IDivisible CLLong # 

Methods

div :: CLLong -> CLLong -> CLLong #

mod :: CLLong -> CLLong -> CLLong #

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

Multiplicative CLLong # 

Methods

midentity :: CLLong #

(*) :: CLLong -> CLLong -> CLLong #

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

NormalForm CLLong # 

Methods

toNormalForm :: CLLong -> () #

type Difference CLLong # 

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 # 
IsNatural CULLong # 

Methods

toNatural :: CULLong -> Natural #

IsIntegral CULLong # 

Methods

toInteger :: CULLong -> Integer #

Subtractive CULLong # 

Associated Types

type Difference CULLong :: * #

Additive CULLong # 

Methods

azero :: CULLong #

(+) :: CULLong -> CULLong -> CULLong #

scale :: IsNatural n => n -> CULLong -> CULLong #

IDivisible CULLong # 
Multiplicative CULLong # 
NormalForm CULLong # 

Methods

toNormalForm :: CULLong -> () #

type Difference CULLong # 

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 # 

Methods

fromInteger :: Integer -> CBool #

IsIntegral CBool # 

Methods

toInteger :: CBool -> Integer #

Subtractive CBool # 

Associated Types

type Difference CBool :: * #

Methods

(-) :: CBool -> CBool -> Difference CBool #

type Difference CBool # 

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 # 
IsIntegral CIntPtr # 

Methods

toInteger :: CIntPtr -> Integer #

Subtractive CIntPtr # 

Associated Types

type Difference CIntPtr :: * #

Additive CIntPtr # 

Methods

azero :: CIntPtr #

(+) :: CIntPtr -> CIntPtr -> CIntPtr #

scale :: IsNatural n => n -> CIntPtr -> CIntPtr #

IDivisible CIntPtr # 
Multiplicative CIntPtr # 
type Difference CIntPtr # 

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

Associated Types

type Difference CUIntPtr :: * #

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

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 # 

Methods

negate :: CIntMax -> CIntMax #

Integral CIntMax # 
IsIntegral CIntMax # 

Methods

toInteger :: CIntMax -> Integer #

Subtractive CIntMax # 

Associated Types

type Difference CIntMax :: * #

Additive CIntMax # 

Methods

azero :: CIntMax #

(+) :: CIntMax -> CIntMax -> CIntMax #

scale :: IsNatural n => n -> CIntMax -> CIntMax #

IDivisible CIntMax # 
Multiplicative CIntMax # 
type Difference CIntMax # 

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

Associated Types

type Difference CUIntMax :: * #

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

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 # 
Subtractive CClock # 

Associated Types

type Difference CClock :: * #

Additive CClock # 

Methods

azero :: CClock #

(+) :: CClock -> CClock -> CClock #

scale :: IsNatural n => n -> CClock -> CClock #

Multiplicative CClock # 

Methods

midentity :: CClock #

(*) :: CClock -> CClock -> CClock #

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

type Difference CClock # 

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 # 

Methods

fromInteger :: Integer -> CTime #

Subtractive CTime # 

Associated Types

type Difference CTime :: * #

Methods

(-) :: CTime -> CTime -> Difference CTime #

Additive CTime # 

Methods

azero :: CTime #

(+) :: CTime -> CTime -> CTime #

scale :: IsNatural n => n -> CTime -> CTime #

Multiplicative CTime # 

Methods

midentity :: CTime #

(*) :: CTime -> CTime -> CTime #

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

type Difference CTime # 

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

Associated Types

type Difference CUSeconds :: * #

Additive CUSeconds # 
Multiplicative CUSeconds # 
type Difference CUSeconds # 

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 # 
Subtractive CSUSeconds # 

Associated Types

type Difference CSUSeconds :: * #

Additive CSUSeconds # 
Multiplicative CSUSeconds # 
type Difference CSUSeconds # 

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 # 

Methods

negate :: CFloat -> CFloat #

Fractional CFloat # 
Integral CFloat # 
Subtractive CFloat # 

Associated Types

type Difference CFloat :: * #

Additive CFloat # 

Methods

azero :: CFloat #

(+) :: CFloat -> CFloat -> CFloat #

scale :: IsNatural n => n -> CFloat -> CFloat #

Divisible CFloat # 

Methods

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

Multiplicative CFloat # 

Methods

midentity :: CFloat #

(*) :: CFloat -> CFloat -> CFloat #

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

NormalForm CFloat # 

Methods

toNormalForm :: CFloat -> () #

type Difference CFloat # 

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 # 

Methods

negate :: CDouble -> CDouble #

Fractional CDouble # 
Integral CDouble # 
Subtractive CDouble # 

Associated Types

type Difference CDouble :: * #

Additive CDouble # 

Methods

azero :: CDouble #

(+) :: CDouble -> CDouble -> CDouble #

scale :: IsNatural n => n -> CDouble -> CDouble #

Divisible CDouble # 

Methods

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

Multiplicative CDouble # 
NormalForm CDouble # 

Methods

toNormalForm :: CDouble -> () #

type Difference CDouble # 

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 # 

Methods

fromInteger :: Integer -> COff #

Subtractive COff # 

Associated Types

type Difference COff :: * #

Methods

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

Additive COff # 

Methods

azero :: COff #

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

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

Multiplicative COff # 

Methods

midentity :: COff #

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

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

type Difference COff # 

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