License	BSD-style
Maintainer	Foundation
Safe Haskell	Safe
Language	Haskell2010

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
Methods minBound :: CChar # maxBound :: CChar #
Enum CChar
Methods succ :: CChar -> CChar # pred :: CChar -> CChar # toEnum :: Int -> CChar # fromEnum :: CChar -> Int # enumFrom :: CChar -> [CChar] # enumFromThen :: CChar -> CChar -> [CChar] # enumFromTo :: CChar -> CChar -> [CChar] # enumFromThenTo :: CChar -> CChar -> CChar -> [CChar] #
Eq CChar
Methods (==) :: CChar -> CChar -> Bool # (/=) :: CChar -> CChar -> Bool #
Integral CChar
Methods quot :: CChar -> CChar -> CChar # rem :: CChar -> CChar -> CChar # div :: CChar -> CChar -> CChar # mod :: CChar -> CChar -> CChar # quotRem :: CChar -> CChar -> (CChar, CChar) # divMod :: CChar -> CChar -> (CChar, CChar) # toInteger :: CChar -> Integer #
Num CChar
Methods (+) :: CChar -> CChar -> CChar # (-) :: CChar -> CChar -> CChar # (*) :: CChar -> CChar -> CChar # negate :: CChar -> CChar # abs :: CChar -> CChar # signum :: CChar -> CChar # fromInteger :: Integer -> 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
Methods readsPrec :: Int -> ReadS CChar # readList :: ReadS [CChar] # readPrec :: ReadPrec CChar # readListPrec :: ReadPrec [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
Methods (.&.) :: CChar -> CChar -> CChar # (.\|.) :: CChar -> CChar -> CChar # xor :: CChar -> CChar -> CChar # complement :: CChar -> CChar # shift :: CChar -> Int -> CChar # rotate :: CChar -> Int -> CChar # zeroBits :: CChar # bit :: Int -> CChar # setBit :: CChar -> Int -> CChar # clearBit :: CChar -> Int -> CChar # complementBit :: CChar -> Int -> CChar # testBit :: CChar -> Int -> Bool # bitSizeMaybe :: CChar -> Maybe Int # bitSize :: CChar -> Int # isSigned :: CChar -> Bool # shiftL :: CChar -> Int -> CChar # unsafeShiftL :: CChar -> Int -> CChar # shiftR :: CChar -> Int -> CChar # unsafeShiftR :: CChar -> Int -> CChar # rotateL :: CChar -> Int -> CChar # rotateR :: CChar -> Int -> CChar # popCount :: CChar -> Int #
FiniteBits CChar
Methods finiteBitSize :: CChar -> Int # countLeadingZeros :: CChar -> Int # countTrailingZeros :: CChar -> Int #
HasNegation CChar Source #
Methods negate :: CChar -> CChar Source #
Integral CChar Source #
Methods fromInteger :: Integer -> CChar Source #
IsIntegral CChar Source #
Methods toInteger :: CChar -> Integer Source #
Subtractive CChar Source #
Associated Types type Difference CChar :: * Source # Methods (-) :: CChar -> CChar -> Difference CChar Source #
Additive CChar Source #
Methods azero :: CChar Source # (+) :: CChar -> CChar -> CChar Source # scale :: IsNatural n => n -> CChar -> CChar Source #
IDivisible CChar Source #
Methods div :: CChar -> CChar -> CChar Source # mod :: CChar -> CChar -> CChar Source # divMod :: CChar -> CChar -> (CChar, CChar) Source #
Multiplicative CChar Source #
Methods midentity :: CChar Source # (*) :: CChar -> CChar -> CChar Source # (^) :: (IsNatural n, IDivisible n) => CChar -> n -> CChar Source #
PrimMemoryComparable CChar Source #

PrimType CChar Source #
Associated Types type PrimSize CChar :: Nat Source # Methods primSizeInBytes :: Proxy * CChar -> CountOf Word8 Source # primShiftToBytes :: Proxy * CChar -> Int Source # primBaUIndex :: ByteArray# -> Offset CChar -> CChar Source # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset CChar -> prim CChar Source # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset CChar -> CChar -> prim () Source # primAddrIndex :: Addr# -> Offset CChar -> CChar Source # primAddrRead :: PrimMonad prim => Addr# -> Offset CChar -> prim CChar Source # primAddrWrite :: PrimMonad prim => Addr# -> Offset CChar -> CChar -> prim () Source #
NormalForm CChar Source #
Methods toNormalForm :: CChar -> () Source #
type Difference CChar Source #
type Difference CChar = CChar
type PrimSize CChar Source #
type PrimSize CChar = 1

newtype CSChar :: * #

Haskell type representing the C signed char type.

Constructors

CSChar Int8

Instances

Bounded CSChar
Methods minBound :: CSChar # maxBound :: CSChar #
Enum CSChar
Methods succ :: CSChar -> CSChar # pred :: CSChar -> CSChar # toEnum :: Int -> CSChar # fromEnum :: CSChar -> Int # enumFrom :: CSChar -> [CSChar] # enumFromThen :: CSChar -> CSChar -> [CSChar] # enumFromTo :: CSChar -> CSChar -> [CSChar] # enumFromThenTo :: CSChar -> CSChar -> CSChar -> [CSChar] #
Eq CSChar
Methods (==) :: CSChar -> CSChar -> Bool # (/=) :: CSChar -> CSChar -> Bool #
Integral CSChar
Methods quot :: CSChar -> CSChar -> CSChar # rem :: CSChar -> CSChar -> CSChar # div :: CSChar -> CSChar -> CSChar # mod :: CSChar -> CSChar -> CSChar # quotRem :: CSChar -> CSChar -> (CSChar, CSChar) # divMod :: CSChar -> CSChar -> (CSChar, CSChar) # toInteger :: CSChar -> Integer #
Num CSChar
Methods (+) :: CSChar -> CSChar -> CSChar # (-) :: CSChar -> CSChar -> CSChar # (*) :: CSChar -> CSChar -> CSChar # negate :: CSChar -> CSChar # abs :: CSChar -> CSChar # signum :: CSChar -> CSChar # fromInteger :: Integer -> CSChar #
Ord CSChar
Methods compare :: CSChar -> CSChar -> Ordering # (<) :: CSChar -> CSChar -> Bool # (<=) :: CSChar -> CSChar -> Bool # (>) :: CSChar -> CSChar -> Bool # (>=) :: CSChar -> CSChar -> Bool # max :: CSChar -> CSChar -> CSChar # min :: CSChar -> CSChar -> CSChar #
Read CSChar
Methods readsPrec :: Int -> ReadS CSChar # readList :: ReadS [CSChar] # readPrec :: ReadPrec CSChar # readListPrec :: ReadPrec [CSChar] #
Real CSChar
Methods toRational :: CSChar -> Rational #
Show CSChar
Methods showsPrec :: Int -> CSChar -> ShowS # show :: CSChar -> String # showList :: [CSChar] -> ShowS #
Storable CSChar
Methods sizeOf :: CSChar -> Int # alignment :: CSChar -> Int # peekElemOff :: Ptr CSChar -> Int -> IO CSChar # pokeElemOff :: Ptr CSChar -> Int -> CSChar -> IO () # peekByteOff :: Ptr b -> Int -> IO CSChar # pokeByteOff :: Ptr b -> Int -> CSChar -> IO () # peek :: Ptr CSChar -> IO CSChar # poke :: Ptr CSChar -> CSChar -> IO () #
Bits CSChar
Methods (.&.) :: CSChar -> CSChar -> CSChar # (.\|.) :: CSChar -> CSChar -> CSChar # xor :: CSChar -> CSChar -> CSChar # complement :: CSChar -> CSChar # shift :: CSChar -> Int -> CSChar # rotate :: CSChar -> Int -> CSChar # zeroBits :: CSChar # bit :: Int -> CSChar # setBit :: CSChar -> Int -> CSChar # clearBit :: CSChar -> Int -> CSChar # complementBit :: CSChar -> Int -> CSChar # testBit :: CSChar -> Int -> Bool # bitSizeMaybe :: CSChar -> Maybe Int # bitSize :: CSChar -> Int # isSigned :: CSChar -> Bool # shiftL :: CSChar -> Int -> CSChar # unsafeShiftL :: CSChar -> Int -> CSChar # shiftR :: CSChar -> Int -> CSChar # unsafeShiftR :: CSChar -> Int -> CSChar # rotateL :: CSChar -> Int -> CSChar # rotateR :: CSChar -> Int -> CSChar # popCount :: CSChar -> Int #
FiniteBits CSChar
Methods finiteBitSize :: CSChar -> Int # countLeadingZeros :: CSChar -> Int # countTrailingZeros :: CSChar -> Int #
HasNegation CSChar Source #
Methods negate :: CSChar -> CSChar Source #
Integral CSChar Source #
Methods fromInteger :: Integer -> CSChar Source #
IsIntegral CSChar Source #
Methods toInteger :: CSChar -> Integer Source #
Subtractive CSChar Source #
Associated Types type Difference CSChar :: * Source # Methods (-) :: CSChar -> CSChar -> Difference CSChar Source #
Additive CSChar Source #
Methods azero :: CSChar Source # (+) :: CSChar -> CSChar -> CSChar Source # scale :: IsNatural n => n -> CSChar -> CSChar Source #
IDivisible CSChar Source #
Methods div :: CSChar -> CSChar -> CSChar Source # mod :: CSChar -> CSChar -> CSChar Source # divMod :: CSChar -> CSChar -> (CSChar, CSChar) Source #
Multiplicative CSChar Source #
Methods midentity :: CSChar Source # (*) :: CSChar -> CSChar -> CSChar Source # (^) :: (IsNatural n, IDivisible n) => CSChar -> n -> CSChar Source #
NormalForm CSChar Source #
Methods toNormalForm :: CSChar -> () Source #
type Difference CSChar Source #
type Difference CSChar = CSChar

newtype CUChar :: * #

Haskell type representing the C unsigned char type.

Constructors

CUChar Word8

Instances

Bounded CUChar
Methods minBound :: CUChar # maxBound :: CUChar #
Enum CUChar
Methods succ :: CUChar -> CUChar # pred :: CUChar -> CUChar # toEnum :: Int -> CUChar # fromEnum :: CUChar -> Int # enumFrom :: CUChar -> [CUChar] # enumFromThen :: CUChar -> CUChar -> [CUChar] # enumFromTo :: CUChar -> CUChar -> [CUChar] # enumFromThenTo :: CUChar -> CUChar -> CUChar -> [CUChar] #
Eq CUChar
Methods (==) :: CUChar -> CUChar -> Bool # (/=) :: CUChar -> CUChar -> Bool #
Integral CUChar
Methods quot :: CUChar -> CUChar -> CUChar # rem :: CUChar -> CUChar -> CUChar # div :: CUChar -> CUChar -> CUChar # mod :: CUChar -> CUChar -> CUChar # quotRem :: CUChar -> CUChar -> (CUChar, CUChar) # divMod :: CUChar -> CUChar -> (CUChar, CUChar) # toInteger :: CUChar -> Integer #
Num CUChar
Methods (+) :: CUChar -> CUChar -> CUChar # (-) :: CUChar -> CUChar -> CUChar # (*) :: CUChar -> CUChar -> CUChar # negate :: CUChar -> CUChar # abs :: CUChar -> CUChar # signum :: CUChar -> CUChar # fromInteger :: Integer -> CUChar #
Ord CUChar
Methods compare :: CUChar -> CUChar -> Ordering # (<) :: CUChar -> CUChar -> Bool # (<=) :: CUChar -> CUChar -> Bool # (>) :: CUChar -> CUChar -> Bool # (>=) :: CUChar -> CUChar -> Bool # max :: CUChar -> CUChar -> CUChar # min :: CUChar -> CUChar -> CUChar #
Read CUChar
Methods readsPrec :: Int -> ReadS CUChar # readList :: ReadS [CUChar] # readPrec :: ReadPrec CUChar # readListPrec :: ReadPrec [CUChar] #
Real CUChar
Methods toRational :: CUChar -> Rational #
Show CUChar
Methods showsPrec :: Int -> CUChar -> ShowS # show :: CUChar -> String # showList :: [CUChar] -> ShowS #
Storable CUChar
Methods sizeOf :: CUChar -> Int # alignment :: CUChar -> Int # peekElemOff :: Ptr CUChar -> Int -> IO CUChar # pokeElemOff :: Ptr CUChar -> Int -> CUChar -> IO () # peekByteOff :: Ptr b -> Int -> IO CUChar # pokeByteOff :: Ptr b -> Int -> CUChar -> IO () # peek :: Ptr CUChar -> IO CUChar # poke :: Ptr CUChar -> CUChar -> IO () #
Bits CUChar
Methods (.&.) :: CUChar -> CUChar -> CUChar # (.\|.) :: CUChar -> CUChar -> CUChar # xor :: CUChar -> CUChar -> CUChar # complement :: CUChar -> CUChar # shift :: CUChar -> Int -> CUChar # rotate :: CUChar -> Int -> CUChar # zeroBits :: CUChar # bit :: Int -> CUChar # setBit :: CUChar -> Int -> CUChar # clearBit :: CUChar -> Int -> CUChar # complementBit :: CUChar -> Int -> CUChar # testBit :: CUChar -> Int -> Bool # bitSizeMaybe :: CUChar -> Maybe Int # bitSize :: CUChar -> Int # isSigned :: CUChar -> Bool # shiftL :: CUChar -> Int -> CUChar # unsafeShiftL :: CUChar -> Int -> CUChar # shiftR :: CUChar -> Int -> CUChar # unsafeShiftR :: CUChar -> Int -> CUChar # rotateL :: CUChar -> Int -> CUChar # rotateR :: CUChar -> Int -> CUChar # popCount :: CUChar -> Int #
FiniteBits CUChar
Methods finiteBitSize :: CUChar -> Int # countLeadingZeros :: CUChar -> Int # countTrailingZeros :: CUChar -> Int #
Integral CUChar Source #
Methods fromInteger :: Integer -> CUChar Source #
IsNatural CUChar Source #
Methods toNatural :: CUChar -> Natural Source #
IsIntegral CUChar Source #
Methods toInteger :: CUChar -> Integer Source #
Subtractive CUChar Source #
Associated Types type Difference CUChar :: * Source # Methods (-) :: CUChar -> CUChar -> Difference CUChar Source #
Additive CUChar Source #
Methods azero :: CUChar Source # (+) :: CUChar -> CUChar -> CUChar Source # scale :: IsNatural n => n -> CUChar -> CUChar Source #
IDivisible CUChar Source #
Methods div :: CUChar -> CUChar -> CUChar Source # mod :: CUChar -> CUChar -> CUChar Source # divMod :: CUChar -> CUChar -> (CUChar, CUChar) Source #
Multiplicative CUChar Source #
Methods midentity :: CUChar Source # (*) :: CUChar -> CUChar -> CUChar Source # (^) :: (IsNatural n, IDivisible n) => CUChar -> n -> CUChar Source #
PrimMemoryComparable CUChar Source #

PrimType CUChar Source #
Associated Types type PrimSize CUChar :: Nat Source # Methods primSizeInBytes :: Proxy * CUChar -> CountOf Word8 Source # primShiftToBytes :: Proxy * CUChar -> Int Source # primBaUIndex :: ByteArray# -> Offset CUChar -> CUChar Source # primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset CUChar -> prim CUChar Source # primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset CUChar -> CUChar -> prim () Source # primAddrIndex :: Addr# -> Offset CUChar -> CUChar Source # primAddrRead :: PrimMonad prim => Addr# -> Offset CUChar -> prim CUChar Source # primAddrWrite :: PrimMonad prim => Addr# -> Offset CUChar -> CUChar -> prim () Source #
NormalForm CUChar Source #
Methods toNormalForm :: CUChar -> () Source #
type Difference CUChar Source #
type Difference CUChar = CUChar
type PrimSize CUChar Source #
type PrimSize CUChar = 1

newtype CShort :: * #

Haskell type representing the C short type.

Constructors

CShort Int16

Instances

Bounded CShort
Methods minBound :: CShort # maxBound :: CShort #
Enum CShort
Methods succ :: CShort -> CShort # pred :: CShort -> CShort # toEnum :: Int -> CShort # fromEnum :: CShort -> Int # enumFrom :: CShort -> [CShort] # enumFromThen :: CShort -> CShort -> [CShort] # enumFromTo :: CShort -> CShort -> [CShort] # enumFromThenTo :: CShort -> CShort -> CShort -> [CShort] #
Eq CShort
Methods (==) :: CShort -> CShort -> Bool # (/=) :: CShort -> CShort -> Bool #
Integral CShort
Methods quot :: CShort -> CShort -> CShort # rem :: CShort -> CShort -> CShort # div :: CShort -> CShort -> CShort # mod :: CShort -> CShort -> CShort # quotRem :: CShort -> CShort -> (CShort, CShort) # divMod :: CShort -> CShort -> (CShort, CShort) # toInteger :: CShort -> Integer #
Num CShort
Methods (+) :: CShort -> CShort -> CShort # (-) :: CShort -> CShort -> CShort # (*) :: CShort -> CShort -> CShort # negate :: CShort -> CShort # abs :: CShort -> CShort # signum :: CShort -> CShort # fromInteger :: Integer -> CShort #
Ord CShort
Methods compare :: CShort -> CShort -> Ordering # (<) :: CShort -> CShort -> Bool # (<=) :: CShort -> CShort -> Bool # (>) :: CShort -> CShort -> Bool # (>=) :: CShort -> CShort -> Bool # max :: CShort -> CShort -> CShort # min :: CShort -> CShort -> CShort #
Read CShort
Methods readsPrec :: Int -> ReadS CShort # readList :: ReadS [CShort] # readPrec :: ReadPrec CShort # readListPrec :: ReadPrec [CShort] #
Real CShort
Methods toRational :: CShort -> Rational #
Show CShort
Methods showsPrec :: Int -> CShort -> ShowS # show :: CShort -> String # showList :: [CShort] -> ShowS #
Storable CShort
Methods sizeOf :: CShort -> Int # alignment :: CShort -> Int # peekElemOff :: Ptr CShort -> Int -> IO CShort # pokeElemOff :: Ptr CShort -> Int -> CShort -> IO () # peekByteOff :: Ptr b -> Int -> IO CShort # pokeByteOff :: Ptr b -> Int -> CShort -> IO () # peek :: Ptr CShort -> IO CShort # poke :: Ptr CShort -> CShort -> IO () #
Bits CShort
Methods (.&.) :: CShort -> CShort -> CShort # (.\|.) :: CShort -> CShort -> CShort # xor :: CShort -> CShort -> CShort # complement :: CShort -> CShort # shift :: CShort -> Int -> CShort # rotate :: CShort -> Int -> CShort # zeroBits :: CShort # bit :: Int -> CShort # setBit :: CShort -> Int -> CShort # clearBit :: CShort -> Int -> CShort # complementBit :: CShort -> Int -> CShort # testBit :: CShort -> Int -> Bool # bitSizeMaybe :: CShort -> Maybe Int # bitSize :: CShort -> Int # isSigned :: CShort -> Bool # shiftL :: CShort -> Int -> CShort # unsafeShiftL :: CShort -> Int -> CShort # shiftR :: CShort -> Int -> CShort # unsafeShiftR :: CShort -> Int -> CShort # rotateL :: CShort -> Int -> CShort # rotateR :: CShort -> Int -> CShort # popCount :: CShort -> Int #
FiniteBits CShort
Methods finiteBitSize :: CShort -> Int # countLeadingZeros :: CShort -> Int # countTrailingZeros :: CShort -> Int #
HasNegation CShort Source #
Methods negate :: CShort -> CShort Source #
Integral CShort Source #
Methods fromInteger :: Integer -> CShort Source #
IsIntegral CShort Source #
Methods toInteger :: CShort -> Integer Source #
Subtractive CShort Source #
Associated Types type Difference CShort :: * Source # Methods (-) :: CShort -> CShort -> Difference CShort Source #
Additive CShort Source #
Methods azero :: CShort Source # (+) :: CShort -> CShort -> CShort Source # scale :: IsNatural n => n -> CShort -> CShort Source #
IDivisible CShort Source #
Methods div :: CShort -> CShort -> CShort Source # mod :: CShort -> CShort -> CShort Source # divMod :: CShort -> CShort -> (CShort, CShort) Source #
Multiplicative CShort Source #
Methods midentity :: CShort Source # (*) :: CShort -> CShort -> CShort Source # (^) :: (IsNatural n, IDivisible n) => CShort -> n -> CShort Source #
NormalForm CShort Source #
Methods toNormalForm :: CShort -> () Source #
type Difference CShort Source #
type Difference CShort = CShort

newtype CUShort :: * #

Haskell type representing the C unsigned short type.

Constructors

CUShort Word16

Instances

Bounded CUShort
Methods minBound :: CUShort # maxBound :: CUShort #
Enum CUShort
Methods succ :: CUShort -> CUShort # pred :: CUShort -> CUShort # toEnum :: Int -> CUShort # fromEnum :: CUShort -> Int # enumFrom :: CUShort -> [CUShort] # enumFromThen :: CUShort -> CUShort -> [CUShort] # enumFromTo :: CUShort -> CUShort -> [CUShort] # enumFromThenTo :: CUShort -> CUShort -> CUShort -> [CUShort] #
Eq CUShort
Methods (==) :: CUShort -> CUShort -> Bool # (/=) :: CUShort -> CUShort -> Bool #
Integral CUShort
Methods quot :: CUShort -> CUShort -> CUShort # rem :: CUShort -> CUShort -> CUShort # div :: CUShort -> CUShort -> CUShort # mod :: CUShort -> CUShort -> CUShort # quotRem :: CUShort -> CUShort -> (CUShort, CUShort) # divMod :: CUShort -> CUShort -> (CUShort, CUShort) # toInteger :: CUShort -> Integer #
Num CUShort
Methods (+) :: CUShort -> CUShort -> CUShort # (-) :: CUShort -> CUShort -> CUShort # (*) :: CUShort -> CUShort -> CUShort # negate :: CUShort -> CUShort # abs :: CUShort -> CUShort # signum :: CUShort -> CUShort # fromInteger :: Integer -> CUShort #
Ord CUShort
Methods compare :: CUShort -> CUShort -> Ordering # (<) :: CUShort -> CUShort -> Bool # (<=) :: CUShort -> CUShort -> Bool # (>) :: CUShort -> CUShort -> Bool # (>=) :: CUShort -> CUShort -> Bool # max :: CUShort -> CUShort -> CUShort # min :: CUShort -> CUShort -> CUShort #
Read CUShort
Methods readsPrec :: Int -> ReadS CUShort # readList :: ReadS [CUShort] # readPrec :: ReadPrec CUShort # readListPrec :: ReadPrec [CUShort] #
Real CUShort
Methods toRational :: CUShort -> Rational #
Show CUShort
Methods showsPrec :: Int -> CUShort -> ShowS # show :: CUShort -> String # showList :: [CUShort] -> ShowS #
Storable CUShort
Methods sizeOf :: CUShort -> Int # alignment :: CUShort -> Int # peekElemOff :: Ptr CUShort -> Int -> IO CUShort # pokeElemOff :: Ptr CUShort -> Int -> CUShort -> IO () # peekByteOff :: Ptr b -> Int -> IO CUShort # pokeByteOff :: Ptr b -> Int -> CUShort -> IO () # peek :: Ptr CUShort -> IO CUShort # poke :: Ptr CUShort -> CUShort -> IO () #
Bits CUShort
Methods (.&.) :: CUShort -> CUShort -> CUShort # (.\|.) :: CUShort -> CUShort -> CUShort # xor :: CUShort -> CUShort -> CUShort # complement :: CUShort -> CUShort # shift :: CUShort -> Int -> CUShort # rotate :: CUShort -> Int -> CUShort # zeroBits :: CUShort # bit :: Int -> CUShort # setBit :: CUShort -> Int -> CUShort # clearBit :: CUShort -> Int -> CUShort # complementBit :: CUShort -> Int -> CUShort # testBit :: CUShort -> Int -> Bool # bitSizeMaybe :: CUShort -> Maybe Int # bitSize :: CUShort -> Int # isSigned :: CUShort -> Bool # shiftL :: CUShort -> Int -> CUShort # unsafeShiftL :: CUShort -> Int -> CUShort # shiftR :: CUShort -> Int -> CUShort # unsafeShiftR :: CUShort -> Int -> CUShort # rotateL :: CUShort -> Int -> CUShort # rotateR :: CUShort -> Int -> CUShort # popCount :: CUShort -> Int #
FiniteBits CUShort
Methods finiteBitSize :: CUShort -> Int # countLeadingZeros :: CUShort -> Int # countTrailingZeros :: CUShort -> Int #
Integral CUShort Source #
Methods fromInteger :: Integer -> CUShort Source #
IsNatural CUShort Source #
Methods toNatural :: CUShort -> Natural Source #
IsIntegral CUShort Source #
Methods toInteger :: CUShort -> Integer Source #
Subtractive CUShort Source #
Associated Types type Difference CUShort :: * Source # Methods (-) :: CUShort -> CUShort -> Difference CUShort Source #
Additive CUShort Source #
Methods azero :: CUShort Source # (+) :: CUShort -> CUShort -> CUShort Source # scale :: IsNatural n => n -> CUShort -> CUShort Source #
IDivisible CUShort Source #
Methods div :: CUShort -> CUShort -> CUShort Source # mod :: CUShort -> CUShort -> CUShort Source # divMod :: CUShort -> CUShort -> (CUShort, CUShort) Source #
Multiplicative CUShort Source #
Methods midentity :: CUShort Source # (*) :: CUShort -> CUShort -> CUShort Source # (^) :: (IsNatural n, IDivisible n) => CUShort -> n -> CUShort Source #
NormalForm CUShort Source #
Methods toNormalForm :: CUShort -> () Source #
type Difference CUShort Source #
type Difference CUShort = CUShort

newtype CInt :: * #

Haskell type representing the C int type.

Constructors

CInt Int32

Instances

Bounded CInt
Methods minBound :: CInt # maxBound :: 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
Methods readsPrec :: Int -> ReadS CInt # readList :: ReadS [CInt] # readPrec :: ReadPrec CInt # readListPrec :: ReadPrec [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
Methods (.&.) :: CInt -> CInt -> CInt # (.\|.) :: CInt -> CInt -> CInt # xor :: CInt -> CInt -> CInt # complement :: CInt -> CInt # shift :: CInt -> Int -> CInt # rotate :: CInt -> Int -> CInt # zeroBits :: CInt # bit :: Int -> CInt # setBit :: CInt -> Int -> CInt # clearBit :: CInt -> Int -> CInt # complementBit :: CInt -> Int -> CInt # testBit :: CInt -> Int -> Bool # bitSizeMaybe :: CInt -> Maybe Int # bitSize :: CInt -> Int # isSigned :: CInt -> Bool # shiftL :: CInt -> Int -> CInt # unsafeShiftL :: CInt -> Int -> CInt # shiftR :: CInt -> Int -> CInt # unsafeShiftR :: CInt -> Int -> CInt # rotateL :: CInt -> Int -> CInt # rotateR :: CInt -> Int -> CInt # popCount :: CInt -> Int #
FiniteBits CInt
Methods finiteBitSize :: CInt -> Int # countLeadingZeros :: CInt -> Int # countTrailingZeros :: CInt -> Int #
HasNegation CInt Source #
Methods negate :: CInt -> CInt Source #
Integral CInt Source #
Methods fromInteger :: Integer -> CInt Source #
IsIntegral CInt Source #
Methods toInteger :: CInt -> Integer 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 #
type Difference CInt = CInt

newtype CUInt :: * #

Haskell type representing the C unsigned int type.

Constructors

CUInt Word32

Instances

Bounded CUInt
Methods minBound :: CUInt # maxBound :: CUInt #
Enum CUInt
Methods succ :: CUInt -> CUInt # pred :: CUInt -> CUInt # toEnum :: Int -> CUInt # fromEnum :: CUInt -> Int # enumFrom :: CUInt -> [CUInt] # enumFromThen :: CUInt -> CUInt -> [CUInt] # enumFromTo :: CUInt -> CUInt -> [CUInt] # enumFromThenTo :: CUInt -> CUInt -> CUInt -> [CUInt] #
Eq CUInt
Methods (==) :: CUInt -> CUInt -> Bool # (/=) :: CUInt -> CUInt -> Bool #
Integral CUInt
Methods quot :: CUInt -> CUInt -> CUInt # rem :: CUInt -> CUInt -> CUInt # div :: CUInt -> CUInt -> CUInt # mod :: CUInt -> CUInt -> CUInt # quotRem :: CUInt -> CUInt -> (CUInt, CUInt) # divMod :: CUInt -> CUInt -> (CUInt, CUInt) # toInteger :: CUInt -> Integer #
Num CUInt
Methods (+) :: CUInt -> CUInt -> CUInt # (-) :: CUInt -> CUInt -> CUInt # (*) :: CUInt -> CUInt -> CUInt # negate :: CUInt -> CUInt # abs :: CUInt -> CUInt # signum :: CUInt -> CUInt # fromInteger :: Integer -> 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
Methods readsPrec :: Int -> ReadS CUInt # readList :: ReadS [CUInt] # readPrec :: ReadPrec CUInt # readListPrec :: ReadPrec [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
Methods (.&.) :: CUInt -> CUInt -> CUInt # (.\|.) :: CUInt -> CUInt -> CUInt # xor :: CUInt -> CUInt -> CUInt # complement :: CUInt -> CUInt # shift :: CUInt -> Int -> CUInt # rotate :: CUInt -> Int -> CUInt # zeroBits :: CUInt # bit :: Int -> CUInt # setBit :: CUInt -> Int -> CUInt # clearBit :: CUInt -> Int -> CUInt # complementBit :: CUInt -> Int -> CUInt # testBit :: CUInt -> Int -> Bool # bitSizeMaybe :: CUInt -> Maybe Int # bitSize :: CUInt -> Int # isSigned :: CUInt -> Bool # shiftL :: CUInt -> Int -> CUInt # unsafeShiftL :: CUInt -> Int -> CUInt # shiftR :: CUInt -> Int -> CUInt # unsafeShiftR :: CUInt -> Int -> CUInt # rotateL :: CUInt -> Int -> CUInt # rotateR :: CUInt -> Int -> CUInt # popCount :: CUInt -> Int #
FiniteBits CUInt
Methods finiteBitSize :: CUInt -> Int # countLeadingZeros :: CUInt -> Int # countTrailingZeros :: CUInt -> Int #
Integral CUInt Source #
Methods fromInteger :: Integer -> CUInt Source #
IsNatural CUInt Source #
Methods toNatural :: CUInt -> Natural Source #
IsIntegral CUInt Source #
Methods toInteger :: CUInt -> Integer Source #
Subtractive CUInt Source #
Associated Types type Difference CUInt :: * Source # Methods (-) :: CUInt -> CUInt -> Difference CUInt Source #
Additive CUInt Source #
Methods azero :: CUInt Source # (+) :: CUInt -> CUInt -> CUInt Source # scale :: IsNatural n => n -> CUInt -> CUInt Source #
IDivisible CUInt Source #
Methods div :: CUInt -> CUInt -> CUInt Source # mod :: CUInt -> CUInt -> CUInt Source # divMod :: CUInt -> CUInt -> (CUInt, CUInt) Source #
Multiplicative CUInt Source #
Methods midentity :: CUInt Source # (*) :: CUInt -> CUInt -> CUInt Source # (^) :: (IsNatural n, IDivisible n) => CUInt -> n -> CUInt Source #
NormalForm CUInt Source #
Methods toNormalForm :: CUInt -> () Source #
type Difference CUInt Source #
type Difference CUInt = CUInt

newtype CLong :: * #

Haskell type representing the C long type.

Constructors

CLong Int64

Instances

Bounded CLong
Methods minBound :: CLong # maxBound :: CLong #
Enum CLong
Methods succ :: CLong -> CLong # pred :: CLong -> CLong # toEnum :: Int -> CLong # fromEnum :: CLong -> Int # enumFrom :: CLong -> [CLong] # enumFromThen :: CLong -> CLong -> [CLong] # enumFromTo :: CLong -> CLong -> [CLong] # enumFromThenTo :: CLong -> CLong -> CLong -> [CLong] #
Eq CLong
Methods (==) :: CLong -> CLong -> Bool # (/=) :: CLong -> CLong -> Bool #
Integral CLong
Methods quot :: CLong -> CLong -> CLong # rem :: CLong -> CLong -> CLong # div :: CLong -> CLong -> CLong # mod :: CLong -> CLong -> CLong # quotRem :: CLong -> CLong -> (CLong, CLong) # divMod :: CLong -> CLong -> (CLong, CLong) # toInteger :: CLong -> Integer #
Num CLong
Methods (+) :: CLong -> CLong -> CLong # (-) :: CLong -> CLong -> CLong # (*) :: CLong -> CLong -> CLong # negate :: CLong -> CLong # abs :: CLong -> CLong # signum :: CLong -> CLong # fromInteger :: Integer -> 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
Methods readsPrec :: Int -> ReadS CLong # readList :: ReadS [CLong] # readPrec :: ReadPrec CLong # readListPrec :: ReadPrec [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
Methods (.&.) :: CLong -> CLong -> CLong # (.\|.) :: CLong -> CLong -> CLong # xor :: CLong -> CLong -> CLong # complement :: CLong -> CLong # shift :: CLong -> Int -> CLong # rotate :: CLong -> Int -> CLong # zeroBits :: CLong # bit :: Int -> CLong # setBit :: CLong -> Int -> CLong # clearBit :: CLong -> Int -> CLong # complementBit :: CLong -> Int -> CLong # testBit :: CLong -> Int -> Bool # bitSizeMaybe :: CLong -> Maybe Int # bitSize :: CLong -> Int # isSigned :: CLong -> Bool # shiftL :: CLong -> Int -> CLong # unsafeShiftL :: CLong -> Int -> CLong # shiftR :: CLong -> Int -> CLong # unsafeShiftR :: CLong -> Int -> CLong # rotateL :: CLong -> Int -> CLong # rotateR :: CLong -> Int -> CLong # popCount :: CLong -> Int #
FiniteBits CLong
Methods finiteBitSize :: CLong -> Int # countLeadingZeros :: CLong -> Int # countTrailingZeros :: CLong -> Int #
HasNegation CLong Source #
Methods negate :: CLong -> CLong Source #
Integral CLong Source #
Methods fromInteger :: Integer -> CLong Source #
IsIntegral CLong Source #
Methods toInteger :: CLong -> Integer Source #
Subtractive CLong Source #
Associated Types type Difference CLong :: * Source # Methods (-) :: CLong -> CLong -> Difference CLong Source #
Additive CLong Source #
Methods azero :: CLong Source # (+) :: CLong -> CLong -> CLong Source # scale :: IsNatural n => n -> CLong -> CLong Source #
IDivisible CLong Source #
Methods div :: CLong -> CLong -> CLong Source # mod :: CLong -> CLong -> CLong Source # divMod :: CLong -> CLong -> (CLong, CLong) Source #
Multiplicative CLong Source #
Methods midentity :: CLong Source # (*) :: CLong -> CLong -> CLong Source # (^) :: (IsNatural n, IDivisible n) => CLong -> n -> CLong Source #
NormalForm CLong Source #
Methods toNormalForm :: CLong -> () Source #
type Difference CLong Source #
type Difference CLong = CLong

newtype CULong :: * #

Haskell type representing the C unsigned long type.

Constructors

CULong Word64

Instances

Bounded CULong
Methods minBound :: CULong # maxBound :: CULong #
Enum CULong
Methods succ :: CULong -> CULong # pred :: CULong -> CULong # toEnum :: Int -> CULong # fromEnum :: CULong -> Int # enumFrom :: CULong -> [CULong] # enumFromThen :: CULong -> CULong -> [CULong] # enumFromTo :: CULong -> CULong -> [CULong] # enumFromThenTo :: CULong -> CULong -> CULong -> [CULong] #
Eq CULong
Methods (==) :: CULong -> CULong -> Bool # (/=) :: CULong -> CULong -> Bool #
Integral CULong
Methods quot :: CULong -> CULong -> CULong # rem :: CULong -> CULong -> CULong # div :: CULong -> CULong -> CULong # mod :: CULong -> CULong -> CULong # quotRem :: CULong -> CULong -> (CULong, CULong) # divMod :: CULong -> CULong -> (CULong, CULong) # toInteger :: CULong -> Integer #
Num CULong
Methods (+) :: CULong -> CULong -> CULong # (-) :: CULong -> CULong -> CULong # (*) :: CULong -> CULong -> CULong # negate :: CULong -> CULong # abs :: CULong -> CULong # signum :: CULong -> CULong # fromInteger :: Integer -> CULong #
Ord CULong
Methods compare :: CULong -> CULong -> Ordering # (<) :: CULong -> CULong -> Bool # (<=) :: CULong -> CULong -> Bool # (>) :: CULong -> CULong -> Bool # (>=) :: CULong -> CULong -> Bool # max :: CULong -> CULong -> CULong # min :: CULong -> CULong -> CULong #
Read CULong
Methods readsPrec :: Int -> ReadS CULong # readList :: ReadS [CULong] # readPrec :: ReadPrec CULong # readListPrec :: ReadPrec [CULong] #
Real CULong
Methods toRational :: CULong -> Rational #
Show CULong
Methods showsPrec :: Int -> CULong -> ShowS # show :: CULong -> String # showList :: [CULong] -> ShowS #
Storable CULong
Methods sizeOf :: CULong -> Int # alignment :: CULong -> Int # peekElemOff :: Ptr CULong -> Int -> IO CULong # pokeElemOff :: Ptr CULong -> Int -> CULong -> IO () # peekByteOff :: Ptr b -> Int -> IO CULong # pokeByteOff :: Ptr b -> Int -> CULong -> IO () # peek :: Ptr CULong -> IO CULong # poke :: Ptr CULong -> CULong -> IO () #
Bits CULong
Methods (.&.) :: CULong -> CULong -> CULong # (.\|.) :: CULong -> CULong -> CULong # xor :: CULong -> CULong -> CULong # complement :: CULong -> CULong # shift :: CULong -> Int -> CULong # rotate :: CULong -> Int -> CULong # zeroBits :: CULong # bit :: Int -> CULong # setBit :: CULong -> Int -> CULong # clearBit :: CULong -> Int -> CULong # complementBit :: CULong -> Int -> CULong # testBit :: CULong -> Int -> Bool # bitSizeMaybe :: CULong -> Maybe Int # bitSize :: CULong -> Int # isSigned :: CULong -> Bool # shiftL :: CULong -> Int -> CULong # unsafeShiftL :: CULong -> Int -> CULong # shiftR :: CULong -> Int -> CULong # unsafeShiftR :: CULong -> Int -> CULong # rotateL :: CULong -> Int -> CULong # rotateR :: CULong -> Int -> CULong # popCount :: CULong -> Int #
FiniteBits CULong
Methods finiteBitSize :: CULong -> Int # countLeadingZeros :: CULong -> Int # countTrailingZeros :: CULong -> Int #
Integral CULong Source #
Methods fromInteger :: Integer -> CULong Source #
IsNatural CULong Source #
Methods toNatural :: CULong -> Natural Source #
IsIntegral CULong Source #
Methods toInteger :: CULong -> Integer Source #
Subtractive CULong Source #
Associated Types type Difference CULong :: * Source # Methods (-) :: CULong -> CULong -> Difference CULong Source #
Additive CULong Source #
Methods azero :: CULong Source # (+) :: CULong -> CULong -> CULong Source # scale :: IsNatural n => n -> CULong -> CULong Source #
IDivisible CULong Source #
Methods div :: CULong -> CULong -> CULong Source # mod :: CULong -> CULong -> CULong Source # divMod :: CULong -> CULong -> (CULong, CULong) Source #
Multiplicative CULong Source #
Methods midentity :: CULong Source # (*) :: CULong -> CULong -> CULong Source # (^) :: (IsNatural n, IDivisible n) => CULong -> n -> CULong Source #
NormalForm CULong Source #
Methods toNormalForm :: CULong -> () Source #
type Difference CULong Source #
type Difference CULong = CULong

newtype CPtrdiff :: * #

Haskell type representing the C ptrdiff_t type.

Constructors

CPtrdiff Int64

Instances

Bounded CPtrdiff
Methods minBound :: CPtrdiff # maxBound :: CPtrdiff #
Enum CPtrdiff
Methods succ :: CPtrdiff -> CPtrdiff # pred :: CPtrdiff -> CPtrdiff # toEnum :: Int -> CPtrdiff # fromEnum :: CPtrdiff -> Int # enumFrom :: CPtrdiff -> [CPtrdiff] # enumFromThen :: CPtrdiff -> CPtrdiff -> [CPtrdiff] # enumFromTo :: CPtrdiff -> CPtrdiff -> [CPtrdiff] # enumFromThenTo :: CPtrdiff -> CPtrdiff -> CPtrdiff -> [CPtrdiff] #
Eq CPtrdiff
Methods (==) :: CPtrdiff -> CPtrdiff -> Bool # (/=) :: CPtrdiff -> CPtrdiff -> Bool #
Integral CPtrdiff
Methods quot :: CPtrdiff -> CPtrdiff -> CPtrdiff # rem :: CPtrdiff -> CPtrdiff -> CPtrdiff # div :: CPtrdiff -> CPtrdiff -> CPtrdiff # mod :: CPtrdiff -> CPtrdiff -> CPtrdiff # quotRem :: CPtrdiff -> CPtrdiff -> (CPtrdiff, CPtrdiff) # divMod :: CPtrdiff -> CPtrdiff -> (CPtrdiff, CPtrdiff) # toInteger :: CPtrdiff -> Integer #
Num CPtrdiff
Methods (+) :: CPtrdiff -> CPtrdiff -> CPtrdiff # (-) :: CPtrdiff -> CPtrdiff -> CPtrdiff # (*) :: CPtrdiff -> CPtrdiff -> CPtrdiff # negate :: CPtrdiff -> CPtrdiff # abs :: CPtrdiff -> CPtrdiff # signum :: CPtrdiff -> CPtrdiff # fromInteger :: Integer -> CPtrdiff #
Ord CPtrdiff
Methods compare :: CPtrdiff -> CPtrdiff -> Ordering # (<) :: CPtrdiff -> CPtrdiff -> Bool # (<=) :: CPtrdiff -> CPtrdiff -> Bool # (>) :: CPtrdiff -> CPtrdiff -> Bool # (>=) :: CPtrdiff -> CPtrdiff -> Bool # max :: CPtrdiff -> CPtrdiff -> CPtrdiff # min :: CPtrdiff -> CPtrdiff -> CPtrdiff #
Read CPtrdiff
Methods readsPrec :: Int -> ReadS CPtrdiff # readList :: ReadS [CPtrdiff] # readPrec :: ReadPrec CPtrdiff # readListPrec :: ReadPrec [CPtrdiff] #
Real CPtrdiff
Methods toRational :: CPtrdiff -> Rational #
Show CPtrdiff
Methods showsPrec :: Int -> CPtrdiff -> ShowS # show :: CPtrdiff -> String # showList :: [CPtrdiff] -> ShowS #
Storable CPtrdiff
Methods sizeOf :: CPtrdiff -> Int # alignment :: CPtrdiff -> Int # peekElemOff :: Ptr CPtrdiff -> Int -> IO CPtrdiff # pokeElemOff :: Ptr CPtrdiff -> Int -> CPtrdiff -> IO () # peekByteOff :: Ptr b -> Int -> IO CPtrdiff # pokeByteOff :: Ptr b -> Int -> CPtrdiff -> IO () # peek :: Ptr CPtrdiff -> IO CPtrdiff # poke :: Ptr CPtrdiff -> CPtrdiff -> IO () #
Bits CPtrdiff
Methods (.&.) :: CPtrdiff -> CPtrdiff -> CPtrdiff # (.\|.) :: CPtrdiff -> CPtrdiff -> CPtrdiff # xor :: CPtrdiff -> CPtrdiff -> CPtrdiff # complement :: CPtrdiff -> CPtrdiff # shift :: CPtrdiff -> Int -> CPtrdiff # rotate :: CPtrdiff -> Int -> CPtrdiff # zeroBits :: CPtrdiff # bit :: Int -> CPtrdiff # setBit :: CPtrdiff -> Int -> CPtrdiff # clearBit :: CPtrdiff -> Int -> CPtrdiff # complementBit :: CPtrdiff -> Int -> CPtrdiff # testBit :: CPtrdiff -> Int -> Bool # bitSizeMaybe :: CPtrdiff -> Maybe Int # bitSize :: CPtrdiff -> Int # isSigned :: CPtrdiff -> Bool # shiftL :: CPtrdiff -> Int -> CPtrdiff # unsafeShiftL :: CPtrdiff -> Int -> CPtrdiff # shiftR :: CPtrdiff -> Int -> CPtrdiff # unsafeShiftR :: CPtrdiff -> Int -> CPtrdiff # rotateL :: CPtrdiff -> Int -> CPtrdiff # rotateR :: CPtrdiff -> Int -> CPtrdiff # popCount :: CPtrdiff -> Int #
FiniteBits CPtrdiff
Methods finiteBitSize :: CPtrdiff -> Int # countLeadingZeros :: CPtrdiff -> Int # countTrailingZeros :: CPtrdiff -> Int #
HasNegation CPtrdiff Source #
Methods negate :: CPtrdiff -> CPtrdiff Source #
Integral CPtrdiff Source #
Methods fromInteger :: Integer -> CPtrdiff Source #
IsIntegral CPtrdiff Source #
Methods toInteger :: CPtrdiff -> Integer Source #
Subtractive CPtrdiff Source #
Associated Types type Difference CPtrdiff :: * Source # Methods (-) :: CPtrdiff -> CPtrdiff -> Difference CPtrdiff Source #
Additive CPtrdiff Source #
Methods azero :: CPtrdiff Source # (+) :: CPtrdiff -> CPtrdiff -> CPtrdiff Source # scale :: IsNatural n => n -> CPtrdiff -> CPtrdiff Source #
IDivisible CPtrdiff Source #
Methods div :: CPtrdiff -> CPtrdiff -> CPtrdiff Source # mod :: CPtrdiff -> CPtrdiff -> CPtrdiff Source # divMod :: CPtrdiff -> CPtrdiff -> (CPtrdiff, CPtrdiff) Source #
Multiplicative CPtrdiff Source #
Methods midentity :: CPtrdiff Source # (*) :: CPtrdiff -> CPtrdiff -> CPtrdiff Source # (^) :: (IsNatural n, IDivisible n) => CPtrdiff -> n -> CPtrdiff Source #
type Difference CPtrdiff Source #
type Difference CPtrdiff = CPtrdiff

newtype CSize :: * #

Haskell type representing the C size_t type.

Constructors

CSize Word64

Instances

Bounded CSize
Methods minBound :: CSize # maxBound :: CSize #
Enum CSize
Methods succ :: CSize -> CSize # pred :: CSize -> CSize # toEnum :: Int -> CSize # fromEnum :: CSize -> Int # enumFrom :: CSize -> [CSize] # enumFromThen :: CSize -> CSize -> [CSize] # enumFromTo :: CSize -> CSize -> [CSize] # enumFromThenTo :: CSize -> CSize -> CSize -> [CSize] #
Eq CSize
Methods (==) :: CSize -> CSize -> Bool # (/=) :: CSize -> CSize -> Bool #
Integral CSize
Methods quot :: CSize -> CSize -> CSize # rem :: CSize -> CSize -> CSize # div :: CSize -> CSize -> CSize # mod :: CSize -> CSize -> CSize # quotRem :: CSize -> CSize -> (CSize, CSize) # divMod :: CSize -> CSize -> (CSize, CSize) # toInteger :: CSize -> Integer #
Num CSize
Methods (+) :: CSize -> CSize -> CSize # (-) :: CSize -> CSize -> CSize # (*) :: CSize -> CSize -> CSize # negate :: CSize -> CSize # abs :: CSize -> CSize # signum :: CSize -> CSize # fromInteger :: Integer -> 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
Methods readsPrec :: Int -> ReadS CSize # readList :: ReadS [CSize] # readPrec :: ReadPrec CSize # readListPrec :: ReadPrec [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
Methods (.&.) :: CSize -> CSize -> CSize # (.\|.) :: CSize -> CSize -> CSize # xor :: CSize -> CSize -> CSize # complement :: CSize -> CSize # shift :: CSize -> Int -> CSize # rotate :: CSize -> Int -> CSize # zeroBits :: CSize # bit :: Int -> CSize # setBit :: CSize -> Int -> CSize # clearBit :: CSize -> Int -> CSize # complementBit :: CSize -> Int -> CSize # testBit :: CSize -> Int -> Bool # bitSizeMaybe :: CSize -> Maybe Int # bitSize :: CSize -> Int # isSigned :: CSize -> Bool # shiftL :: CSize -> Int -> CSize # unsafeShiftL :: CSize -> Int -> CSize # shiftR :: CSize -> Int -> CSize # unsafeShiftR :: CSize -> Int -> CSize # rotateL :: CSize -> Int -> CSize # rotateR :: CSize -> Int -> CSize # popCount :: CSize -> Int #
FiniteBits CSize
Methods finiteBitSize :: CSize -> Int # countLeadingZeros :: CSize -> Int # countTrailingZeros :: CSize -> Int #
Integral CSize Source #
Methods fromInteger :: Integer -> CSize Source #
IsNatural CSize Source #
Methods toNatural :: CSize -> Natural Source #
IsIntegral CSize Source #
Methods toInteger :: CSize -> Integer Source #
Subtractive CSize Source #
Associated Types type Difference CSize :: * Source # Methods (-) :: CSize -> CSize -> Difference CSize Source #
Additive CSize Source #
Methods azero :: CSize Source # (+) :: CSize -> CSize -> CSize Source # scale :: IsNatural n => n -> CSize -> CSize Source #
IDivisible CSize Source #
Methods div :: CSize -> CSize -> CSize Source # mod :: CSize -> CSize -> CSize Source # divMod :: CSize -> CSize -> (CSize, CSize) Source #
Multiplicative CSize Source #
Methods midentity :: CSize Source # (*) :: CSize -> CSize -> CSize Source # (^) :: (IsNatural n, IDivisible n) => CSize -> n -> CSize Source #
type Difference CSize Source #
type Difference CSize = CSize

newtype CWchar :: * #

Haskell type representing the C wchar_t type.

Constructors

CWchar Int32

Instances

Bounded CWchar
Methods minBound :: CWchar # maxBound :: CWchar #
Enum CWchar
Methods succ :: CWchar -> CWchar # pred :: CWchar -> CWchar # toEnum :: Int -> CWchar # fromEnum :: CWchar -> Int # enumFrom :: CWchar -> [CWchar] # enumFromThen :: CWchar -> CWchar -> [CWchar] # enumFromTo :: CWchar -> CWchar -> [CWchar] # enumFromThenTo :: CWchar -> CWchar -> CWchar -> [CWchar] #
Eq CWchar
Methods (==) :: CWchar -> CWchar -> Bool # (/=) :: CWchar -> CWchar -> Bool #
Integral CWchar
Methods quot :: CWchar -> CWchar -> CWchar # rem :: CWchar -> CWchar -> CWchar # div :: CWchar -> CWchar -> CWchar # mod :: CWchar -> CWchar -> CWchar # quotRem :: CWchar -> CWchar -> (CWchar, CWchar) # divMod :: CWchar -> CWchar -> (CWchar, CWchar) # toInteger :: CWchar -> Integer #
Num CWchar
Methods (+) :: CWchar -> CWchar -> CWchar # (-) :: CWchar -> CWchar -> CWchar # (*) :: CWchar -> CWchar -> CWchar # negate :: CWchar -> CWchar # abs :: CWchar -> CWchar # signum :: CWchar -> CWchar # fromInteger :: Integer -> CWchar #
Ord CWchar
Methods compare :: CWchar -> CWchar -> Ordering # (<) :: CWchar -> CWchar -> Bool # (<=) :: CWchar -> CWchar -> Bool # (>) :: CWchar -> CWchar -> Bool # (>=) :: CWchar -> CWchar -> Bool # max :: CWchar -> CWchar -> CWchar # min :: CWchar -> CWchar -> CWchar #
Read CWchar
Methods readsPrec :: Int -> ReadS CWchar # readList :: ReadS [CWchar] # readPrec :: ReadPrec CWchar # readListPrec :: ReadPrec [CWchar] #
Real CWchar
Methods toRational :: CWchar -> Rational #
Show CWchar
Methods showsPrec :: Int -> CWchar -> ShowS # show :: CWchar -> String # showList :: [CWchar] -> ShowS #
Storable CWchar
Methods sizeOf :: CWchar -> Int # alignment :: CWchar -> Int # peekElemOff :: Ptr CWchar -> Int -> IO CWchar # pokeElemOff :: Ptr CWchar -> Int -> CWchar -> IO () # peekByteOff :: Ptr b -> Int -> IO CWchar # pokeByteOff :: Ptr b -> Int -> CWchar -> IO () # peek :: Ptr CWchar -> IO CWchar # poke :: Ptr CWchar -> CWchar -> IO () #
Bits CWchar
Methods (.&.) :: CWchar -> CWchar -> CWchar # (.\|.) :: CWchar -> CWchar -> CWchar # xor :: CWchar -> CWchar -> CWchar # complement :: CWchar -> CWchar # shift :: CWchar -> Int -> CWchar # rotate :: CWchar -> Int -> CWchar # zeroBits :: CWchar # bit :: Int -> CWchar # setBit :: CWchar -> Int -> CWchar # clearBit :: CWchar -> Int -> CWchar # complementBit :: CWchar -> Int -> CWchar # testBit :: CWchar -> Int -> Bool # bitSizeMaybe :: CWchar -> Maybe Int # bitSize :: CWchar -> Int # isSigned :: CWchar -> Bool # shiftL :: CWchar -> Int -> CWchar # unsafeShiftL :: CWchar -> Int -> CWchar # shiftR :: CWchar -> Int -> CWchar # unsafeShiftR :: CWchar -> Int -> CWchar # rotateL :: CWchar -> Int -> CWchar # rotateR :: CWchar -> Int -> CWchar # popCount :: CWchar -> Int #
FiniteBits CWchar
Methods finiteBitSize :: CWchar -> Int # countLeadingZeros :: CWchar -> Int # countTrailingZeros :: CWchar -> Int #
HasNegation CWchar Source #
Methods negate :: CWchar -> CWchar Source #
Integral CWchar Source #
Methods fromInteger :: Integer -> CWchar Source #
IsIntegral CWchar Source #
Methods toInteger :: CWchar -> Integer Source #
Subtractive CWchar Source #
Associated Types type Difference CWchar :: * Source # Methods (-) :: CWchar -> CWchar -> Difference CWchar Source #
Additive CWchar Source #
Methods azero :: CWchar Source # (+) :: CWchar -> CWchar -> CWchar Source # scale :: IsNatural n => n -> CWchar -> CWchar Source #
IDivisible CWchar Source #
Methods div :: CWchar -> CWchar -> CWchar Source # mod :: CWchar -> CWchar -> CWchar Source # divMod :: CWchar -> CWchar -> (CWchar, CWchar) Source #
Multiplicative CWchar Source #
Methods midentity :: CWchar Source # (*) :: CWchar -> CWchar -> CWchar Source # (^) :: (IsNatural n, IDivisible n) => CWchar -> n -> CWchar Source #
type Difference CWchar Source #
type Difference CWchar = CWchar

newtype CSigAtomic :: * #

Haskell type representing the C sig_atomic_t type.

Constructors

CSigAtomic Int32

Instances

Bounded CSigAtomic
Methods minBound :: CSigAtomic # maxBound :: CSigAtomic #
Enum CSigAtomic
Methods succ :: CSigAtomic -> CSigAtomic # pred :: CSigAtomic -> CSigAtomic # toEnum :: Int -> CSigAtomic # fromEnum :: CSigAtomic -> Int # enumFrom :: CSigAtomic -> [CSigAtomic] # enumFromThen :: CSigAtomic -> CSigAtomic -> [CSigAtomic] # enumFromTo :: CSigAtomic -> CSigAtomic -> [CSigAtomic] # enumFromThenTo :: CSigAtomic -> CSigAtomic -> CSigAtomic -> [CSigAtomic] #
Eq CSigAtomic
Methods (==) :: CSigAtomic -> CSigAtomic -> Bool # (/=) :: CSigAtomic -> CSigAtomic -> Bool #
Integral CSigAtomic
Methods quot :: CSigAtomic -> CSigAtomic -> CSigAtomic # rem :: CSigAtomic -> CSigAtomic -> CSigAtomic # div :: CSigAtomic -> CSigAtomic -> CSigAtomic # mod :: CSigAtomic -> CSigAtomic -> CSigAtomic # quotRem :: CSigAtomic -> CSigAtomic -> (CSigAtomic, CSigAtomic) # divMod :: CSigAtomic -> CSigAtomic -> (CSigAtomic, CSigAtomic) # toInteger :: CSigAtomic -> Integer #
Num CSigAtomic
Methods (+) :: CSigAtomic -> CSigAtomic -> CSigAtomic # (-) :: CSigAtomic -> CSigAtomic -> CSigAtomic # (*) :: CSigAtomic -> CSigAtomic -> CSigAtomic # negate :: CSigAtomic -> CSigAtomic # abs :: CSigAtomic -> CSigAtomic # signum :: CSigAtomic -> CSigAtomic # fromInteger :: Integer -> CSigAtomic #
Ord CSigAtomic
Methods compare :: CSigAtomic -> CSigAtomic -> Ordering # (<) :: CSigAtomic -> CSigAtomic -> Bool # (<=) :: CSigAtomic -> CSigAtomic -> Bool # (>) :: CSigAtomic -> CSigAtomic -> Bool # (>=) :: CSigAtomic -> CSigAtomic -> Bool # max :: CSigAtomic -> CSigAtomic -> CSigAtomic # min :: CSigAtomic -> CSigAtomic -> CSigAtomic #
Read CSigAtomic
Methods readsPrec :: Int -> ReadS CSigAtomic # readList :: ReadS [CSigAtomic] # readPrec :: ReadPrec CSigAtomic # readListPrec :: ReadPrec [CSigAtomic] #
Real CSigAtomic
Methods toRational :: CSigAtomic -> Rational #
Show CSigAtomic
Methods showsPrec :: Int -> CSigAtomic -> ShowS # show :: CSigAtomic -> String # showList :: [CSigAtomic] -> ShowS #
Storable CSigAtomic
Methods sizeOf :: CSigAtomic -> Int # alignment :: CSigAtomic -> Int # peekElemOff :: Ptr CSigAtomic -> Int -> IO CSigAtomic # pokeElemOff :: Ptr CSigAtomic -> Int -> CSigAtomic -> IO () # peekByteOff :: Ptr b -> Int -> IO CSigAtomic # pokeByteOff :: Ptr b -> Int -> CSigAtomic -> IO () # peek :: Ptr CSigAtomic -> IO CSigAtomic # poke :: Ptr CSigAtomic -> CSigAtomic -> IO () #
Bits CSigAtomic
Methods (.&.) :: CSigAtomic -> CSigAtomic -> CSigAtomic # (.\|.) :: CSigAtomic -> CSigAtomic -> CSigAtomic # xor :: CSigAtomic -> CSigAtomic -> CSigAtomic # complement :: CSigAtomic -> CSigAtomic # shift :: CSigAtomic -> Int -> CSigAtomic # rotate :: CSigAtomic -> Int -> CSigAtomic # zeroBits :: CSigAtomic # bit :: Int -> CSigAtomic # setBit :: CSigAtomic -> Int -> CSigAtomic # clearBit :: CSigAtomic -> Int -> CSigAtomic # complementBit :: CSigAtomic -> Int -> CSigAtomic # testBit :: CSigAtomic -> Int -> Bool # bitSizeMaybe :: CSigAtomic -> Maybe Int # bitSize :: CSigAtomic -> Int # isSigned :: CSigAtomic -> Bool # shiftL :: CSigAtomic -> Int -> CSigAtomic # unsafeShiftL :: CSigAtomic -> Int -> CSigAtomic # shiftR :: CSigAtomic -> Int -> CSigAtomic # unsafeShiftR :: CSigAtomic -> Int -> CSigAtomic # rotateL :: CSigAtomic -> Int -> CSigAtomic # rotateR :: CSigAtomic -> Int -> CSigAtomic # popCount :: CSigAtomic -> Int #
FiniteBits CSigAtomic
Methods finiteBitSize :: CSigAtomic -> Int # countLeadingZeros :: CSigAtomic -> Int # countTrailingZeros :: CSigAtomic -> Int #
Integral CSigAtomic Source #
Methods fromInteger :: Integer -> CSigAtomic Source #
IsIntegral CSigAtomic Source #
Methods toInteger :: CSigAtomic -> Integer Source #
Subtractive CSigAtomic Source #
Associated Types type Difference CSigAtomic :: * Source # Methods (-) :: CSigAtomic -> CSigAtomic -> Difference CSigAtomic Source #
Additive CSigAtomic Source #
Methods azero :: CSigAtomic Source # (+) :: CSigAtomic -> CSigAtomic -> CSigAtomic Source # scale :: IsNatural n => n -> CSigAtomic -> CSigAtomic Source #
IDivisible CSigAtomic Source #
Methods div :: CSigAtomic -> CSigAtomic -> CSigAtomic Source # mod :: CSigAtomic -> CSigAtomic -> CSigAtomic Source # divMod :: CSigAtomic -> CSigAtomic -> (CSigAtomic, CSigAtomic) Source #
Multiplicative CSigAtomic Source #
Methods midentity :: CSigAtomic Source # (*) :: CSigAtomic -> CSigAtomic -> CSigAtomic Source # (^) :: (IsNatural n, IDivisible n) => CSigAtomic -> n -> CSigAtomic Source #
type Difference CSigAtomic Source #
type Difference CSigAtomic = CSigAtomic

newtype CLLong :: * #

Haskell type representing the C long long type.

Constructors

CLLong Int64

Instances

Bounded CLLong
Methods minBound :: CLLong # maxBound :: CLLong #
Enum CLLong
Methods succ :: CLLong -> CLLong # pred :: CLLong -> CLLong # toEnum :: Int -> CLLong # fromEnum :: CLLong -> Int # enumFrom :: CLLong -> [CLLong] # enumFromThen :: CLLong -> CLLong -> [CLLong] # enumFromTo :: CLLong -> CLLong -> [CLLong] # enumFromThenTo :: CLLong -> CLLong -> CLLong -> [CLLong] #
Eq CLLong
Methods (==) :: CLLong -> CLLong -> Bool # (/=) :: CLLong -> CLLong -> Bool #
Integral CLLong
Methods quot :: CLLong -> CLLong -> CLLong # rem :: CLLong -> CLLong -> CLLong # div :: CLLong -> CLLong -> CLLong # mod :: CLLong -> CLLong -> CLLong # quotRem :: CLLong -> CLLong -> (CLLong, CLLong) # divMod :: CLLong -> CLLong -> (CLLong, CLLong) # toInteger :: CLLong -> Integer #
Num CLLong
Methods (+) :: CLLong -> CLLong -> CLLong # (-) :: CLLong -> CLLong -> CLLong # (*) :: CLLong -> CLLong -> CLLong # negate :: CLLong -> CLLong # abs :: CLLong -> CLLong # signum :: CLLong -> CLLong # fromInteger :: Integer -> CLLong #
Ord CLLong
Methods compare :: CLLong -> CLLong -> Ordering # (<) :: CLLong -> CLLong -> Bool # (<=) :: CLLong -> CLLong -> Bool # (>) :: CLLong -> CLLong -> Bool # (>=) :: CLLong -> CLLong -> Bool # max :: CLLong -> CLLong -> CLLong # min :: CLLong -> CLLong -> CLLong #
Read CLLong
Methods readsPrec :: Int -> ReadS CLLong # readList :: ReadS [CLLong] # readPrec :: ReadPrec CLLong # readListPrec :: ReadPrec [CLLong] #
Real CLLong
Methods toRational :: CLLong -> Rational #
Show CLLong
Methods showsPrec :: Int -> CLLong -> ShowS # show :: CLLong -> String # showList :: [CLLong] -> ShowS #
Storable CLLong
Methods sizeOf :: CLLong -> Int # alignment :: CLLong -> Int # peekElemOff :: Ptr CLLong -> Int -> IO CLLong # pokeElemOff :: Ptr CLLong -> Int -> CLLong -> IO () # peekByteOff :: Ptr b -> Int -> IO CLLong # pokeByteOff :: Ptr b -> Int -> CLLong -> IO () # peek :: Ptr CLLong -> IO CLLong # poke :: Ptr CLLong -> CLLong -> IO () #
Bits CLLong
Methods (.&.) :: CLLong -> CLLong -> CLLong # (.\|.) :: CLLong -> CLLong -> CLLong # xor :: CLLong -> CLLong -> CLLong # complement :: CLLong -> CLLong # shift :: CLLong -> Int -> CLLong # rotate :: CLLong -> Int -> CLLong # zeroBits :: CLLong # bit :: Int -> CLLong # setBit :: CLLong -> Int -> CLLong # clearBit :: CLLong -> Int -> CLLong # complementBit :: CLLong -> Int -> CLLong # testBit :: CLLong -> Int -> Bool # bitSizeMaybe :: CLLong -> Maybe Int # bitSize :: CLLong -> Int # isSigned :: CLLong -> Bool # shiftL :: CLLong -> Int -> CLLong # unsafeShiftL :: CLLong -> Int -> CLLong # shiftR :: CLLong -> Int -> CLLong # unsafeShiftR :: CLLong -> Int -> CLLong # rotateL :: CLLong -> Int -> CLLong # rotateR :: CLLong -> Int -> CLLong # popCount :: CLLong -> Int #
FiniteBits CLLong
Methods finiteBitSize :: CLLong -> Int # countLeadingZeros :: CLLong -> Int # countTrailingZeros :: CLLong -> Int #
HasNegation CLLong Source #
Methods negate :: CLLong -> CLLong Source #
Integral CLLong Source #
Methods fromInteger :: Integer -> CLLong Source #
IsIntegral CLLong Source #
Methods toInteger :: CLLong -> Integer Source #
Subtractive CLLong Source #
Associated Types type Difference CLLong :: * Source # Methods (-) :: CLLong -> CLLong -> Difference CLLong Source #
Additive CLLong Source #
Methods azero :: CLLong Source # (+) :: CLLong -> CLLong -> CLLong Source # scale :: IsNatural n => n -> CLLong -> CLLong Source #
IDivisible CLLong Source #
Methods div :: CLLong -> CLLong -> CLLong Source # mod :: CLLong -> CLLong -> CLLong Source # divMod :: CLLong -> CLLong -> (CLLong, CLLong) Source #
Multiplicative CLLong Source #
Methods midentity :: CLLong Source # (*) :: CLLong -> CLLong -> CLLong Source # (^) :: (IsNatural n, IDivisible n) => CLLong -> n -> CLLong Source #
NormalForm CLLong Source #
Methods toNormalForm :: CLLong -> () Source #
type Difference CLLong Source #
type Difference CLLong = CLLong

newtype CULLong :: * #

Haskell type representing the C unsigned long long type.

Constructors

CULLong Word64

Instances

Bounded CULLong
Methods minBound :: CULLong # maxBound :: CULLong #
Enum CULLong
Methods succ :: CULLong -> CULLong # pred :: CULLong -> CULLong # toEnum :: Int -> CULLong # fromEnum :: CULLong -> Int # enumFrom :: CULLong -> [CULLong] # enumFromThen :: CULLong -> CULLong -> [CULLong] # enumFromTo :: CULLong -> CULLong -> [CULLong] # enumFromThenTo :: CULLong -> CULLong -> CULLong -> [CULLong] #
Eq CULLong
Methods (==) :: CULLong -> CULLong -> Bool # (/=) :: CULLong -> CULLong -> Bool #
Integral CULLong
Methods quot :: CULLong -> CULLong -> CULLong # rem :: CULLong -> CULLong -> CULLong # div :: CULLong -> CULLong -> CULLong # mod :: CULLong -> CULLong -> CULLong # quotRem :: CULLong -> CULLong -> (CULLong, CULLong) # divMod :: CULLong -> CULLong -> (CULLong, CULLong) # toInteger :: CULLong -> Integer #
Num CULLong
Methods (+) :: CULLong -> CULLong -> CULLong # (-) :: CULLong -> CULLong -> CULLong # (*) :: CULLong -> CULLong -> CULLong # negate :: CULLong -> CULLong # abs :: CULLong -> CULLong # signum :: CULLong -> CULLong # fromInteger :: Integer -> CULLong #
Ord CULLong
Methods compare :: CULLong -> CULLong -> Ordering # (<) :: CULLong -> CULLong -> Bool # (<=) :: CULLong -> CULLong -> Bool # (>) :: CULLong -> CULLong -> Bool # (>=) :: CULLong -> CULLong -> Bool # max :: CULLong -> CULLong -> CULLong # min :: CULLong -> CULLong -> CULLong #
Read CULLong
Methods readsPrec :: Int -> ReadS CULLong # readList :: ReadS [CULLong] # readPrec :: ReadPrec CULLong # readListPrec :: ReadPrec [CULLong] #
Real CULLong
Methods toRational :: CULLong -> Rational #
Show CULLong
Methods showsPrec :: Int -> CULLong -> ShowS # show :: CULLong -> String # showList :: [CULLong] -> ShowS #
Storable CULLong
Methods sizeOf :: CULLong -> Int # alignment :: CULLong -> Int # peekElemOff :: Ptr CULLong -> Int -> IO CULLong # pokeElemOff :: Ptr CULLong -> Int -> CULLong -> IO () # peekByteOff :: Ptr b -> Int -> IO CULLong # pokeByteOff :: Ptr b -> Int -> CULLong -> IO () # peek :: Ptr CULLong -> IO CULLong # poke :: Ptr CULLong -> CULLong -> IO () #
Bits CULLong
Methods (.&.) :: CULLong -> CULLong -> CULLong # (.\|.) :: CULLong -> CULLong -> CULLong # xor :: CULLong -> CULLong -> CULLong # complement :: CULLong -> CULLong # shift :: CULLong -> Int -> CULLong # rotate :: CULLong -> Int -> CULLong # zeroBits :: CULLong # bit :: Int -> CULLong # setBit :: CULLong -> Int -> CULLong # clearBit :: CULLong -> Int -> CULLong # complementBit :: CULLong -> Int -> CULLong # testBit :: CULLong -> Int -> Bool # bitSizeMaybe :: CULLong -> Maybe Int # bitSize :: CULLong -> Int # isSigned :: CULLong -> Bool # shiftL :: CULLong -> Int -> CULLong # unsafeShiftL :: CULLong -> Int -> CULLong # shiftR :: CULLong -> Int -> CULLong # unsafeShiftR :: CULLong -> Int -> CULLong # rotateL :: CULLong -> Int -> CULLong # rotateR :: CULLong -> Int -> CULLong # popCount :: CULLong -> Int #
FiniteBits CULLong
Methods finiteBitSize :: CULLong -> Int # countLeadingZeros :: CULLong -> Int # countTrailingZeros :: CULLong -> Int #
Integral CULLong Source #
Methods fromInteger :: Integer -> CULLong Source #
IsNatural CULLong Source #
Methods toNatural :: CULLong -> Natural Source #
IsIntegral CULLong Source #
Methods toInteger :: CULLong -> Integer Source #
Subtractive CULLong Source #
Associated Types type Difference CULLong :: * Source # Methods (-) :: CULLong -> CULLong -> Difference CULLong Source #
Additive CULLong Source #
Methods azero :: CULLong Source # (+) :: CULLong -> CULLong -> CULLong Source # scale :: IsNatural n => n -> CULLong -> CULLong Source #
IDivisible CULLong Source #
Methods div :: CULLong -> CULLong -> CULLong Source # mod :: CULLong -> CULLong -> CULLong Source # divMod :: CULLong -> CULLong -> (CULLong, CULLong) Source #
Multiplicative CULLong Source #
Methods midentity :: CULLong Source # (*) :: CULLong -> CULLong -> CULLong Source # (^) :: (IsNatural n, IDivisible n) => CULLong -> n -> CULLong Source #
NormalForm CULLong Source #
Methods toNormalForm :: CULLong -> () Source #
type Difference CULLong Source #
type Difference CULLong = CULLong

newtype CBool :: * #

Haskell type representing the C bool type.

Since: 4.10.0.0

Constructors

CBool Word8

Instances

Bounded CBool
Methods minBound :: CBool # maxBound :: CBool #
Enum CBool
Methods succ :: CBool -> CBool # pred :: CBool -> CBool # toEnum :: Int -> CBool # fromEnum :: CBool -> Int # enumFrom :: CBool -> [CBool] # enumFromThen :: CBool -> CBool -> [CBool] # enumFromTo :: CBool -> CBool -> [CBool] # enumFromThenTo :: CBool -> CBool -> CBool -> [CBool] #
Eq CBool
Methods (==) :: CBool -> CBool -> Bool # (/=) :: CBool -> CBool -> Bool #
Integral CBool
Methods quot :: CBool -> CBool -> CBool # rem :: CBool -> CBool -> CBool # div :: CBool -> CBool -> CBool # mod :: CBool -> CBool -> CBool # quotRem :: CBool -> CBool -> (CBool, CBool) # divMod :: CBool -> CBool -> (CBool, CBool) # toInteger :: CBool -> Integer #
Num CBool
Methods (+) :: CBool -> CBool -> CBool # (-) :: CBool -> CBool -> CBool # (*) :: CBool -> CBool -> CBool # negate :: CBool -> CBool # abs :: CBool -> CBool # signum :: CBool -> CBool # fromInteger :: Integer -> 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
Methods readsPrec :: Int -> ReadS CBool # readList :: ReadS [CBool] # readPrec :: ReadPrec CBool # readListPrec :: ReadPrec [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
Methods (.&.) :: CBool -> CBool -> CBool # (.\|.) :: CBool -> CBool -> CBool # xor :: CBool -> CBool -> CBool # complement :: CBool -> CBool # shift :: CBool -> Int -> CBool # rotate :: CBool -> Int -> CBool # zeroBits :: CBool # bit :: Int -> CBool # setBit :: CBool -> Int -> CBool # clearBit :: CBool -> Int -> CBool # complementBit :: CBool -> Int -> CBool # testBit :: CBool -> Int -> Bool # bitSizeMaybe :: CBool -> Maybe Int # bitSize :: CBool -> Int # isSigned :: CBool -> Bool # shiftL :: CBool -> Int -> CBool # unsafeShiftL :: CBool -> Int -> CBool # shiftR :: CBool -> Int -> CBool # unsafeShiftR :: CBool -> Int -> CBool # rotateL :: CBool -> Int -> CBool # rotateR :: CBool -> Int -> CBool # popCount :: CBool -> Int #
FiniteBits CBool
Methods finiteBitSize :: CBool -> Int # countLeadingZeros :: CBool -> Int # countTrailingZeros :: CBool -> Int #
Integral CBool Source #
Methods fromInteger :: Integer -> CBool Source #
IsIntegral CBool Source #
Methods toInteger :: CBool -> Integer Source #
Subtractive CBool Source #
Associated Types type Difference CBool :: * Source # Methods (-) :: CBool -> CBool -> Difference CBool Source #
type Difference CBool Source #
type Difference CBool = CBool

newtype CIntPtr :: * #

Constructors

CIntPtr Int64

Instances

Bounded CIntPtr
Methods minBound :: CIntPtr # maxBound :: CIntPtr #
Enum CIntPtr
Methods succ :: CIntPtr -> CIntPtr # pred :: CIntPtr -> CIntPtr # toEnum :: Int -> CIntPtr # fromEnum :: CIntPtr -> Int # enumFrom :: CIntPtr -> [CIntPtr] # enumFromThen :: CIntPtr -> CIntPtr -> [CIntPtr] # enumFromTo :: CIntPtr -> CIntPtr -> [CIntPtr] # enumFromThenTo :: CIntPtr -> CIntPtr -> CIntPtr -> [CIntPtr] #
Eq CIntPtr
Methods (==) :: CIntPtr -> CIntPtr -> Bool # (/=) :: CIntPtr -> CIntPtr -> Bool #
Integral CIntPtr
Methods quot :: CIntPtr -> CIntPtr -> CIntPtr # rem :: CIntPtr -> CIntPtr -> CIntPtr # div :: CIntPtr -> CIntPtr -> CIntPtr # mod :: CIntPtr -> CIntPtr -> CIntPtr # quotRem :: CIntPtr -> CIntPtr -> (CIntPtr, CIntPtr) # divMod :: CIntPtr -> CIntPtr -> (CIntPtr, CIntPtr) # toInteger :: CIntPtr -> Integer #
Num CIntPtr
Methods (+) :: CIntPtr -> CIntPtr -> CIntPtr # (-) :: CIntPtr -> CIntPtr -> CIntPtr # (*) :: CIntPtr -> CIntPtr -> CIntPtr # negate :: CIntPtr -> CIntPtr # abs :: CIntPtr -> CIntPtr # signum :: CIntPtr -> CIntPtr # fromInteger :: Integer -> CIntPtr #
Ord CIntPtr
Methods compare :: CIntPtr -> CIntPtr -> Ordering # (<) :: CIntPtr -> CIntPtr -> Bool # (<=) :: CIntPtr -> CIntPtr -> Bool # (>) :: CIntPtr -> CIntPtr -> Bool # (>=) :: CIntPtr -> CIntPtr -> Bool # max :: CIntPtr -> CIntPtr -> CIntPtr # min :: CIntPtr -> CIntPtr -> CIntPtr #
Read CIntPtr
Methods readsPrec :: Int -> ReadS CIntPtr # readList :: ReadS [CIntPtr] # readPrec :: ReadPrec CIntPtr # readListPrec :: ReadPrec [CIntPtr] #
Real CIntPtr
Methods toRational :: CIntPtr -> Rational #
Show CIntPtr
Methods showsPrec :: Int -> CIntPtr -> ShowS # show :: CIntPtr -> String # showList :: [CIntPtr] -> ShowS #
Storable CIntPtr
Methods sizeOf :: CIntPtr -> Int # alignment :: CIntPtr -> Int # peekElemOff :: Ptr CIntPtr -> Int -> IO CIntPtr # pokeElemOff :: Ptr CIntPtr -> Int -> CIntPtr -> IO () # peekByteOff :: Ptr b -> Int -> IO CIntPtr # pokeByteOff :: Ptr b -> Int -> CIntPtr -> IO () # peek :: Ptr CIntPtr -> IO CIntPtr # poke :: Ptr CIntPtr -> CIntPtr -> IO () #
Bits CIntPtr
Methods (.&.) :: CIntPtr -> CIntPtr -> CIntPtr # (.\|.) :: CIntPtr -> CIntPtr -> CIntPtr # xor :: CIntPtr -> CIntPtr -> CIntPtr # complement :: CIntPtr -> CIntPtr # shift :: CIntPtr -> Int -> CIntPtr # rotate :: CIntPtr -> Int -> CIntPtr # zeroBits :: CIntPtr # bit :: Int -> CIntPtr # setBit :: CIntPtr -> Int -> CIntPtr # clearBit :: CIntPtr -> Int -> CIntPtr # complementBit :: CIntPtr -> Int -> CIntPtr # testBit :: CIntPtr -> Int -> Bool # bitSizeMaybe :: CIntPtr -> Maybe Int # bitSize :: CIntPtr -> Int # isSigned :: CIntPtr -> Bool # shiftL :: CIntPtr -> Int -> CIntPtr # unsafeShiftL :: CIntPtr -> Int -> CIntPtr # shiftR :: CIntPtr -> Int -> CIntPtr # unsafeShiftR :: CIntPtr -> Int -> CIntPtr # rotateL :: CIntPtr -> Int -> CIntPtr # rotateR :: CIntPtr -> Int -> CIntPtr # popCount :: CIntPtr -> Int #
FiniteBits CIntPtr
Methods finiteBitSize :: CIntPtr -> Int # countLeadingZeros :: CIntPtr -> Int # countTrailingZeros :: CIntPtr -> Int #
Integral CIntPtr Source #
Methods fromInteger :: Integer -> CIntPtr Source #
IsIntegral CIntPtr Source #
Methods toInteger :: CIntPtr -> Integer Source #
Subtractive CIntPtr Source #
Associated Types type Difference CIntPtr :: * Source # Methods (-) :: CIntPtr -> CIntPtr -> Difference CIntPtr Source #
Additive CIntPtr Source #
Methods azero :: CIntPtr Source # (+) :: CIntPtr -> CIntPtr -> CIntPtr Source # scale :: IsNatural n => n -> CIntPtr -> CIntPtr Source #
IDivisible CIntPtr Source #
Methods div :: CIntPtr -> CIntPtr -> CIntPtr Source # mod :: CIntPtr -> CIntPtr -> CIntPtr Source # divMod :: CIntPtr -> CIntPtr -> (CIntPtr, CIntPtr) Source #
Multiplicative CIntPtr Source #
Methods midentity :: CIntPtr Source # (*) :: CIntPtr -> CIntPtr -> CIntPtr Source # (^) :: (IsNatural n, IDivisible n) => CIntPtr -> n -> CIntPtr Source #
type Difference CIntPtr Source #
type Difference CIntPtr = CIntPtr

newtype CUIntPtr :: * #

Constructors

CUIntPtr Word64

Instances

Bounded CUIntPtr
Methods minBound :: CUIntPtr # maxBound :: CUIntPtr #
Enum CUIntPtr
Methods succ :: CUIntPtr -> CUIntPtr # pred :: CUIntPtr -> CUIntPtr # toEnum :: Int -> CUIntPtr # fromEnum :: CUIntPtr -> Int # enumFrom :: CUIntPtr -> [CUIntPtr] # enumFromThen :: CUIntPtr -> CUIntPtr -> [CUIntPtr] # enumFromTo :: CUIntPtr -> CUIntPtr -> [CUIntPtr] # enumFromThenTo :: CUIntPtr -> CUIntPtr -> CUIntPtr -> [CUIntPtr] #
Eq CUIntPtr
Methods (==) :: CUIntPtr -> CUIntPtr -> Bool # (/=) :: CUIntPtr -> CUIntPtr -> Bool #
Integral CUIntPtr
Methods quot :: CUIntPtr -> CUIntPtr -> CUIntPtr # rem :: CUIntPtr -> CUIntPtr -> CUIntPtr # div :: CUIntPtr -> CUIntPtr -> CUIntPtr # mod :: CUIntPtr -> CUIntPtr -> CUIntPtr # quotRem :: CUIntPtr -> CUIntPtr -> (CUIntPtr, CUIntPtr) # divMod :: CUIntPtr -> CUIntPtr -> (CUIntPtr, CUIntPtr) # toInteger :: CUIntPtr -> Integer #
Num CUIntPtr
Methods (+) :: CUIntPtr -> CUIntPtr -> CUIntPtr # (-) :: CUIntPtr -> CUIntPtr -> CUIntPtr # (*) :: CUIntPtr -> CUIntPtr -> CUIntPtr # negate :: CUIntPtr -> CUIntPtr # abs :: CUIntPtr -> CUIntPtr # signum :: CUIntPtr -> CUIntPtr # fromInteger :: Integer -> CUIntPtr #
Ord CUIntPtr
Methods compare :: CUIntPtr -> CUIntPtr -> Ordering # (<) :: CUIntPtr -> CUIntPtr -> Bool # (<=) :: CUIntPtr -> CUIntPtr -> Bool # (>) :: CUIntPtr -> CUIntPtr -> Bool # (>=) :: CUIntPtr -> CUIntPtr -> Bool # max :: CUIntPtr -> CUIntPtr -> CUIntPtr # min :: CUIntPtr -> CUIntPtr -> CUIntPtr #
Read CUIntPtr
Methods readsPrec :: Int -> ReadS CUIntPtr # readList :: ReadS [CUIntPtr] # readPrec :: ReadPrec CUIntPtr # readListPrec :: ReadPrec [CUIntPtr] #
Real CUIntPtr
Methods toRational :: CUIntPtr -> Rational #
Show CUIntPtr
Methods showsPrec :: Int -> CUIntPtr -> ShowS # show :: CUIntPtr -> String # showList :: [CUIntPtr] -> ShowS #
Storable CUIntPtr
Methods sizeOf :: CUIntPtr -> Int # alignment :: CUIntPtr -> Int # peekElemOff :: Ptr CUIntPtr -> Int -> IO CUIntPtr # pokeElemOff :: Ptr CUIntPtr -> Int -> CUIntPtr -> IO () # peekByteOff :: Ptr b -> Int -> IO CUIntPtr # pokeByteOff :: Ptr b -> Int -> CUIntPtr -> IO () # peek :: Ptr CUIntPtr -> IO CUIntPtr # poke :: Ptr CUIntPtr -> CUIntPtr -> IO () #
Bits CUIntPtr
Methods (.&.) :: CUIntPtr -> CUIntPtr -> CUIntPtr # (.\|.) :: CUIntPtr -> CUIntPtr -> CUIntPtr # xor :: CUIntPtr -> CUIntPtr -> CUIntPtr # complement :: CUIntPtr -> CUIntPtr # shift :: CUIntPtr -> Int -> CUIntPtr # rotate :: CUIntPtr -> Int -> CUIntPtr # zeroBits :: CUIntPtr # bit :: Int -> CUIntPtr # setBit :: CUIntPtr -> Int -> CUIntPtr # clearBit :: CUIntPtr -> Int -> CUIntPtr # complementBit :: CUIntPtr -> Int -> CUIntPtr # testBit :: CUIntPtr -> Int -> Bool # bitSizeMaybe :: CUIntPtr -> Maybe Int # bitSize :: CUIntPtr -> Int # isSigned :: CUIntPtr -> Bool # shiftL :: CUIntPtr -> Int -> CUIntPtr # unsafeShiftL :: CUIntPtr -> Int -> CUIntPtr # shiftR :: CUIntPtr -> Int -> CUIntPtr # unsafeShiftR :: CUIntPtr -> Int -> CUIntPtr # rotateL :: CUIntPtr -> Int -> CUIntPtr # rotateR :: CUIntPtr -> Int -> CUIntPtr # popCount :: CUIntPtr -> Int #
FiniteBits CUIntPtr
Methods finiteBitSize :: CUIntPtr -> Int # countLeadingZeros :: CUIntPtr -> Int # countTrailingZeros :: CUIntPtr -> Int #
Integral CUIntPtr Source #
Methods fromInteger :: Integer -> CUIntPtr Source #
IsNatural CUIntPtr Source #
Methods toNatural :: CUIntPtr -> Natural Source #
IsIntegral CUIntPtr Source #
Methods toInteger :: CUIntPtr -> Integer Source #
Subtractive CUIntPtr Source #
Associated Types type Difference CUIntPtr :: * Source # Methods (-) :: CUIntPtr -> CUIntPtr -> Difference CUIntPtr Source #
Additive CUIntPtr Source #
Methods azero :: CUIntPtr Source # (+) :: CUIntPtr -> CUIntPtr -> CUIntPtr Source # scale :: IsNatural n => n -> CUIntPtr -> CUIntPtr Source #
IDivisible CUIntPtr Source #
Methods div :: CUIntPtr -> CUIntPtr -> CUIntPtr Source # mod :: CUIntPtr -> CUIntPtr -> CUIntPtr Source # divMod :: CUIntPtr -> CUIntPtr -> (CUIntPtr, CUIntPtr) Source #
Multiplicative CUIntPtr Source #
Methods midentity :: CUIntPtr Source # (*) :: CUIntPtr -> CUIntPtr -> CUIntPtr Source # (^) :: (IsNatural n, IDivisible n) => CUIntPtr -> n -> CUIntPtr Source #
type Difference CUIntPtr Source #
type Difference CUIntPtr = CUIntPtr

newtype CIntMax :: * #

Constructors

CIntMax Int64

Instances

Bounded CIntMax
Methods minBound :: CIntMax # maxBound :: CIntMax #
Enum CIntMax
Methods succ :: CIntMax -> CIntMax # pred :: CIntMax -> CIntMax # toEnum :: Int -> CIntMax # fromEnum :: CIntMax -> Int # enumFrom :: CIntMax -> [CIntMax] # enumFromThen :: CIntMax -> CIntMax -> [CIntMax] # enumFromTo :: CIntMax -> CIntMax -> [CIntMax] # enumFromThenTo :: CIntMax -> CIntMax -> CIntMax -> [CIntMax] #
Eq CIntMax
Methods (==) :: CIntMax -> CIntMax -> Bool # (/=) :: CIntMax -> CIntMax -> Bool #
Integral CIntMax
Methods quot :: CIntMax -> CIntMax -> CIntMax # rem :: CIntMax -> CIntMax -> CIntMax # div :: CIntMax -> CIntMax -> CIntMax # mod :: CIntMax -> CIntMax -> CIntMax # quotRem :: CIntMax -> CIntMax -> (CIntMax, CIntMax) # divMod :: CIntMax -> CIntMax -> (CIntMax, CIntMax) # toInteger :: CIntMax -> Integer #
Num CIntMax
Methods (+) :: CIntMax -> CIntMax -> CIntMax # (-) :: CIntMax -> CIntMax -> CIntMax # (*) :: CIntMax -> CIntMax -> CIntMax # negate :: CIntMax -> CIntMax # abs :: CIntMax -> CIntMax # signum :: CIntMax -> CIntMax # fromInteger :: Integer -> CIntMax #
Ord CIntMax
Methods compare :: CIntMax -> CIntMax -> Ordering # (<) :: CIntMax -> CIntMax -> Bool # (<=) :: CIntMax -> CIntMax -> Bool # (>) :: CIntMax -> CIntMax -> Bool # (>=) :: CIntMax -> CIntMax -> Bool # max :: CIntMax -> CIntMax -> CIntMax # min :: CIntMax -> CIntMax -> CIntMax #
Read CIntMax
Methods readsPrec :: Int -> ReadS CIntMax # readList :: ReadS [CIntMax] # readPrec :: ReadPrec CIntMax # readListPrec :: ReadPrec [CIntMax] #
Real CIntMax
Methods toRational :: CIntMax -> Rational #
Show CIntMax
Methods showsPrec :: Int -> CIntMax -> ShowS # show :: CIntMax -> String # showList :: [CIntMax] -> ShowS #
Storable CIntMax
Methods sizeOf :: CIntMax -> Int # alignment :: CIntMax -> Int # peekElemOff :: Ptr CIntMax -> Int -> IO CIntMax # pokeElemOff :: Ptr CIntMax -> Int -> CIntMax -> IO () # peekByteOff :: Ptr b -> Int -> IO CIntMax # pokeByteOff :: Ptr b -> Int -> CIntMax -> IO () # peek :: Ptr CIntMax -> IO CIntMax # poke :: Ptr CIntMax -> CIntMax -> IO () #
Bits CIntMax
Methods (.&.) :: CIntMax -> CIntMax -> CIntMax # (.\|.) :: CIntMax -> CIntMax -> CIntMax # xor :: CIntMax -> CIntMax -> CIntMax # complement :: CIntMax -> CIntMax # shift :: CIntMax -> Int -> CIntMax # rotate :: CIntMax -> Int -> CIntMax # zeroBits :: CIntMax # bit :: Int -> CIntMax # setBit :: CIntMax -> Int -> CIntMax # clearBit :: CIntMax -> Int -> CIntMax # complementBit :: CIntMax -> Int -> CIntMax # testBit :: CIntMax -> Int -> Bool # bitSizeMaybe :: CIntMax -> Maybe Int # bitSize :: CIntMax -> Int # isSigned :: CIntMax -> Bool # shiftL :: CIntMax -> Int -> CIntMax # unsafeShiftL :: CIntMax -> Int -> CIntMax # shiftR :: CIntMax -> Int -> CIntMax # unsafeShiftR :: CIntMax -> Int -> CIntMax # rotateL :: CIntMax -> Int -> CIntMax # rotateR :: CIntMax -> Int -> CIntMax # popCount :: CIntMax -> Int #
FiniteBits CIntMax
Methods finiteBitSize :: CIntMax -> Int # countLeadingZeros :: CIntMax -> Int # countTrailingZeros :: CIntMax -> Int #
HasNegation CIntMax Source #
Methods negate :: CIntMax -> CIntMax Source #
Integral CIntMax Source #
Methods fromInteger :: Integer -> CIntMax Source #
IsIntegral CIntMax Source #
Methods toInteger :: CIntMax -> Integer Source #
Subtractive CIntMax Source #
Associated Types type Difference CIntMax :: * Source # Methods (-) :: CIntMax -> CIntMax -> Difference CIntMax Source #
Additive CIntMax Source #
Methods azero :: CIntMax Source # (+) :: CIntMax -> CIntMax -> CIntMax Source # scale :: IsNatural n => n -> CIntMax -> CIntMax Source #
IDivisible CIntMax Source #
Methods div :: CIntMax -> CIntMax -> CIntMax Source # mod :: CIntMax -> CIntMax -> CIntMax Source # divMod :: CIntMax -> CIntMax -> (CIntMax, CIntMax) Source #
Multiplicative CIntMax Source #
Methods midentity :: CIntMax Source # (*) :: CIntMax -> CIntMax -> CIntMax Source # (^) :: (IsNatural n, IDivisible n) => CIntMax -> n -> CIntMax Source #
type Difference CIntMax Source #
type Difference CIntMax = CIntMax

newtype CUIntMax :: * #

Constructors

CUIntMax Word64

Instances

Bounded CUIntMax
Methods minBound :: CUIntMax # maxBound :: CUIntMax #
Enum CUIntMax
Methods succ :: CUIntMax -> CUIntMax # pred :: CUIntMax -> CUIntMax # toEnum :: Int -> CUIntMax # fromEnum :: CUIntMax -> Int # enumFrom :: CUIntMax -> [CUIntMax] # enumFromThen :: CUIntMax -> CUIntMax -> [CUIntMax] # enumFromTo :: CUIntMax -> CUIntMax -> [CUIntMax] # enumFromThenTo :: CUIntMax -> CUIntMax -> CUIntMax -> [CUIntMax] #
Eq CUIntMax
Methods (==) :: CUIntMax -> CUIntMax -> Bool # (/=) :: CUIntMax -> CUIntMax -> Bool #
Integral CUIntMax
Methods quot :: CUIntMax -> CUIntMax -> CUIntMax # rem :: CUIntMax -> CUIntMax -> CUIntMax # div :: CUIntMax -> CUIntMax -> CUIntMax # mod :: CUIntMax -> CUIntMax -> CUIntMax # quotRem :: CUIntMax -> CUIntMax -> (CUIntMax, CUIntMax) # divMod :: CUIntMax -> CUIntMax -> (CUIntMax, CUIntMax) # toInteger :: CUIntMax -> Integer #
Num CUIntMax
Methods (+) :: CUIntMax -> CUIntMax -> CUIntMax # (-) :: CUIntMax -> CUIntMax -> CUIntMax # (*) :: CUIntMax -> CUIntMax -> CUIntMax # negate :: CUIntMax -> CUIntMax # abs :: CUIntMax -> CUIntMax # signum :: CUIntMax -> CUIntMax # fromInteger :: Integer -> CUIntMax #
Ord CUIntMax
Methods compare :: CUIntMax -> CUIntMax -> Ordering # (<) :: CUIntMax -> CUIntMax -> Bool # (<=) :: CUIntMax -> CUIntMax -> Bool # (>) :: CUIntMax -> CUIntMax -> Bool # (>=) :: CUIntMax -> CUIntMax -> Bool # max :: CUIntMax -> CUIntMax -> CUIntMax # min :: CUIntMax -> CUIntMax -> CUIntMax #
Read CUIntMax
Methods readsPrec :: Int -> ReadS CUIntMax # readList :: ReadS [CUIntMax] # readPrec :: ReadPrec CUIntMax # readListPrec :: ReadPrec [CUIntMax] #
Real CUIntMax
Methods toRational :: CUIntMax -> Rational #
Show CUIntMax
Methods showsPrec :: Int -> CUIntMax -> ShowS # show :: CUIntMax -> String # showList :: [CUIntMax] -> ShowS #
Storable CUIntMax
Methods sizeOf :: CUIntMax -> Int # alignment :: CUIntMax -> Int # peekElemOff :: Ptr CUIntMax -> Int -> IO CUIntMax # pokeElemOff :: Ptr CUIntMax -> Int -> CUIntMax -> IO () # peekByteOff :: Ptr b -> Int -> IO CUIntMax # pokeByteOff :: Ptr b -> Int -> CUIntMax -> IO () # peek :: Ptr CUIntMax -> IO CUIntMax # poke :: Ptr CUIntMax -> CUIntMax -> IO () #
Bits CUIntMax
Methods (.&.) :: CUIntMax -> CUIntMax -> CUIntMax # (.\|.) :: CUIntMax -> CUIntMax -> CUIntMax # xor :: CUIntMax -> CUIntMax -> CUIntMax # complement :: CUIntMax -> CUIntMax # shift :: CUIntMax -> Int -> CUIntMax # rotate :: CUIntMax -> Int -> CUIntMax # zeroBits :: CUIntMax # bit :: Int -> CUIntMax # setBit :: CUIntMax -> Int -> CUIntMax # clearBit :: CUIntMax -> Int -> CUIntMax # complementBit :: CUIntMax -> Int -> CUIntMax # testBit :: CUIntMax -> Int -> Bool # bitSizeMaybe :: CUIntMax -> Maybe Int # bitSize :: CUIntMax -> Int # isSigned :: CUIntMax -> Bool # shiftL :: CUIntMax -> Int -> CUIntMax # unsafeShiftL :: CUIntMax -> Int -> CUIntMax # shiftR :: CUIntMax -> Int -> CUIntMax # unsafeShiftR :: CUIntMax -> Int -> CUIntMax # rotateL :: CUIntMax -> Int -> CUIntMax # rotateR :: CUIntMax -> Int -> CUIntMax # popCount :: CUIntMax -> Int #
FiniteBits CUIntMax
Methods finiteBitSize :: CUIntMax -> Int # countLeadingZeros :: CUIntMax -> Int # countTrailingZeros :: CUIntMax -> Int #
Integral CUIntMax Source #
Methods fromInteger :: Integer -> CUIntMax Source #
IsNatural CUIntMax Source #
Methods toNatural :: CUIntMax -> Natural Source #
IsIntegral CUIntMax Source #
Methods toInteger :: CUIntMax -> Integer Source #
Subtractive CUIntMax Source #
Associated Types type Difference CUIntMax :: * Source # Methods (-) :: CUIntMax -> CUIntMax -> Difference CUIntMax Source #
Additive CUIntMax Source #
Methods azero :: CUIntMax Source # (+) :: CUIntMax -> CUIntMax -> CUIntMax Source # scale :: IsNatural n => n -> CUIntMax -> CUIntMax Source #
IDivisible CUIntMax Source #
Methods div :: CUIntMax -> CUIntMax -> CUIntMax Source # mod :: CUIntMax -> CUIntMax -> CUIntMax Source # divMod :: CUIntMax -> CUIntMax -> (CUIntMax, CUIntMax) Source #
Multiplicative CUIntMax Source #
Methods midentity :: CUIntMax Source # (*) :: CUIntMax -> CUIntMax -> CUIntMax Source # (^) :: (IsNatural n, IDivisible n) => CUIntMax -> n -> CUIntMax Source #
type Difference CUIntMax Source #
type Difference CUIntMax = CUIntMax

newtype CClock :: * #

Haskell type representing the C clock_t type.

Constructors

CClock Int64

Instances

Enum CClock
Methods succ :: CClock -> CClock # pred :: CClock -> CClock # toEnum :: Int -> CClock # fromEnum :: CClock -> Int # enumFrom :: CClock -> [CClock] # enumFromThen :: CClock -> CClock -> [CClock] # enumFromTo :: CClock -> CClock -> [CClock] # enumFromThenTo :: CClock -> CClock -> CClock -> [CClock] #
Eq CClock
Methods (==) :: CClock -> CClock -> Bool # (/=) :: CClock -> CClock -> Bool #
Num CClock
Methods (+) :: CClock -> CClock -> CClock # (-) :: CClock -> CClock -> CClock # (*) :: CClock -> CClock -> CClock # negate :: CClock -> CClock # abs :: CClock -> CClock # signum :: CClock -> CClock # fromInteger :: Integer -> CClock #
Ord CClock
Methods compare :: CClock -> CClock -> Ordering # (<) :: CClock -> CClock -> Bool # (<=) :: CClock -> CClock -> Bool # (>) :: CClock -> CClock -> Bool # (>=) :: CClock -> CClock -> Bool # max :: CClock -> CClock -> CClock # min :: CClock -> CClock -> CClock #
Read CClock
Methods readsPrec :: Int -> ReadS CClock # readList :: ReadS [CClock] # readPrec :: ReadPrec CClock # readListPrec :: ReadPrec [CClock] #
Real CClock
Methods toRational :: CClock -> Rational #
Show CClock
Methods showsPrec :: Int -> CClock -> ShowS # show :: CClock -> String # showList :: [CClock] -> ShowS #
Storable CClock
Methods sizeOf :: CClock -> Int # alignment :: CClock -> Int # peekElemOff :: Ptr CClock -> Int -> IO CClock # pokeElemOff :: Ptr CClock -> Int -> CClock -> IO () # peekByteOff :: Ptr b -> Int -> IO CClock # pokeByteOff :: Ptr b -> Int -> CClock -> IO () # peek :: Ptr CClock -> IO CClock # poke :: Ptr CClock -> CClock -> IO () #
Integral CClock Source #
Methods fromInteger :: Integer -> CClock Source #
Subtractive CClock Source #
Associated Types type Difference CClock :: * Source # Methods (-) :: CClock -> CClock -> Difference CClock Source #
Additive CClock Source #
Methods azero :: CClock Source # (+) :: CClock -> CClock -> CClock Source # scale :: IsNatural n => n -> CClock -> CClock Source #
Multiplicative CClock Source #
Methods midentity :: CClock Source # (*) :: CClock -> CClock -> CClock Source # (^) :: (IsNatural n, IDivisible n) => CClock -> n -> CClock Source #
type Difference CClock Source #
type Difference CClock = CClock

newtype CTime :: * #

Haskell type representing the C time_t type.

Constructors

CTime Int64

Instances

Enum CTime
Methods succ :: CTime -> CTime # pred :: CTime -> CTime # toEnum :: Int -> CTime # fromEnum :: CTime -> Int # enumFrom :: CTime -> [CTime] # enumFromThen :: CTime -> CTime -> [CTime] # enumFromTo :: CTime -> CTime -> [CTime] # enumFromThenTo :: CTime -> CTime -> CTime -> [CTime] #
Eq CTime
Methods (==) :: CTime -> CTime -> Bool # (/=) :: CTime -> CTime -> Bool #
Num CTime
Methods (+) :: CTime -> CTime -> CTime # (-) :: CTime -> CTime -> CTime # (*) :: CTime -> CTime -> CTime # negate :: CTime -> CTime # abs :: CTime -> CTime # signum :: CTime -> CTime # fromInteger :: Integer -> 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
Methods readsPrec :: Int -> ReadS CTime # readList :: ReadS [CTime] # readPrec :: ReadPrec CTime # readListPrec :: ReadPrec [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 #
Methods fromInteger :: Integer -> CTime Source #
Subtractive CTime Source #
Associated Types type Difference CTime :: * Source # Methods (-) :: CTime -> CTime -> Difference CTime Source #
Additive CTime Source #
Methods azero :: CTime Source # (+) :: CTime -> CTime -> CTime Source # scale :: IsNatural n => n -> CTime -> CTime Source #
Multiplicative CTime Source #
Methods midentity :: CTime Source # (*) :: CTime -> CTime -> CTime Source # (^) :: (IsNatural n, IDivisible n) => CTime -> n -> CTime Source #
type Difference CTime Source #
type Difference CTime = CTime

newtype CUSeconds :: * #

Haskell type representing the C useconds_t type.

Since: 4.4.0.0

Constructors

CUSeconds Word32

Instances

Enum CUSeconds
Methods succ :: CUSeconds -> CUSeconds # pred :: CUSeconds -> CUSeconds # toEnum :: Int -> CUSeconds # fromEnum :: CUSeconds -> Int # enumFrom :: CUSeconds -> [CUSeconds] # enumFromThen :: CUSeconds -> CUSeconds -> [CUSeconds] # enumFromTo :: CUSeconds -> CUSeconds -> [CUSeconds] # enumFromThenTo :: CUSeconds -> CUSeconds -> CUSeconds -> [CUSeconds] #
Eq CUSeconds
Methods (==) :: CUSeconds -> CUSeconds -> Bool # (/=) :: CUSeconds -> CUSeconds -> Bool #
Num CUSeconds
Methods (+) :: CUSeconds -> CUSeconds -> CUSeconds # (-) :: CUSeconds -> CUSeconds -> CUSeconds # (*) :: CUSeconds -> CUSeconds -> CUSeconds # negate :: CUSeconds -> CUSeconds # abs :: CUSeconds -> CUSeconds # signum :: CUSeconds -> CUSeconds # fromInteger :: Integer -> CUSeconds #
Ord CUSeconds
Methods compare :: CUSeconds -> CUSeconds -> Ordering # (<) :: CUSeconds -> CUSeconds -> Bool # (<=) :: CUSeconds -> CUSeconds -> Bool # (>) :: CUSeconds -> CUSeconds -> Bool # (>=) :: CUSeconds -> CUSeconds -> Bool # max :: CUSeconds -> CUSeconds -> CUSeconds # min :: CUSeconds -> CUSeconds -> CUSeconds #
Read CUSeconds
Methods readsPrec :: Int -> ReadS CUSeconds # readList :: ReadS [CUSeconds] # readPrec :: ReadPrec CUSeconds # readListPrec :: ReadPrec [CUSeconds] #
Real CUSeconds
Methods toRational :: CUSeconds -> Rational #
Show CUSeconds
Methods showsPrec :: Int -> CUSeconds -> ShowS # show :: CUSeconds -> String # showList :: [CUSeconds] -> ShowS #
Storable CUSeconds
Methods sizeOf :: CUSeconds -> Int # alignment :: CUSeconds -> Int # peekElemOff :: Ptr CUSeconds -> Int -> IO CUSeconds # pokeElemOff :: Ptr CUSeconds -> Int -> CUSeconds -> IO () # peekByteOff :: Ptr b -> Int -> IO CUSeconds # pokeByteOff :: Ptr b -> Int -> CUSeconds -> IO () # peek :: Ptr CUSeconds -> IO CUSeconds # poke :: Ptr CUSeconds -> CUSeconds -> IO () #
Integral CUSeconds Source #
Methods fromInteger :: Integer -> CUSeconds Source #
Subtractive CUSeconds Source #
Associated Types type Difference CUSeconds :: * Source # Methods (-) :: CUSeconds -> CUSeconds -> Difference CUSeconds Source #
Additive CUSeconds Source #
Methods azero :: CUSeconds Source # (+) :: CUSeconds -> CUSeconds -> CUSeconds Source # scale :: IsNatural n => n -> CUSeconds -> CUSeconds Source #
Multiplicative CUSeconds Source #
Methods midentity :: CUSeconds Source # (*) :: CUSeconds -> CUSeconds -> CUSeconds Source # (^) :: (IsNatural n, IDivisible n) => CUSeconds -> n -> CUSeconds Source #
type Difference CUSeconds Source #
type Difference CUSeconds = CUSeconds

newtype CSUSeconds :: * #

Haskell type representing the C suseconds_t type.

Since: 4.4.0.0

Constructors

CSUSeconds Int64

Instances

Enum CSUSeconds
Methods succ :: CSUSeconds -> CSUSeconds # pred :: CSUSeconds -> CSUSeconds # toEnum :: Int -> CSUSeconds # fromEnum :: CSUSeconds -> Int # enumFrom :: CSUSeconds -> [CSUSeconds] # enumFromThen :: CSUSeconds -> CSUSeconds -> [CSUSeconds] # enumFromTo :: CSUSeconds -> CSUSeconds -> [CSUSeconds] # enumFromThenTo :: CSUSeconds -> CSUSeconds -> CSUSeconds -> [CSUSeconds] #
Eq CSUSeconds
Methods (==) :: CSUSeconds -> CSUSeconds -> Bool # (/=) :: CSUSeconds -> CSUSeconds -> Bool #
Num CSUSeconds
Methods (+) :: CSUSeconds -> CSUSeconds -> CSUSeconds # (-) :: CSUSeconds -> CSUSeconds -> CSUSeconds # (*) :: CSUSeconds -> CSUSeconds -> CSUSeconds # negate :: CSUSeconds -> CSUSeconds # abs :: CSUSeconds -> CSUSeconds # signum :: CSUSeconds -> CSUSeconds # fromInteger :: Integer -> CSUSeconds #
Ord CSUSeconds
Methods compare :: CSUSeconds -> CSUSeconds -> Ordering # (<) :: CSUSeconds -> CSUSeconds -> Bool # (<=) :: CSUSeconds -> CSUSeconds -> Bool # (>) :: CSUSeconds -> CSUSeconds -> Bool # (>=) :: CSUSeconds -> CSUSeconds -> Bool # max :: CSUSeconds -> CSUSeconds -> CSUSeconds # min :: CSUSeconds -> CSUSeconds -> CSUSeconds #
Read CSUSeconds
Methods readsPrec :: Int -> ReadS CSUSeconds # readList :: ReadS [CSUSeconds] # readPrec :: ReadPrec CSUSeconds # readListPrec :: ReadPrec [CSUSeconds] #
Real CSUSeconds
Methods toRational :: CSUSeconds -> Rational #
Show CSUSeconds
Methods showsPrec :: Int -> CSUSeconds -> ShowS # show :: CSUSeconds -> String # showList :: [CSUSeconds] -> ShowS #
Storable CSUSeconds
Methods sizeOf :: CSUSeconds -> Int # alignment :: CSUSeconds -> Int # peekElemOff :: Ptr CSUSeconds -> Int -> IO CSUSeconds # pokeElemOff :: Ptr CSUSeconds -> Int -> CSUSeconds -> IO () # peekByteOff :: Ptr b -> Int -> IO CSUSeconds # pokeByteOff :: Ptr b -> Int -> CSUSeconds -> IO () # peek :: Ptr CSUSeconds -> IO CSUSeconds # poke :: Ptr CSUSeconds -> CSUSeconds -> IO () #
Integral CSUSeconds Source #
Methods fromInteger :: Integer -> CSUSeconds Source #
Subtractive CSUSeconds Source #
Associated Types type Difference CSUSeconds :: * Source # Methods (-) :: CSUSeconds -> CSUSeconds -> Difference CSUSeconds Source #
Additive CSUSeconds Source #
Methods azero :: CSUSeconds Source # (+) :: CSUSeconds -> CSUSeconds -> CSUSeconds Source # scale :: IsNatural n => n -> CSUSeconds -> CSUSeconds Source #
Multiplicative CSUSeconds Source #
Methods midentity :: CSUSeconds Source # (*) :: CSUSeconds -> CSUSeconds -> CSUSeconds Source # (^) :: (IsNatural n, IDivisible n) => CSUSeconds -> n -> CSUSeconds Source #
type Difference CSUSeconds Source #
type Difference CSUSeconds = CSUSeconds

newtype CFloat :: * #

Haskell type representing the C float type.

Constructors

CFloat Float

Instances

Enum CFloat
Methods succ :: CFloat -> CFloat # pred :: CFloat -> CFloat # toEnum :: Int -> CFloat # fromEnum :: CFloat -> Int # enumFrom :: CFloat -> [CFloat] # enumFromThen :: CFloat -> CFloat -> [CFloat] # enumFromTo :: CFloat -> CFloat -> [CFloat] # enumFromThenTo :: CFloat -> CFloat -> CFloat -> [CFloat] #
Eq CFloat
Methods (==) :: CFloat -> CFloat -> Bool # (/=) :: CFloat -> CFloat -> Bool #
Floating CFloat
Methods pi :: CFloat # exp :: CFloat -> CFloat # log :: CFloat -> CFloat # sqrt :: CFloat -> CFloat # (**) :: CFloat -> CFloat -> CFloat # logBase :: CFloat -> CFloat -> CFloat # sin :: CFloat -> CFloat # cos :: CFloat -> CFloat # tan :: CFloat -> CFloat # asin :: CFloat -> CFloat # acos :: CFloat -> CFloat # atan :: CFloat -> CFloat # sinh :: CFloat -> CFloat # cosh :: CFloat -> CFloat # tanh :: CFloat -> CFloat # asinh :: CFloat -> CFloat # acosh :: CFloat -> CFloat # atanh :: CFloat -> CFloat # log1p :: CFloat -> CFloat # expm1 :: CFloat -> CFloat # log1pexp :: CFloat -> CFloat # log1mexp :: CFloat -> CFloat #
Fractional CFloat
Methods (/) :: CFloat -> CFloat -> CFloat # recip :: CFloat -> CFloat # fromRational :: Rational -> CFloat #
Num CFloat
Methods (+) :: CFloat -> CFloat -> CFloat # (-) :: CFloat -> CFloat -> CFloat # (*) :: CFloat -> CFloat -> CFloat # negate :: CFloat -> CFloat # abs :: CFloat -> CFloat # signum :: CFloat -> CFloat # fromInteger :: Integer -> CFloat #
Ord CFloat
Methods compare :: CFloat -> CFloat -> Ordering # (<) :: CFloat -> CFloat -> Bool # (<=) :: CFloat -> CFloat -> Bool # (>) :: CFloat -> CFloat -> Bool # (>=) :: CFloat -> CFloat -> Bool # max :: CFloat -> CFloat -> CFloat # min :: CFloat -> CFloat -> CFloat #
Read CFloat
Methods readsPrec :: Int -> ReadS CFloat # readList :: ReadS [CFloat] # readPrec :: ReadPrec CFloat # readListPrec :: ReadPrec [CFloat] #
Real CFloat
Methods toRational :: CFloat -> Rational #
RealFloat CFloat
Methods floatRadix :: CFloat -> Integer # floatDigits :: CFloat -> Int # floatRange :: CFloat -> (Int, Int) # decodeFloat :: CFloat -> (Integer, Int) # encodeFloat :: Integer -> Int -> CFloat # exponent :: CFloat -> Int # significand :: CFloat -> CFloat # scaleFloat :: Int -> CFloat -> CFloat # isNaN :: CFloat -> Bool # isInfinite :: CFloat -> Bool # isDenormalized :: CFloat -> Bool # isNegativeZero :: CFloat -> Bool # isIEEE :: CFloat -> Bool # atan2 :: CFloat -> CFloat -> 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
Methods showsPrec :: Int -> CFloat -> ShowS # show :: CFloat -> String # showList :: [CFloat] -> ShowS #
Storable CFloat
Methods sizeOf :: CFloat -> Int # alignment :: CFloat -> Int # peekElemOff :: Ptr CFloat -> Int -> IO CFloat # pokeElemOff :: Ptr CFloat -> Int -> CFloat -> IO () # peekByteOff :: Ptr b -> Int -> IO CFloat # pokeByteOff :: Ptr b -> Int -> CFloat -> IO () # peek :: Ptr CFloat -> IO CFloat # poke :: Ptr CFloat -> CFloat -> IO () #
HasNegation CFloat Source #
Methods negate :: CFloat -> CFloat Source #
Fractional CFloat Source #
Methods fromRational :: Rational -> CFloat Source #
Integral CFloat Source #
Methods fromInteger :: Integer -> CFloat Source #
Subtractive CFloat Source #
Associated Types type Difference CFloat :: * Source # Methods (-) :: CFloat -> CFloat -> Difference CFloat Source #
Additive CFloat Source #
Methods azero :: CFloat Source # (+) :: CFloat -> CFloat -> CFloat Source # scale :: IsNatural n => n -> CFloat -> CFloat Source #
Divisible CFloat Source #
Methods (/) :: CFloat -> CFloat -> CFloat Source #
Multiplicative CFloat Source #
Methods midentity :: CFloat Source # (*) :: CFloat -> CFloat -> CFloat Source # (^) :: (IsNatural n, IDivisible n) => CFloat -> n -> CFloat Source #
NormalForm CFloat Source #
Methods toNormalForm :: CFloat -> () Source #
type Difference CFloat Source #
type Difference CFloat = CFloat

data CDouble :: * #

Haskell type representing the C double type.

Instances

Enum CDouble
Methods succ :: CDouble -> CDouble # pred :: CDouble -> CDouble # toEnum :: Int -> CDouble # fromEnum :: CDouble -> Int # enumFrom :: CDouble -> [CDouble] # enumFromThen :: CDouble -> CDouble -> [CDouble] # enumFromTo :: CDouble -> CDouble -> [CDouble] # enumFromThenTo :: CDouble -> CDouble -> CDouble -> [CDouble] #
Eq CDouble
Methods (==) :: CDouble -> CDouble -> Bool # (/=) :: CDouble -> CDouble -> Bool #
Floating CDouble
Methods pi :: CDouble # exp :: CDouble -> CDouble # log :: CDouble -> CDouble # sqrt :: CDouble -> CDouble # (**) :: CDouble -> CDouble -> CDouble # logBase :: CDouble -> CDouble -> CDouble # sin :: CDouble -> CDouble # cos :: CDouble -> CDouble # tan :: CDouble -> CDouble # asin :: CDouble -> CDouble # acos :: CDouble -> CDouble # atan :: CDouble -> CDouble # sinh :: CDouble -> CDouble # cosh :: CDouble -> CDouble # tanh :: CDouble -> CDouble # asinh :: CDouble -> CDouble # acosh :: CDouble -> CDouble # atanh :: CDouble -> CDouble # log1p :: CDouble -> CDouble # expm1 :: CDouble -> CDouble # log1pexp :: CDouble -> CDouble # log1mexp :: CDouble -> CDouble #
Fractional CDouble
Methods (/) :: CDouble -> CDouble -> CDouble # recip :: CDouble -> CDouble # fromRational :: Rational -> CDouble #
Num CDouble
Methods (+) :: CDouble -> CDouble -> CDouble # (-) :: CDouble -> CDouble -> CDouble # (*) :: CDouble -> CDouble -> CDouble # negate :: CDouble -> CDouble # abs :: CDouble -> CDouble # signum :: CDouble -> CDouble # fromInteger :: Integer -> CDouble #
Ord CDouble
Methods compare :: CDouble -> CDouble -> Ordering # (<) :: CDouble -> CDouble -> Bool # (<=) :: CDouble -> CDouble -> Bool # (>) :: CDouble -> CDouble -> Bool # (>=) :: CDouble -> CDouble -> Bool # max :: CDouble -> CDouble -> CDouble # min :: CDouble -> CDouble -> CDouble #
Read CDouble
Methods readsPrec :: Int -> ReadS CDouble # readList :: ReadS [CDouble] # readPrec :: ReadPrec CDouble # readListPrec :: ReadPrec [CDouble] #
Real CDouble
Methods toRational :: CDouble -> Rational #
RealFloat CDouble
Methods floatRadix :: CDouble -> Integer # floatDigits :: CDouble -> Int # floatRange :: CDouble -> (Int, Int) # decodeFloat :: CDouble -> (Integer, Int) # encodeFloat :: Integer -> Int -> CDouble # exponent :: CDouble -> Int # significand :: CDouble -> CDouble # scaleFloat :: Int -> CDouble -> CDouble # isNaN :: CDouble -> Bool # isInfinite :: CDouble -> Bool # isDenormalized :: CDouble -> Bool # isNegativeZero :: CDouble -> Bool # isIEEE :: CDouble -> Bool # atan2 :: CDouble -> CDouble -> 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
Methods showsPrec :: Int -> CDouble -> ShowS # show :: CDouble -> String # showList :: [CDouble] -> ShowS #
Storable CDouble
Methods sizeOf :: CDouble -> Int # alignment :: CDouble -> Int # peekElemOff :: Ptr CDouble -> Int -> IO CDouble # pokeElemOff :: Ptr CDouble -> Int -> CDouble -> IO () # peekByteOff :: Ptr b -> Int -> IO CDouble # pokeByteOff :: Ptr b -> Int -> CDouble -> IO () # peek :: Ptr CDouble -> IO CDouble # poke :: Ptr CDouble -> CDouble -> IO () #
HasNegation CDouble Source #
Methods negate :: CDouble -> CDouble Source #
Fractional CDouble Source #
Methods fromRational :: Rational -> CDouble Source #
Integral CDouble Source #
Methods fromInteger :: Integer -> CDouble Source #
Subtractive CDouble Source #
Associated Types type Difference CDouble :: * Source # Methods (-) :: CDouble -> CDouble -> Difference CDouble Source #
Additive CDouble Source #
Methods azero :: CDouble Source # (+) :: CDouble -> CDouble -> CDouble Source # scale :: IsNatural n => n -> CDouble -> CDouble Source #
Divisible CDouble Source #
Methods (/) :: CDouble -> CDouble -> CDouble Source #
Multiplicative CDouble Source #
Methods midentity :: CDouble Source # (*) :: CDouble -> CDouble -> CDouble Source # (^) :: (IsNatural n, IDivisible n) => CDouble -> n -> CDouble Source #
NormalForm CDouble Source #
Methods toNormalForm :: CDouble -> () Source #
type Difference CDouble Source #
type Difference CDouble = CDouble

newtype COff :: * #

Constructors

COff Int64

Instances

Bounded COff
Methods minBound :: COff # maxBound :: 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
Methods readsPrec :: Int -> ReadS COff # readList :: ReadS [COff] # readPrec :: ReadPrec COff # readListPrec :: ReadPrec [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
Methods (.&.) :: COff -> COff -> COff # (.\|.) :: COff -> COff -> COff # xor :: COff -> COff -> COff # complement :: COff -> COff # shift :: COff -> Int -> COff # rotate :: COff -> Int -> COff # zeroBits :: COff # bit :: Int -> COff # setBit :: COff -> Int -> COff # clearBit :: COff -> Int -> COff # complementBit :: COff -> Int -> COff # testBit :: COff -> Int -> Bool # bitSizeMaybe :: COff -> Maybe Int # bitSize :: COff -> Int # isSigned :: COff -> Bool # shiftL :: COff -> Int -> COff # unsafeShiftL :: COff -> Int -> COff # shiftR :: COff -> Int -> COff # unsafeShiftR :: COff -> Int -> COff # rotateL :: COff -> Int -> COff # rotateR :: COff -> Int -> COff # popCount :: COff -> Int #
FiniteBits COff
Methods finiteBitSize :: COff -> Int # countLeadingZeros :: COff -> Int # countTrailingZeros :: COff -> Int #
Integral COff Source #
Methods fromInteger :: Integer -> 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 #
type Difference COff = COff

newtype CMode :: * #

Constructors

CMode Word32

Instances

Bounded CMode
Methods minBound :: CMode # maxBound :: CMode #
Enum CMode
Methods succ :: CMode -> CMode # pred :: CMode -> CMode # toEnum :: Int -> CMode # fromEnum :: CMode -> Int # enumFrom :: CMode -> [CMode] # enumFromThen :: CMode -> CMode -> [CMode] # enumFromTo :: CMode -> CMode -> [CMode] # enumFromThenTo :: CMode -> CMode -> CMode -> [CMode] #
Eq CMode
Methods (==) :: CMode -> CMode -> Bool # (/=) :: CMode -> CMode -> Bool #
Integral CMode
Methods quot :: CMode -> CMode -> CMode # rem :: CMode -> CMode -> CMode # div :: CMode -> CMode -> CMode # mod :: CMode -> CMode -> CMode # quotRem :: CMode -> CMode -> (CMode, CMode) # divMod :: CMode -> CMode -> (CMode, CMode) # toInteger :: CMode -> Integer #
Num CMode
Methods (+) :: CMode -> CMode -> CMode # (-) :: CMode -> CMode -> CMode # (*) :: CMode -> CMode -> CMode # negate :: CMode -> CMode # abs :: CMode -> CMode # signum :: CMode -> CMode # fromInteger :: Integer -> 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
Methods readsPrec :: Int -> ReadS CMode # readList :: ReadS [CMode] # readPrec :: ReadPrec CMode # readListPrec :: ReadPrec [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
Methods (.&.) :: CMode -> CMode -> CMode # (.\|.) :: CMode -> CMode -> CMode # xor :: CMode -> CMode -> CMode # complement :: CMode -> CMode # shift :: CMode -> Int -> CMode # rotate :: CMode -> Int -> CMode # zeroBits :: CMode # bit :: Int -> CMode # setBit :: CMode -> Int -> CMode # clearBit :: CMode -> Int -> CMode # complementBit :: CMode -> Int -> CMode # testBit :: CMode -> Int -> Bool # bitSizeMaybe :: CMode -> Maybe Int # bitSize :: CMode -> Int # isSigned :: CMode -> Bool # shiftL :: CMode -> Int -> CMode # unsafeShiftL :: CMode -> Int -> CMode # shiftR :: CMode -> Int -> CMode # unsafeShiftR :: CMode -> Int -> CMode # rotateL :: CMode -> Int -> CMode # rotateR :: CMode -> Int -> CMode # popCount :: CMode -> Int #
FiniteBits CMode
Methods finiteBitSize :: CMode -> Int # countLeadingZeros :: CMode -> Int # countTrailingZeros :: CMode -> Int #