System.Win32.Com.HDirect.HDirect

Stubs for marshalling and unmarshalling primitive types, as used by HaskellDirect-generated code.

Documentation

foreignPtrToPtr :: ForeignPtr a -> Ptr a

marshallInt :: Int -> IO Int

unmarshallInt :: Int -> IO Int

writeInt :: Ptr Int -> Int -> IO ()

readInt :: Ptr Int -> IO Int

sizeofInt :: Word32

marshallInt8 :: Int8 -> IO Int8

unmarshallInt8 :: Int8 -> IO Int8

writeInt8 :: Ptr Int8 -> Int8 -> IO ()

readInt8 :: Ptr Int8 -> IO Int8

sizeofInt8 :: Word32

marshallInt16 :: Int16 -> IO Int16

unmarshallInt16 :: Int16 -> IO Int16

writeInt16 :: Ptr Int16 -> Int16 -> IO ()

readInt16 :: Ptr Int16 -> IO Int16

sizeofInt16 :: Word32

marshallInt32 :: Int32 -> IO Int32

unmarshallInt32 :: Int32 -> IO Int32

writeInt32 :: Ptr Int32 -> Int32 -> IO ()

readInt32 :: Ptr Int32 -> IO Int32

sizeofInt32 :: Word32

marshallInt64 :: Int64 -> IO Int64

unmarshallInt64 :: Int64 -> IO Int64

writeInt64 :: Ptr Int64 -> Int64 -> IO ()

readInt64 :: Ptr Int64 -> IO Int64

sizeofInt64 :: Word32

type Hyper = Int64

marshallHyper :: Hyper -> IO Int64

unmarshallHyper :: Int64 -> IO Hyper

writeHyper :: Ptr Hyper -> Hyper -> IO ()

readHyper :: Ptr Hyper -> IO Hyper

sizeofHyper :: Word32

writeInteger :: Ptr Integer -> Integer -> IO ()

readInteger :: Ptr Integer -> IO Integer

marshallInteger :: Integer -> IO (Int32, Int32)

unmarshallInteger :: (Int32, Int32) -> IO Integer

marshallUInteger :: Integer -> IO (Int32, Int32)

unmarshallUInteger :: (Int32, Int32) -> IO Integer

readUInteger :: Ptr Integer -> IO Integer

writeUInteger :: Ptr Integer -> Integer -> IO ()

marshallChar :: Char -> IO Char

unmarshallChar :: Char -> IO Char

writeChar :: Ptr Char -> Char -> IO ()

readChar :: Ptr Char -> IO Char

sizeofChar :: Word32

type Wchar_t = Word16

marshallWchar_t :: Wchar_t -> IO Wchar_t

unmarshallWchar_t :: Wchar_t -> IO Wchar_t

writeWchar_t :: Ptr Wchar_t -> Wchar_t -> IO ()

readWchar_t :: Ptr Wchar_t -> IO Wchar_t

sizeofWchar_t :: Word32

type Octet = Byte

type Byte = Word8

marshallByte :: Byte -> IO Byte

unmarshallByte :: Byte -> IO Byte

writeByte :: Ptr Byte -> Byte -> IO ()

readByte :: Ptr Byte -> IO Byte

sizeofByte :: Word32

marshallWord8 :: Word8 -> IO Word8

unmarshallWord8 :: Word8 -> IO Word8

writeWord8 :: Ptr Word8 -> Word8 -> IO ()

readWord8 :: Ptr Word8 -> IO Word8

sizeofWord8 :: Word32

marshallWord16 :: Word16 -> IO Word16

unmarshallWord16 :: Word16 -> IO Word16

writeWord16 :: Ptr Word16 -> Word16 -> IO ()

readWord16 :: Ptr Word16 -> IO Word16

sizeofWord16 :: Word32

marshallWord32 :: Word32 -> IO Word32

unmarshallWord32 :: Word32 -> IO Word32

writeWord32 :: Ptr Word32 -> Word32 -> IO ()

readWord32 :: Ptr Word32 -> IO Word32

sizeofWord32 :: Word32

marshallWord64 :: Word64 -> IO Word64

unmarshallWord64 :: Word64 -> IO Word64

writeWord64 :: Ptr Word64 -> Word64 -> IO ()

readWord64 :: Ptr Word64 -> IO Word64

sizeofWord64 :: Word32

marshallDouble :: Double -> IO Double

unmarshallDouble :: Double -> IO Double

writeDouble :: Ptr Double -> Double -> IO ()

readDouble :: Ptr Double -> IO Double

sizeofDouble :: Word32

writeFloat :: Ptr Float -> Float -> IO ()

readFloat :: Ptr Float -> IO Float

sizeofFloat :: Word32

marshallBool :: Bool -> IO Int32

unmarshallBool :: Int32 -> IO Bool

writeBool :: Ptr Bool -> Bool -> IO ()

readBool :: Ptr Bool -> IO Bool

sizeofBool :: Word32

addNCastPtr :: Ptr a -> Word32 -> Ptr b

derefPtr :: Ptr (Ptr a) -> IO (Ptr a)

indexPtr :: Ptr (Ptr a) -> Int -> IO (Ptr a)

allocOutPtr :: IO (Ptr a)

allocBytes :: Int -> IO (Ptr a)

allocWords :: Int -> IO (Ptr a)

alloc_malloc :: Word32 -> IO (Ptr a)

free_malloc :: Ptr a -> IO ()

free :: Ptr a -> IO ()

alloc :: Word32 -> IO (Ptr a)

doThenFree :: (Ptr a -> IO ()) -> (Ptr b -> IO c) -> Ptr d -> IO c

trivialFree :: a -> IO ()

fillIn :: Int -> (Ptr a -> IO ()) -> IO (Ptr a)

marshallPtr :: Ptr a -> IO (Ptr a)

unmarshallPtr :: Ptr a -> IO (Ptr a)

writePtr :: Ptr (Ptr a) -> Ptr a -> IO ()

readPtr :: Ptr a -> IO (Ptr b)

writefptr :: Ptr b -> ForeignPtr a -> IO ()

marshallunique :: IO (Ptr a) -> (Ptr a -> a -> IO ()) -> Maybe a -> IO (Ptr a)

marshallMaybe :: (a -> IO b) -> b -> Maybe a -> IO b

writeMaybe :: (Ptr a -> a -> IO ()) -> Ptr (Maybe a) -> Maybe a -> IO ()

readMaybe :: (Ptr a -> IO b) -> Ptr a -> IO (Maybe b)

writeunique :: IO (Ptr a) -> (Ptr a -> a -> IO ()) -> Ptr (Maybe a) -> Maybe a -> IO ()

writeunique_fun :: IO (Ptr a) -> (Ptr (Ptr a) -> a -> IO ()) -> Ptr (Maybe a) -> Maybe a -> IO ()

unmarshallunique :: (Ptr a -> IO a) -> Ptr a -> IO (Maybe a)

readunique :: (Ptr a -> IO a) -> Ptr b -> IO (Maybe a)

freeunique :: (Ptr a -> IO ()) -> Ptr (Ptr a) -> IO ()

marshallunique_ptr :: Maybe (Ptr a) -> IO (Ptr a)

marshallref :: IO (Ptr a) -> (Ptr a -> a -> IO ()) -> a -> IO (Ptr a)

writeref :: IO (Ptr a) -> (Ptr a -> a -> IO ()) -> Ptr (Ptr a) -> a -> IO ()

unmarshallref :: (Ptr a -> IO b) -> Ptr a -> IO b

readref :: (Ptr a -> IO a) -> Ptr (Ptr a) -> IO a

freeref :: (Ptr b -> IO ()) -> Ptr a -> IO ()

writeenum16 :: (b -> IO Int16) -> Ptr Int16 -> b -> IO ()

readenum16 :: (Int16 -> IO a) -> Ptr Int16 -> IO a

marshallEnum16 :: Enum a => a -> IO Int16

unmarshallEnum16 :: Enum a => Int16 -> IO a

marshallEnum32 :: Enum a => a -> IO Int32

unmarshallEnum32 :: Enum a => Int32 -> IO a

writeEnum32 :: Enum a => Ptr b -> a -> IO ()

readEnum32 :: Enum a => Ptr b -> IO a

writeEnum16 :: Enum a => Ptr b -> a -> IO ()

readEnum16 :: Enum a => Ptr b -> IO a

marshalllist :: Word32 -> (Ptr a -> a -> IO ()) -> [a] -> IO (Ptr b)

unmarshalllist :: Word32 -> Word32 -> Word32 -> (Ptr any -> IO a) -> Ptr b -> IO [a]

unmarshallSingle :: (Ptr a -> IO a) -> Ptr a -> IO [a]

writelist :: Bool -> Word32 -> (Ptr a -> a -> IO ()) -> Ptr [a] -> [a] -> IO ()

readlist :: Word32 -> Word32 -> (Ptr a -> IO a) -> Ptr [a] -> IO [a]

freelist :: Word32 -> Word32 -> (Ptr a -> IO ()) -> Ptr [a] -> IO ()

marshallString :: String -> IO (Ptr String)

marshallBString :: Int -> String -> IO (Ptr String)

unmarshallString :: Ptr String -> IO String

unmarshallBString :: Int -> Ptr String -> IO String

readString :: Ptr (Ptr String) -> IO String

readBString :: Int -> Ptr (Ptr String) -> IO String

writeString :: Bool -> Ptr String -> String -> IO ()

writeBString :: Bool -> Int -> Ptr a -> String -> IO ()

freeString :: Ptr String -> IO ()

marshallSequence :: (Ptr a -> a -> IO ()) -> (Ptr a -> IO ()) -> Word32 -> Maybe Word32 -> [a] -> IO (Ptr a)

unmarshallSequence :: Eq a => (Ptr (Ptr a) -> IO a) -> (Ptr (Ptr a) -> IO Bool) -> Word32 -> Maybe Word32 -> Ptr (Ptr a) -> IO [a]

readSequence :: Eq a => (Ptr (Ptr a) -> IO a) -> (Ptr (Ptr a) -> IO Bool) -> Word32 -> Maybe Word32 -> Ptr (Ptr a) -> IO [a]

writeSequence :: Eq a => Bool -> (Ptr a -> a -> IO ()) -> (Ptr a -> IO ()) -> Word32 -> Maybe Word32 -> Ptr a -> [a] -> IO ()

freeSequence :: Ptr a -> IO ()

marshallblist :: Word32 -> Word32 -> (Ptr a -> a -> IO ()) -> [a] -> IO (Ptr [a])

writeblist :: Word32 -> Word32 -> (Ptr a -> a -> IO ()) -> Ptr [a] -> [a] -> IO ()

readblist :: Word32 -> Word32 -> (Ptr a -> IO a) -> Ptr a -> IO [a]

word16ToInt32 :: Word16 -> Int32

word32ToInt32 :: Word32 -> Int32

int32ToWord32 :: Int32 -> Word32

int16ToWord32 :: Int16 -> Word32

intToChar :: Int -> Char

charToInt32 :: Char -> Int32

word32ToChar :: Word32 -> Char

charToWord32 :: Char -> Word32

toInt32 :: Integral a => a -> Int32

toInt16 :: Integral a => a -> Int16

marshallFO :: ForeignPtr a -> IO (ForeignPtr a)

unmarshallFO :: ForeignPtr a -> IO (ForeignPtr a)

writeFO :: Ptr (ForeignPtr a) -> ForeignPtr a -> IO ()

sizeofForeignPtr :: Word32

nullFinaliser :: FunPtr (Ptr a -> IO ())

nullFO :: ForeignPtr a

readStablePtr :: Ptr (StablePtr a) -> IO (StablePtr a)

marshallStruct :: String -> a -> IO b

unmarshallStruct :: String -> a -> IO c

marshallUnion :: String -> a -> IO b

unmarshallUnion :: String -> a -> b -> IO c

marshallPointer :: Ptr a -> IO (Ptr a)

unmarshallPointer :: Ptr a -> IO (Ptr a)

writePointer :: Ptr (Ptr a) -> Ptr a -> IO ()

readPointer :: Ptr (Ptr a) -> IO (Ptr a)

sizeofPtr :: Word32

primInvokeIt :: (Ptr b -> Ptr a -> IO c) -> Int -> IO (Ptr a) -> IO c

primInvokeItFO :: (Ptr b -> Ptr a -> IO c) -> Int -> IO (ForeignPtr a) -> IO c

stackStringLen :: Int -> String -> (Ptr String -> IO a) -> IO a

enumToFlag :: Enum a => a -> Int

enumToInt :: Enum a => a -> Int

flagToIntTag :: Int -> Int

unboxInt :: Int -> Int#

toIntFlag :: Int -> Int -> Int

pow2Series :: Int -> Int32 -> [Int32]

orList :: [Int] -> Int

orFlags :: (Num a, Flags a) => [a] -> a

class Flags a where

Minimal complete definition

(.+.)

Methods

(.+.) :: a -> a -> a infixl 5

Instances

Flags LIBFLAGS

Methods

(.+.) :: LIBFLAGS -> LIBFLAGS -> LIBFLAGS

Flags SYSKIND

Methods

(.+.) :: SYSKIND -> SYSKIND -> SYSKIND

Flags VARFLAGS

Methods

(.+.) :: VARFLAGS -> VARFLAGS -> VARFLAGS

Flags FUNCFLAGS

Methods

(.+.) :: FUNCFLAGS -> FUNCFLAGS -> FUNCFLAGS

Flags TYPEFLAGS

Methods

(.+.) :: TYPEFLAGS -> TYPEFLAGS -> TYPEFLAGS

Flags INVOKEKIND

Methods

(.+.) :: INVOKEKIND -> INVOKEKIND -> INVOKEKIND

data Int8 :: *

8-bit signed integer type

Instances

Bounded Int8

Methods

minBound :: Int8

maxBound :: Int8

Enum Int8

Methods

succ :: Int8 -> Int8

pred :: Int8 -> Int8

toEnum :: Int -> Int8

fromEnum :: Int8 -> Int

enumFrom :: Int8 -> [Int8]

enumFromThen :: Int8 -> Int8 -> [Int8]

enumFromTo :: Int8 -> Int8 -> [Int8]

enumFromThenTo :: Int8 -> Int8 -> Int8 -> [Int8]

Eq Int8

Methods

(==) :: Int8 -> Int8 -> Bool

(/=) :: Int8 -> Int8 -> Bool

Integral Int8

Methods

quot :: Int8 -> Int8 -> Int8

rem :: Int8 -> Int8 -> Int8

div :: Int8 -> Int8 -> Int8

mod :: Int8 -> Int8 -> Int8

quotRem :: Int8 -> Int8 -> (Int8, Int8)

divMod :: Int8 -> Int8 -> (Int8, Int8)

toInteger :: Int8 -> Integer

Num Int8

Methods

(+) :: Int8 -> Int8 -> Int8

(-) :: Int8 -> Int8 -> Int8

(*) :: Int8 -> Int8 -> Int8

negate :: Int8 -> Int8

abs :: Int8 -> Int8

signum :: Int8 -> Int8

fromInteger :: Integer -> Int8

Ord Int8

Methods

compare :: Int8 -> Int8 -> Ordering

(<) :: Int8 -> Int8 -> Bool

(<=) :: Int8 -> Int8 -> Bool

(>) :: Int8 -> Int8 -> Bool

(>=) :: Int8 -> Int8 -> Bool

max :: Int8 -> Int8 -> Int8

min :: Int8 -> Int8 -> Int8

Read Int8

Methods

readsPrec :: Int -> ReadS Int8

readList :: ReadS [Int8]

readPrec :: ReadPrec Int8

readListPrec :: ReadPrec [Int8]

Real Int8

Methods

toRational :: Int8 -> Rational

Show Int8

Methods

showsPrec :: Int -> Int8 -> ShowS

show :: Int8 -> String

showList :: [Int8] -> ShowS

Ix Int8

Methods

range :: (Int8, Int8) -> [Int8]

index :: (Int8, Int8) -> Int8 -> Int

unsafeIndex :: (Int8, Int8) -> Int8 -> Int

inRange :: (Int8, Int8) -> Int8 -> Bool

rangeSize :: (Int8, Int8) -> Int

unsafeRangeSize :: (Int8, Int8) -> Int

Storable Int8

Methods

sizeOf :: Int8 -> Int

alignment :: Int8 -> Int

peekElemOff :: Ptr Int8 -> Int -> IO Int8

pokeElemOff :: Ptr Int8 -> Int -> Int8 -> IO ()

peekByteOff :: Ptr b -> Int -> IO Int8

pokeByteOff :: Ptr b -> Int -> Int8 -> IO ()

peek :: Ptr Int8 -> IO Int8

poke :: Ptr Int8 -> Int8 -> IO ()

Bits Int8

Methods

(.&.) :: Int8 -> Int8 -> Int8

(.|.) :: Int8 -> Int8 -> Int8

xor :: Int8 -> Int8 -> Int8

complement :: Int8 -> Int8

shift :: Int8 -> Int -> Int8

rotate :: Int8 -> Int -> Int8

zeroBits :: Int8

bit :: Int -> Int8

setBit :: Int8 -> Int -> Int8

clearBit :: Int8 -> Int -> Int8

complementBit :: Int8 -> Int -> Int8

testBit :: Int8 -> Int -> Bool

bitSizeMaybe :: Int8 -> Maybe Int

bitSize :: Int8 -> Int

isSigned :: Int8 -> Bool

shiftL :: Int8 -> Int -> Int8

unsafeShiftL :: Int8 -> Int -> Int8

shiftR :: Int8 -> Int -> Int8

unsafeShiftR :: Int8 -> Int -> Int8

rotateL :: Int8 -> Int -> Int8

rotateR :: Int8 -> Int -> Int8

popCount :: Int8 -> Int

FiniteBits Int8

Methods

finiteBitSize :: Int8 -> Int

countLeadingZeros :: Int8 -> Int

countTrailingZeros :: Int8 -> Int

Variant Int8

Methods

inVariant :: ArgIn Int8

inVarList :: ArgIn [Int8]

inVarIUnknown :: ArgIn (IUnknown Int8)

vtEltType :: Int8 -> VARENUM

resVariant :: ArgRes Int8

defaultVariant :: Int8

resVarList :: ArgRes [Int8]

resVarIUnknown :: ArgRes (IUnknown Int8)

resVarIDispatch :: ArgRes (IDispatch Int8)

data Int16 :: *

16-bit signed integer type

Instances

Bounded Int16

Methods

minBound :: Int16

maxBound :: Int16

Enum Int16

Methods

succ :: Int16 -> Int16

pred :: Int16 -> Int16

toEnum :: Int -> Int16

fromEnum :: Int16 -> Int

enumFrom :: Int16 -> [Int16]

enumFromThen :: Int16 -> Int16 -> [Int16]

enumFromTo :: Int16 -> Int16 -> [Int16]

enumFromThenTo :: Int16 -> Int16 -> Int16 -> [Int16]

Eq Int16

Methods

(==) :: Int16 -> Int16 -> Bool

(/=) :: Int16 -> Int16 -> Bool

Integral Int16

Methods

quot :: Int16 -> Int16 -> Int16

rem :: Int16 -> Int16 -> Int16

div :: Int16 -> Int16 -> Int16

mod :: Int16 -> Int16 -> Int16

quotRem :: Int16 -> Int16 -> (Int16, Int16)

divMod :: Int16 -> Int16 -> (Int16, Int16)

toInteger :: Int16 -> Integer

Num Int16

Methods

(+) :: Int16 -> Int16 -> Int16

(-) :: Int16 -> Int16 -> Int16

(*) :: Int16 -> Int16 -> Int16

negate :: Int16 -> Int16

abs :: Int16 -> Int16

signum :: Int16 -> Int16

fromInteger :: Integer -> Int16

Ord Int16

Methods

compare :: Int16 -> Int16 -> Ordering

(<) :: Int16 -> Int16 -> Bool

(<=) :: Int16 -> Int16 -> Bool

(>) :: Int16 -> Int16 -> Bool

(>=) :: Int16 -> Int16 -> Bool

max :: Int16 -> Int16 -> Int16

min :: Int16 -> Int16 -> Int16

Read Int16

Methods

readsPrec :: Int -> ReadS Int16

readList :: ReadS [Int16]

readPrec :: ReadPrec Int16

readListPrec :: ReadPrec [Int16]

Real Int16

Methods

toRational :: Int16 -> Rational

Show Int16

Methods

showsPrec :: Int -> Int16 -> ShowS

show :: Int16 -> String

showList :: [Int16] -> ShowS

Ix Int16

Methods

range :: (Int16, Int16) -> [Int16]

index :: (Int16, Int16) -> Int16 -> Int

unsafeIndex :: (Int16, Int16) -> Int16 -> Int

inRange :: (Int16, Int16) -> Int16 -> Bool

rangeSize :: (Int16, Int16) -> Int

unsafeRangeSize :: (Int16, Int16) -> Int

Storable Int16

Methods

sizeOf :: Int16 -> Int

alignment :: Int16 -> Int

peekElemOff :: Ptr Int16 -> Int -> IO Int16

pokeElemOff :: Ptr Int16 -> Int -> Int16 -> IO ()

peekByteOff :: Ptr b -> Int -> IO Int16

pokeByteOff :: Ptr b -> Int -> Int16 -> IO ()

peek :: Ptr Int16 -> IO Int16

poke :: Ptr Int16 -> Int16 -> IO ()

Bits Int16

Methods

(.&.) :: Int16 -> Int16 -> Int16

(.|.) :: Int16 -> Int16 -> Int16

xor :: Int16 -> Int16 -> Int16

complement :: Int16 -> Int16

shift :: Int16 -> Int -> Int16

rotate :: Int16 -> Int -> Int16

zeroBits :: Int16

bit :: Int -> Int16

setBit :: Int16 -> Int -> Int16

clearBit :: Int16 -> Int -> Int16

complementBit :: Int16 -> Int -> Int16

testBit :: Int16 -> Int -> Bool

bitSizeMaybe :: Int16 -> Maybe Int

bitSize :: Int16 -> Int

isSigned :: Int16 -> Bool

shiftL :: Int16 -> Int -> Int16

unsafeShiftL :: Int16 -> Int -> Int16

shiftR :: Int16 -> Int -> Int16

unsafeShiftR :: Int16 -> Int -> Int16

rotateL :: Int16 -> Int -> Int16

rotateR :: Int16 -> Int -> Int16

popCount :: Int16 -> Int

FiniteBits Int16

Methods

finiteBitSize :: Int16 -> Int

countLeadingZeros :: Int16 -> Int

countTrailingZeros :: Int16 -> Int

Variant Int16

Methods

inVariant :: ArgIn Int16

inVarList :: ArgIn [Int16]

inVarIUnknown :: ArgIn (IUnknown Int16)

vtEltType :: Int16 -> VARENUM

resVariant :: ArgRes Int16

defaultVariant :: Int16

resVarList :: ArgRes [Int16]

resVarIUnknown :: ArgRes (IUnknown Int16)

resVarIDispatch :: ArgRes (IDispatch Int16)

data Int32 :: *

32-bit signed integer type

Instances

Bounded Int32

Methods

minBound :: Int32

maxBound :: Int32

Enum Int32

Methods

succ :: Int32 -> Int32

pred :: Int32 -> Int32

toEnum :: Int -> Int32

fromEnum :: Int32 -> Int

enumFrom :: Int32 -> [Int32]

enumFromThen :: Int32 -> Int32 -> [Int32]

enumFromTo :: Int32 -> Int32 -> [Int32]

enumFromThenTo :: Int32 -> Int32 -> Int32 -> [Int32]

Eq Int32

Methods

(==) :: Int32 -> Int32 -> Bool

(/=) :: Int32 -> Int32 -> Bool

Integral Int32

Methods

quot :: Int32 -> Int32 -> Int32

rem :: Int32 -> Int32 -> Int32

div :: Int32 -> Int32 -> Int32

mod :: Int32 -> Int32 -> Int32

quotRem :: Int32 -> Int32 -> (Int32, Int32)

divMod :: Int32 -> Int32 -> (Int32, Int32)

toInteger :: Int32 -> Integer

Num Int32

Methods

(+) :: Int32 -> Int32 -> Int32

(-) :: Int32 -> Int32 -> Int32

(*) :: Int32 -> Int32 -> Int32

negate :: Int32 -> Int32

abs :: Int32 -> Int32

signum :: Int32 -> Int32

fromInteger :: Integer -> Int32

Ord Int32

Methods

compare :: Int32 -> Int32 -> Ordering

(<) :: Int32 -> Int32 -> Bool

(<=) :: Int32 -> Int32 -> Bool

(>) :: Int32 -> Int32 -> Bool

(>=) :: Int32 -> Int32 -> Bool

max :: Int32 -> Int32 -> Int32

min :: Int32 -> Int32 -> Int32

Read Int32

Methods

readsPrec :: Int -> ReadS Int32

readList :: ReadS [Int32]

readPrec :: ReadPrec Int32

readListPrec :: ReadPrec [Int32]

Real Int32

Methods

toRational :: Int32 -> Rational

Show Int32

Methods

showsPrec :: Int -> Int32 -> ShowS

show :: Int32 -> String

showList :: [Int32] -> ShowS

Ix Int32

Methods

range :: (Int32, Int32) -> [Int32]

index :: (Int32, Int32) -> Int32 -> Int

unsafeIndex :: (Int32, Int32) -> Int32 -> Int

inRange :: (Int32, Int32) -> Int32 -> Bool

rangeSize :: (Int32, Int32) -> Int

unsafeRangeSize :: (Int32, Int32) -> Int

Storable Int32

Methods

sizeOf :: Int32 -> Int

alignment :: Int32 -> Int

peekElemOff :: Ptr Int32 -> Int -> IO Int32

pokeElemOff :: Ptr Int32 -> Int -> Int32 -> IO ()

peekByteOff :: Ptr b -> Int -> IO Int32

pokeByteOff :: Ptr b -> Int -> Int32 -> IO ()

peek :: Ptr Int32 -> IO Int32

poke :: Ptr Int32 -> Int32 -> IO ()

Bits Int32

Methods

(.&.) :: Int32 -> Int32 -> Int32

(.|.) :: Int32 -> Int32 -> Int32

xor :: Int32 -> Int32 -> Int32

complement :: Int32 -> Int32

shift :: Int32 -> Int -> Int32

rotate :: Int32 -> Int -> Int32

zeroBits :: Int32

bit :: Int -> Int32

setBit :: Int32 -> Int -> Int32

clearBit :: Int32 -> Int -> Int32

complementBit :: Int32 -> Int -> Int32

testBit :: Int32 -> Int -> Bool

bitSizeMaybe :: Int32 -> Maybe Int

bitSize :: Int32 -> Int

isSigned :: Int32 -> Bool

shiftL :: Int32 -> Int -> Int32

unsafeShiftL :: Int32 -> Int -> Int32

shiftR :: Int32 -> Int -> Int32

unsafeShiftR :: Int32 -> Int -> Int32

rotateL :: Int32 -> Int -> Int32

rotateR :: Int32 -> Int -> Int32

popCount :: Int32 -> Int

FiniteBits Int32

Methods

finiteBitSize :: Int32 -> Int

countLeadingZeros :: Int32 -> Int

countTrailingZeros :: Int32 -> Int

Variant Int32

Methods

inVariant :: ArgIn Int32

inVarList :: ArgIn [Int32]

inVarIUnknown :: ArgIn (IUnknown Int32)

vtEltType :: Int32 -> VARENUM

resVariant :: ArgRes Int32

defaultVariant :: Int32

resVarList :: ArgRes [Int32]

resVarIUnknown :: ArgRes (IUnknown Int32)

resVarIDispatch :: ArgRes (IDispatch Int32)

data Int64 :: *

64-bit signed integer type

Instances

Bounded Int64

Methods

minBound :: Int64

maxBound :: Int64

Enum Int64

Methods

succ :: Int64 -> Int64

pred :: Int64 -> Int64

toEnum :: Int -> Int64

fromEnum :: Int64 -> Int

enumFrom :: Int64 -> [Int64]

enumFromThen :: Int64 -> Int64 -> [Int64]

enumFromTo :: Int64 -> Int64 -> [Int64]

enumFromThenTo :: Int64 -> Int64 -> Int64 -> [Int64]

Eq Int64

Methods

(==) :: Int64 -> Int64 -> Bool

(/=) :: Int64 -> Int64 -> Bool

Integral Int64

Methods

quot :: Int64 -> Int64 -> Int64

rem :: Int64 -> Int64 -> Int64

div :: Int64 -> Int64 -> Int64

mod :: Int64 -> Int64 -> Int64

quotRem :: Int64 -> Int64 -> (Int64, Int64)

divMod :: Int64 -> Int64 -> (Int64, Int64)

toInteger :: Int64 -> Integer

Num Int64

Methods

(+) :: Int64 -> Int64 -> Int64

(-) :: Int64 -> Int64 -> Int64

(*) :: Int64 -> Int64 -> Int64

negate :: Int64 -> Int64

abs :: Int64 -> Int64

signum :: Int64 -> Int64

fromInteger :: Integer -> Int64

Ord Int64

Methods

compare :: Int64 -> Int64 -> Ordering

(<) :: Int64 -> Int64 -> Bool

(<=) :: Int64 -> Int64 -> Bool

(>) :: Int64 -> Int64 -> Bool

(>=) :: Int64 -> Int64 -> Bool

max :: Int64 -> Int64 -> Int64

min :: Int64 -> Int64 -> Int64

Read Int64

Methods

readsPrec :: Int -> ReadS Int64

readList :: ReadS [Int64]

readPrec :: ReadPrec Int64

readListPrec :: ReadPrec [Int64]

Real Int64

Methods

toRational :: Int64 -> Rational

Show Int64

Methods

showsPrec :: Int -> Int64 -> ShowS

show :: Int64 -> String

showList :: [Int64] -> ShowS

Ix Int64

Methods

range :: (Int64, Int64) -> [Int64]

index :: (Int64, Int64) -> Int64 -> Int

unsafeIndex :: (Int64, Int64) -> Int64 -> Int

inRange :: (Int64, Int64) -> Int64 -> Bool

rangeSize :: (Int64, Int64) -> Int

unsafeRangeSize :: (Int64, Int64) -> Int

Storable Int64

Methods

sizeOf :: Int64 -> Int

alignment :: Int64 -> Int

peekElemOff :: Ptr Int64 -> Int -> IO Int64

pokeElemOff :: Ptr Int64 -> Int -> Int64 -> IO ()

peekByteOff :: Ptr b -> Int -> IO Int64

pokeByteOff :: Ptr b -> Int -> Int64 -> IO ()

peek :: Ptr Int64 -> IO Int64

poke :: Ptr Int64 -> Int64 -> IO ()

Bits Int64

Methods

(.&.) :: Int64 -> Int64 -> Int64

(.|.) :: Int64 -> Int64 -> Int64

xor :: Int64 -> Int64 -> Int64

complement :: Int64 -> Int64

shift :: Int64 -> Int -> Int64

rotate :: Int64 -> Int -> Int64

zeroBits :: Int64

bit :: Int -> Int64

setBit :: Int64 -> Int -> Int64

clearBit :: Int64 -> Int -> Int64

complementBit :: Int64 -> Int -> Int64

testBit :: Int64 -> Int -> Bool

bitSizeMaybe :: Int64 -> Maybe Int

bitSize :: Int64 -> Int

isSigned :: Int64 -> Bool

shiftL :: Int64 -> Int -> Int64

unsafeShiftL :: Int64 -> Int -> Int64

shiftR :: Int64 -> Int -> Int64

unsafeShiftR :: Int64 -> Int -> Int64

rotateL :: Int64 -> Int -> Int64

rotateR :: Int64 -> Int -> Int64

popCount :: Int64 -> Int

FiniteBits Int64

Methods

finiteBitSize :: Int64 -> Int

countLeadingZeros :: Int64 -> Int

countTrailingZeros :: Int64 -> Int

Variant Int64

Methods

inVariant :: ArgIn Int64

inVarList :: ArgIn [Int64]

inVarIUnknown :: ArgIn (IUnknown Int64)

vtEltType :: Int64 -> VARENUM

resVariant :: ArgRes Int64

defaultVariant :: Int64

resVarList :: ArgRes [Int64]

resVarIUnknown :: ArgRes (IUnknown Int64)

resVarIDispatch :: ArgRes (IDispatch Int64)

data Word8 :: *

8-bit unsigned integer type

Instances

Bounded Word8

Methods

minBound :: Word8

maxBound :: Word8

Enum Word8

Methods

succ :: Word8 -> Word8

pred :: Word8 -> Word8

toEnum :: Int -> Word8

fromEnum :: Word8 -> Int

enumFrom :: Word8 -> [Word8]

enumFromThen :: Word8 -> Word8 -> [Word8]

enumFromTo :: Word8 -> Word8 -> [Word8]

enumFromThenTo :: Word8 -> Word8 -> Word8 -> [Word8]

Eq Word8

Methods

(==) :: Word8 -> Word8 -> Bool

(/=) :: Word8 -> Word8 -> Bool

Integral Word8

Methods

quot :: Word8 -> Word8 -> Word8

rem :: Word8 -> Word8 -> Word8

div :: Word8 -> Word8 -> Word8

mod :: Word8 -> Word8 -> Word8

quotRem :: Word8 -> Word8 -> (Word8, Word8)

divMod :: Word8 -> Word8 -> (Word8, Word8)

toInteger :: Word8 -> Integer

Num Word8

Methods

(+) :: Word8 -> Word8 -> Word8

(-) :: Word8 -> Word8 -> Word8

(*) :: Word8 -> Word8 -> Word8

negate :: Word8 -> Word8

abs :: Word8 -> Word8

signum :: Word8 -> Word8

fromInteger :: Integer -> Word8

Ord Word8

Methods

compare :: Word8 -> Word8 -> Ordering

(<) :: Word8 -> Word8 -> Bool

(<=) :: Word8 -> Word8 -> Bool

(>) :: Word8 -> Word8 -> Bool

(>=) :: Word8 -> Word8 -> Bool

max :: Word8 -> Word8 -> Word8

min :: Word8 -> Word8 -> Word8

Read Word8

Methods

readsPrec :: Int -> ReadS Word8

readList :: ReadS [Word8]

readPrec :: ReadPrec Word8

readListPrec :: ReadPrec [Word8]

Real Word8

Methods

toRational :: Word8 -> Rational

Show Word8

Methods

showsPrec :: Int -> Word8 -> ShowS

show :: Word8 -> String

showList :: [Word8] -> ShowS

Ix Word8

Methods

range :: (Word8, Word8) -> [Word8]

index :: (Word8, Word8) -> Word8 -> Int

unsafeIndex :: (Word8, Word8) -> Word8 -> Int

inRange :: (Word8, Word8) -> Word8 -> Bool

rangeSize :: (Word8, Word8) -> Int

unsafeRangeSize :: (Word8, Word8) -> Int

Storable Word8

Methods

sizeOf :: Word8 -> Int

alignment :: Word8 -> Int

peekElemOff :: Ptr Word8 -> Int -> IO Word8

pokeElemOff :: Ptr Word8 -> Int -> Word8 -> IO ()

peekByteOff :: Ptr b -> Int -> IO Word8

pokeByteOff :: Ptr b -> Int -> Word8 -> IO ()

peek :: Ptr Word8 -> IO Word8

poke :: Ptr Word8 -> Word8 -> IO ()

Bits Word8

Methods

(.&.) :: Word8 -> Word8 -> Word8

(.|.) :: Word8 -> Word8 -> Word8

xor :: Word8 -> Word8 -> Word8

complement :: Word8 -> Word8

shift :: Word8 -> Int -> Word8

rotate :: Word8 -> Int -> Word8

zeroBits :: Word8

bit :: Int -> Word8

setBit :: Word8 -> Int -> Word8

clearBit :: Word8 -> Int -> Word8

complementBit :: Word8 -> Int -> Word8

testBit :: Word8 -> Int -> Bool

bitSizeMaybe :: Word8 -> Maybe Int

bitSize :: Word8 -> Int

isSigned :: Word8 -> Bool

shiftL :: Word8 -> Int -> Word8

unsafeShiftL :: Word8 -> Int -> Word8

shiftR :: Word8 -> Int -> Word8

unsafeShiftR :: Word8 -> Int -> Word8

rotateL :: Word8 -> Int -> Word8

rotateR :: Word8 -> Int -> Word8

popCount :: Word8 -> Int

FiniteBits Word8

Methods

finiteBitSize :: Word8 -> Int

countLeadingZeros :: Word8 -> Int

countTrailingZeros :: Word8 -> Int

Variant Word8

Methods

inVariant :: ArgIn Word8

inVarList :: ArgIn [Word8]

inVarIUnknown :: ArgIn (IUnknown Word8)

vtEltType :: Word8 -> VARENUM

resVariant :: ArgRes Word8

defaultVariant :: Word8

resVarList :: ArgRes [Word8]

resVarIUnknown :: ArgRes (IUnknown Word8)

resVarIDispatch :: ArgRes (IDispatch Word8)

data Word16 :: *

16-bit unsigned integer type

Instances

Bounded Word16

Methods

minBound :: Word16

maxBound :: Word16

Enum Word16

Methods

succ :: Word16 -> Word16

pred :: Word16 -> Word16

toEnum :: Int -> Word16

fromEnum :: Word16 -> Int

enumFrom :: Word16 -> [Word16]

enumFromThen :: Word16 -> Word16 -> [Word16]

enumFromTo :: Word16 -> Word16 -> [Word16]

enumFromThenTo :: Word16 -> Word16 -> Word16 -> [Word16]

Eq Word16

Methods

(==) :: Word16 -> Word16 -> Bool

(/=) :: Word16 -> Word16 -> Bool

Integral Word16

Methods

quot :: Word16 -> Word16 -> Word16

rem :: Word16 -> Word16 -> Word16

div :: Word16 -> Word16 -> Word16

mod :: Word16 -> Word16 -> Word16

quotRem :: Word16 -> Word16 -> (Word16, Word16)

divMod :: Word16 -> Word16 -> (Word16, Word16)

toInteger :: Word16 -> Integer

Num Word16

Methods

(+) :: Word16 -> Word16 -> Word16

(-) :: Word16 -> Word16 -> Word16

(*) :: Word16 -> Word16 -> Word16

negate :: Word16 -> Word16

abs :: Word16 -> Word16

signum :: Word16 -> Word16

fromInteger :: Integer -> Word16

Ord Word16

Methods

compare :: Word16 -> Word16 -> Ordering

(<) :: Word16 -> Word16 -> Bool

(<=) :: Word16 -> Word16 -> Bool

(>) :: Word16 -> Word16 -> Bool

(>=) :: Word16 -> Word16 -> Bool

max :: Word16 -> Word16 -> Word16

min :: Word16 -> Word16 -> Word16

Read Word16

Methods

readsPrec :: Int -> ReadS Word16

readList :: ReadS [Word16]

readPrec :: ReadPrec Word16

readListPrec :: ReadPrec [Word16]

Real Word16

Methods

toRational :: Word16 -> Rational

Show Word16

Methods

showsPrec :: Int -> Word16 -> ShowS

show :: Word16 -> String

showList :: [Word16] -> ShowS

Ix Word16

Methods

range :: (Word16, Word16) -> [Word16]

index :: (Word16, Word16) -> Word16 -> Int

unsafeIndex :: (Word16, Word16) -> Word16 -> Int

inRange :: (Word16, Word16) -> Word16 -> Bool

rangeSize :: (Word16, Word16) -> Int

unsafeRangeSize :: (Word16, Word16) -> Int

Storable Word16

Methods

sizeOf :: Word16 -> Int

alignment :: Word16 -> Int

peekElemOff :: Ptr Word16 -> Int -> IO Word16

pokeElemOff :: Ptr Word16 -> Int -> Word16 -> IO ()

peekByteOff :: Ptr b -> Int -> IO Word16

pokeByteOff :: Ptr b -> Int -> Word16 -> IO ()

peek :: Ptr Word16 -> IO Word16

poke :: Ptr Word16 -> Word16 -> IO ()

Bits Word16

Methods

(.&.) :: Word16 -> Word16 -> Word16

(.|.) :: Word16 -> Word16 -> Word16

xor :: Word16 -> Word16 -> Word16

complement :: Word16 -> Word16

shift :: Word16 -> Int -> Word16

rotate :: Word16 -> Int -> Word16

zeroBits :: Word16

bit :: Int -> Word16

setBit :: Word16 -> Int -> Word16

clearBit :: Word16 -> Int -> Word16

complementBit :: Word16 -> Int -> Word16

testBit :: Word16 -> Int -> Bool

bitSizeMaybe :: Word16 -> Maybe Int

bitSize :: Word16 -> Int

isSigned :: Word16 -> Bool

shiftL :: Word16 -> Int -> Word16

unsafeShiftL :: Word16 -> Int -> Word16

shiftR :: Word16 -> Int -> Word16

unsafeShiftR :: Word16 -> Int -> Word16

rotateL :: Word16 -> Int -> Word16

rotateR :: Word16 -> Int -> Word16

popCount :: Word16 -> Int

FiniteBits Word16

Methods

finiteBitSize :: Word16 -> Int

countLeadingZeros :: Word16 -> Int

countTrailingZeros :: Word16 -> Int

Variant Word16

Methods

inVariant :: ArgIn Word16

inVarList :: ArgIn [Word16]

inVarIUnknown :: ArgIn (IUnknown Word16)

vtEltType :: Word16 -> VARENUM

resVariant :: ArgRes Word16

defaultVariant :: Word16

resVarList :: ArgRes [Word16]

resVarIUnknown :: ArgRes (IUnknown Word16)

resVarIDispatch :: ArgRes (IDispatch Word16)

data Word32 :: *

32-bit unsigned integer type

Instances

Bounded Word32

Methods

minBound :: Word32

maxBound :: Word32

Enum Word32

Methods

succ :: Word32 -> Word32

pred :: Word32 -> Word32

toEnum :: Int -> Word32

fromEnum :: Word32 -> Int

enumFrom :: Word32 -> [Word32]

enumFromThen :: Word32 -> Word32 -> [Word32]

enumFromTo :: Word32 -> Word32 -> [Word32]

enumFromThenTo :: Word32 -> Word32 -> Word32 -> [Word32]

Eq Word32

Methods

(==) :: Word32 -> Word32 -> Bool

(/=) :: Word32 -> Word32 -> Bool

Integral Word32

Methods

quot :: Word32 -> Word32 -> Word32

rem :: Word32 -> Word32 -> Word32

div :: Word32 -> Word32 -> Word32

mod :: Word32 -> Word32 -> Word32

quotRem :: Word32 -> Word32 -> (Word32, Word32)

divMod :: Word32 -> Word32 -> (Word32, Word32)

toInteger :: Word32 -> Integer

Num Word32

Methods

(+) :: Word32 -> Word32 -> Word32

(-) :: Word32 -> Word32 -> Word32

(*) :: Word32 -> Word32 -> Word32

negate :: Word32 -> Word32

abs :: Word32 -> Word32

signum :: Word32 -> Word32

fromInteger :: Integer -> Word32

Ord Word32

Methods

compare :: Word32 -> Word32 -> Ordering

(<) :: Word32 -> Word32 -> Bool

(<=) :: Word32 -> Word32 -> Bool

(>) :: Word32 -> Word32 -> Bool

(>=) :: Word32 -> Word32 -> Bool

max :: Word32 -> Word32 -> Word32

min :: Word32 -> Word32 -> Word32

Read Word32

Methods

readsPrec :: Int -> ReadS Word32

readList :: ReadS [Word32]

readPrec :: ReadPrec Word32

readListPrec :: ReadPrec [Word32]

Real Word32

Methods

toRational :: Word32 -> Rational

Show Word32

Methods

showsPrec :: Int -> Word32 -> ShowS

show :: Word32 -> String

showList :: [Word32] -> ShowS

Ix Word32

Methods

range :: (Word32, Word32) -> [Word32]

index :: (Word32, Word32) -> Word32 -> Int

unsafeIndex :: (Word32, Word32) -> Word32 -> Int

inRange :: (Word32, Word32) -> Word32 -> Bool

rangeSize :: (Word32, Word32) -> Int

unsafeRangeSize :: (Word32, Word32) -> Int

Storable Word32

Methods

sizeOf :: Word32 -> Int

alignment :: Word32 -> Int

peekElemOff :: Ptr Word32 -> Int -> IO Word32

pokeElemOff :: Ptr Word32 -> Int -> Word32 -> IO ()

peekByteOff :: Ptr b -> Int -> IO Word32

pokeByteOff :: Ptr b -> Int -> Word32 -> IO ()

peek :: Ptr Word32 -> IO Word32

poke :: Ptr Word32 -> Word32 -> IO ()

Bits Word32

Methods

(.&.) :: Word32 -> Word32 -> Word32

(.|.) :: Word32 -> Word32 -> Word32

xor :: Word32 -> Word32 -> Word32

complement :: Word32 -> Word32

shift :: Word32 -> Int -> Word32

rotate :: Word32 -> Int -> Word32

zeroBits :: Word32

bit :: Int -> Word32

setBit :: Word32 -> Int -> Word32

clearBit :: Word32 -> Int -> Word32

complementBit :: Word32 -> Int -> Word32

testBit :: Word32 -> Int -> Bool

bitSizeMaybe :: Word32 -> Maybe Int

bitSize :: Word32 -> Int

isSigned :: Word32 -> Bool

shiftL :: Word32 -> Int -> Word32

unsafeShiftL :: Word32 -> Int -> Word32

shiftR :: Word32 -> Int -> Word32

unsafeShiftR :: Word32 -> Int -> Word32

rotateL :: Word32 -> Int -> Word32

rotateR :: Word32 -> Int -> Word32

popCount :: Word32 -> Int

FiniteBits Word32

Methods

finiteBitSize :: Word32 -> Int

countLeadingZeros :: Word32 -> Int

countTrailingZeros :: Word32 -> Int

Variant Word32

Methods

inVariant :: ArgIn Word32

inVarList :: ArgIn [Word32]

inVarIUnknown :: ArgIn (IUnknown Word32)

vtEltType :: Word32 -> VARENUM

resVariant :: ArgRes Word32

defaultVariant :: Word32

resVarList :: ArgRes [Word32]

resVarIUnknown :: ArgRes (IUnknown Word32)

resVarIDispatch :: ArgRes (IDispatch Word32)

data Word64 :: *

64-bit unsigned integer type

Instances

Bounded Word64

Methods

minBound :: Word64

maxBound :: Word64

Enum Word64

Methods

succ :: Word64 -> Word64

pred :: Word64 -> Word64

toEnum :: Int -> Word64

fromEnum :: Word64 -> Int

enumFrom :: Word64 -> [Word64]

enumFromThen :: Word64 -> Word64 -> [Word64]

enumFromTo :: Word64 -> Word64 -> [Word64]

enumFromThenTo :: Word64 -> Word64 -> Word64 -> [Word64]

Eq Word64

Methods

(==) :: Word64 -> Word64 -> Bool

(/=) :: Word64 -> Word64 -> Bool

Integral Word64

Methods

quot :: Word64 -> Word64 -> Word64

rem :: Word64 -> Word64 -> Word64

div :: Word64 -> Word64 -> Word64

mod :: Word64 -> Word64 -> Word64

quotRem :: Word64 -> Word64 -> (Word64, Word64)

divMod :: Word64 -> Word64 -> (Word64, Word64)

toInteger :: Word64 -> Integer

Num Word64

Methods

(+) :: Word64 -> Word64 -> Word64

(-) :: Word64 -> Word64 -> Word64

(*) :: Word64 -> Word64 -> Word64

negate :: Word64 -> Word64

abs :: Word64 -> Word64

signum :: Word64 -> Word64

fromInteger :: Integer -> Word64

Ord Word64

Methods

compare :: Word64 -> Word64 -> Ordering

(<) :: Word64 -> Word64 -> Bool

(<=) :: Word64 -> Word64 -> Bool

(>) :: Word64 -> Word64 -> Bool

(>=) :: Word64 -> Word64 -> Bool

max :: Word64 -> Word64 -> Word64

min :: Word64 -> Word64 -> Word64

Read Word64

Methods

readsPrec :: Int -> ReadS Word64

readList :: ReadS [Word64]

readPrec :: ReadPrec Word64

readListPrec :: ReadPrec [Word64]

Real Word64

Methods

toRational :: Word64 -> Rational

Show Word64

Methods

showsPrec :: Int -> Word64 -> ShowS

show :: Word64 -> String

showList :: [Word64] -> ShowS

Ix Word64

Methods

range :: (Word64, Word64) -> [Word64]

index :: (Word64, Word64) -> Word64 -> Int

unsafeIndex :: (Word64, Word64) -> Word64 -> Int

inRange :: (Word64, Word64) -> Word64 -> Bool

rangeSize :: (Word64, Word64) -> Int

unsafeRangeSize :: (Word64, Word64) -> Int

Storable Word64

Methods

sizeOf :: Word64 -> Int

alignment :: Word64 -> Int

peekElemOff :: Ptr Word64 -> Int -> IO Word64

pokeElemOff :: Ptr Word64 -> Int -> Word64 -> IO ()

peekByteOff :: Ptr b -> Int -> IO Word64

pokeByteOff :: Ptr b -> Int -> Word64 -> IO ()

peek :: Ptr Word64 -> IO Word64

poke :: Ptr Word64 -> Word64 -> IO ()

Bits Word64

Methods

(.&.) :: Word64 -> Word64 -> Word64

(.|.) :: Word64 -> Word64 -> Word64

xor :: Word64 -> Word64 -> Word64

complement :: Word64 -> Word64

shift :: Word64 -> Int -> Word64

rotate :: Word64 -> Int -> Word64

zeroBits :: Word64

bit :: Int -> Word64

setBit :: Word64 -> Int -> Word64

clearBit :: Word64 -> Int -> Word64

complementBit :: Word64 -> Int -> Word64

testBit :: Word64 -> Int -> Bool

bitSizeMaybe :: Word64 -> Maybe Int

bitSize :: Word64 -> Int

isSigned :: Word64 -> Bool

shiftL :: Word64 -> Int -> Word64

unsafeShiftL :: Word64 -> Int -> Word64

shiftR :: Word64 -> Int -> Word64

unsafeShiftR :: Word64 -> Int -> Word64

rotateL :: Word64 -> Int -> Word64

rotateR :: Word64 -> Int -> Word64

popCount :: Word64 -> Int

FiniteBits Word64

Methods

finiteBitSize :: Word64 -> Int

countLeadingZeros :: Word64 -> Int

countTrailingZeros :: Word64 -> Int

Variant Word64

Methods

inVariant :: ArgIn Word64

inVarList :: ArgIn [Word64]

inVarIUnknown :: ArgIn (IUnknown Word64)

vtEltType :: Word64 -> VARENUM

resVariant :: ArgRes Word64

defaultVariant :: Word64

resVarList :: ArgRes [Word64]

resVarIUnknown :: ArgRes (IUnknown Word64)

resVarIDispatch :: ArgRes (IDispatch Word64)

data Char :: *

The character type Char is an enumeration whose values represent Unicode (or equivalently ISO/IEC 10646) characters (see http://www.unicode.org/ for details). This set extends the ISO 8859-1 (Latin-1) character set (the first 256 characters), which is itself an extension of the ASCII character set (the first 128 characters). A character literal in Haskell has type Char.

To convert a Char to or from the corresponding Int value defined by Unicode, use toEnum and fromEnum from the Enum class respectively (or equivalently ord and chr).

Instances

Bounded Char

Methods

minBound :: Char

maxBound :: Char

Enum Char

Methods

succ :: Char -> Char

pred :: Char -> Char

toEnum :: Int -> Char

fromEnum :: Char -> Int

enumFrom :: Char -> [Char]

enumFromThen :: Char -> Char -> [Char]

enumFromTo :: Char -> Char -> [Char]

enumFromThenTo :: Char -> Char -> Char -> [Char]

Eq Char

Methods

(==) :: Char -> Char -> Bool

(/=) :: Char -> Char -> Bool

Ord Char

Methods

compare :: Char -> Char -> Ordering

(<) :: Char -> Char -> Bool

(<=) :: Char -> Char -> Bool

(>) :: Char -> Char -> Bool

(>=) :: Char -> Char -> Bool

max :: Char -> Char -> Char

min :: Char -> Char -> Char

Show Char

Methods

showsPrec :: Int -> Char -> ShowS

show :: Char -> String

showList :: [Char] -> ShowS

Storable Char

Methods

sizeOf :: Char -> Int

alignment :: Char -> Int

peekElemOff :: Ptr Char -> Int -> IO Char

pokeElemOff :: Ptr Char -> Int -> Char -> IO ()

peekByteOff :: Ptr b -> Int -> IO Char

pokeByteOff :: Ptr b -> Int -> Char -> IO ()

peek :: Ptr Char -> IO Char

poke :: Ptr Char -> Char -> IO ()

Variant Char

Methods

inVariant :: ArgIn Char

inVarList :: ArgIn [Char]

inVarIUnknown :: ArgIn (IUnknown Char)

vtEltType :: Char -> VARENUM

resVariant :: ArgRes Char

defaultVariant :: Char

resVarList :: ArgRes [Char]

resVarIUnknown :: ArgRes (IUnknown Char)

resVarIDispatch :: ArgRes (IDispatch Char)

Functor (URec Char)

Methods

fmap :: (a -> b) -> URec Char a -> URec Char b

(<$) :: a -> URec Char b -> URec Char a

Foldable (URec Char)

Methods

fold :: Monoid m => URec Char m -> m

foldMap :: Monoid m => (a -> m) -> URec Char a -> m

foldr :: (a -> b -> b) -> b -> URec Char a -> b

foldr' :: (a -> b -> b) -> b -> URec Char a -> b

foldl :: (b -> a -> b) -> b -> URec Char a -> b

foldl' :: (b -> a -> b) -> b -> URec Char a -> b

foldr1 :: (a -> a -> a) -> URec Char a -> a

foldl1 :: (a -> a -> a) -> URec Char a -> a

toList :: URec Char a -> [a]

null :: URec Char a -> Bool

length :: URec Char a -> Int

elem :: Eq a => a -> URec Char a -> Bool

maximum :: Ord a => URec Char a -> a

minimum :: Ord a => URec Char a -> a

sum :: Num a => URec Char a -> a

product :: Num a => URec Char a -> a

Traversable (URec Char)

Methods

traverse :: Applicative f => (a -> f b) -> URec Char a -> f (URec Char b)

sequenceA :: Applicative f => URec Char (f a) -> f (URec Char a)

mapM :: Monad m => (a -> m b) -> URec Char a -> m (URec Char b)

sequence :: Monad m => URec Char (m a) -> m (URec Char a)

Generic1 (URec Char)

Associated Types

type Rep1 (URec Char :: * -> *) :: * -> *

Methods

from1 :: URec Char a -> Rep1 (URec Char) a

to1 :: Rep1 (URec Char) a -> URec Char a

Eq (URec Char p)

Methods

(==) :: URec Char p -> URec Char p -> Bool

(/=) :: URec Char p -> URec Char p -> Bool

Ord (URec Char p)

Methods

compare :: URec Char p -> URec Char p -> Ordering

(<) :: URec Char p -> URec Char p -> Bool

(<=) :: URec Char p -> URec Char p -> Bool

(>) :: URec Char p -> URec Char p -> Bool

(>=) :: URec Char p -> URec Char p -> Bool

max :: URec Char p -> URec Char p -> URec Char p

min :: URec Char p -> URec Char p -> URec Char p

Show (URec Char p)

Methods

showsPrec :: Int -> URec Char p -> ShowS

show :: URec Char p -> String

showList :: [URec Char p] -> ShowS

Generic (URec Char p)

Associated Types

type Rep (URec Char p) :: * -> *

Methods

from :: URec Char p -> Rep (URec Char p) x

to :: Rep (URec Char p) x -> URec Char p

data URec Char

Used for marking occurrences of Char#

data URec Char = UChar {

• uChar# :: Char#

}

type Rep1 (URec Char)

type Rep1 (URec Char) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UChar" PrefixI True) (S1 (MetaSel (Just Symbol "uChar#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UChar))

type Rep (URec Char p)

type Rep (URec Char p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UChar" PrefixI True) (S1 (MetaSel (Just Symbol "uChar#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UChar))

data Double :: *

Double-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE double-precision type.

Instances

Eq Double

Methods

(==) :: Double -> Double -> Bool

(/=) :: Double -> Double -> Bool

Floating Double

Methods

pi :: Double

exp :: Double -> Double

log :: Double -> Double

sqrt :: Double -> Double

(**) :: Double -> Double -> Double

logBase :: Double -> Double -> Double

sin :: Double -> Double

cos :: Double -> Double

tan :: Double -> Double

asin :: Double -> Double

acos :: Double -> Double

atan :: Double -> Double

sinh :: Double -> Double

cosh :: Double -> Double

tanh :: Double -> Double

asinh :: Double -> Double

acosh :: Double -> Double

atanh :: Double -> Double

log1p :: Double -> Double

expm1 :: Double -> Double

log1pexp :: Double -> Double

log1mexp :: Double -> Double

Ord Double

Methods

compare :: Double -> Double -> Ordering

(<) :: Double -> Double -> Bool

(<=) :: Double -> Double -> Bool

(>) :: Double -> Double -> Bool

(>=) :: Double -> Double -> Bool

max :: Double -> Double -> Double

min :: Double -> Double -> Double

RealFloat Double

Methods

floatRadix :: Double -> Integer

floatDigits :: Double -> Int

floatRange :: Double -> (Int, Int)

decodeFloat :: Double -> (Integer, Int)

encodeFloat :: Integer -> Int -> Double

exponent :: Double -> Int

significand :: Double -> Double

scaleFloat :: Int -> Double -> Double

isNaN :: Double -> Bool

isInfinite :: Double -> Bool

isDenormalized :: Double -> Bool

isNegativeZero :: Double -> Bool

isIEEE :: Double -> Bool

atan2 :: Double -> Double -> Double

Storable Double

Methods

sizeOf :: Double -> Int

alignment :: Double -> Int

peekElemOff :: Ptr Double -> Int -> IO Double

pokeElemOff :: Ptr Double -> Int -> Double -> IO ()

peekByteOff :: Ptr b -> Int -> IO Double

pokeByteOff :: Ptr b -> Int -> Double -> IO ()

peek :: Ptr Double -> IO Double

poke :: Ptr Double -> Double -> IO ()

Variant Double

Methods

inVariant :: ArgIn Double

inVarList :: ArgIn [Double]

inVarIUnknown :: ArgIn (IUnknown Double)

vtEltType :: Double -> VARENUM

resVariant :: ArgRes Double

defaultVariant :: Double

resVarList :: ArgRes [Double]

resVarIUnknown :: ArgRes (IUnknown Double)

resVarIDispatch :: ArgRes (IDispatch Double)

Functor (URec Double)

Methods

fmap :: (a -> b) -> URec Double a -> URec Double b

(<$) :: a -> URec Double b -> URec Double a

Foldable (URec Double)

Methods

fold :: Monoid m => URec Double m -> m

foldMap :: Monoid m => (a -> m) -> URec Double a -> m

foldr :: (a -> b -> b) -> b -> URec Double a -> b

foldr' :: (a -> b -> b) -> b -> URec Double a -> b

foldl :: (b -> a -> b) -> b -> URec Double a -> b

foldl' :: (b -> a -> b) -> b -> URec Double a -> b

foldr1 :: (a -> a -> a) -> URec Double a -> a

foldl1 :: (a -> a -> a) -> URec Double a -> a

toList :: URec Double a -> [a]

null :: URec Double a -> Bool

length :: URec Double a -> Int

elem :: Eq a => a -> URec Double a -> Bool

maximum :: Ord a => URec Double a -> a

minimum :: Ord a => URec Double a -> a

sum :: Num a => URec Double a -> a

product :: Num a => URec Double a -> a

Traversable (URec Double)

Methods

traverse :: Applicative f => (a -> f b) -> URec Double a -> f (URec Double b)

sequenceA :: Applicative f => URec Double (f a) -> f (URec Double a)

mapM :: Monad m => (a -> m b) -> URec Double a -> m (URec Double b)

sequence :: Monad m => URec Double (m a) -> m (URec Double a)

Generic1 (URec Double)

Associated Types

type Rep1 (URec Double :: * -> *) :: * -> *

Methods

from1 :: URec Double a -> Rep1 (URec Double) a

to1 :: Rep1 (URec Double) a -> URec Double a

Eq (URec Double p)

Methods

(==) :: URec Double p -> URec Double p -> Bool

(/=) :: URec Double p -> URec Double p -> Bool

Ord (URec Double p)

Methods

compare :: URec Double p -> URec Double p -> Ordering

(<) :: URec Double p -> URec Double p -> Bool

(<=) :: URec Double p -> URec Double p -> Bool

(>) :: URec Double p -> URec Double p -> Bool

(>=) :: URec Double p -> URec Double p -> Bool

max :: URec Double p -> URec Double p -> URec Double p

min :: URec Double p -> URec Double p -> URec Double p

Show (URec Double p)

Methods

showsPrec :: Int -> URec Double p -> ShowS

show :: URec Double p -> String

showList :: [URec Double p] -> ShowS

Generic (URec Double p)

Associated Types

type Rep (URec Double p) :: * -> *

Methods

from :: URec Double p -> Rep (URec Double p) x

to :: Rep (URec Double p) x -> URec Double p

data URec Double

Used for marking occurrences of Double#

data URec Double = UDouble {

• uDouble# :: Double#

}

type Rep1 (URec Double)

type Rep1 (URec Double) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UDouble" PrefixI True) (S1 (MetaSel (Just Symbol "uDouble#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UDouble))

type Rep (URec Double p)

type Rep (URec Double p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UDouble" PrefixI True) (S1 (MetaSel (Just Symbol "uDouble#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UDouble))

data Float :: *

Single-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE single-precision type.

Instances

Eq Float

Methods

(==) :: Float -> Float -> Bool

(/=) :: Float -> Float -> Bool

Floating Float

Methods

pi :: Float

exp :: Float -> Float

log :: Float -> Float

sqrt :: Float -> Float

(**) :: Float -> Float -> Float

logBase :: Float -> Float -> Float

sin :: Float -> Float

cos :: Float -> Float

tan :: Float -> Float

asin :: Float -> Float

acos :: Float -> Float

atan :: Float -> Float

sinh :: Float -> Float

cosh :: Float -> Float

tanh :: Float -> Float

asinh :: Float -> Float

acosh :: Float -> Float

atanh :: Float -> Float

log1p :: Float -> Float

expm1 :: Float -> Float

log1pexp :: Float -> Float

log1mexp :: Float -> Float

Ord Float

Methods

compare :: Float -> Float -> Ordering

(<) :: Float -> Float -> Bool

(<=) :: Float -> Float -> Bool

(>) :: Float -> Float -> Bool

(>=) :: Float -> Float -> Bool

max :: Float -> Float -> Float

min :: Float -> Float -> Float

RealFloat Float

Methods

floatRadix :: Float -> Integer

floatDigits :: Float -> Int

floatRange :: Float -> (Int, Int)

decodeFloat :: Float -> (Integer, Int)

encodeFloat :: Integer -> Int -> Float

exponent :: Float -> Int

significand :: Float -> Float

scaleFloat :: Int -> Float -> Float

isNaN :: Float -> Bool

isInfinite :: Float -> Bool

isDenormalized :: Float -> Bool

isNegativeZero :: Float -> Bool

isIEEE :: Float -> Bool

atan2 :: Float -> Float -> Float

Storable Float

Methods

sizeOf :: Float -> Int

alignment :: Float -> Int

peekElemOff :: Ptr Float -> Int -> IO Float

pokeElemOff :: Ptr Float -> Int -> Float -> IO ()

peekByteOff :: Ptr b -> Int -> IO Float

pokeByteOff :: Ptr b -> Int -> Float -> IO ()

peek :: Ptr Float -> IO Float

poke :: Ptr Float -> Float -> IO ()

Variant Float

Methods

inVariant :: ArgIn Float

inVarList :: ArgIn [Float]

inVarIUnknown :: ArgIn (IUnknown Float)

vtEltType :: Float -> VARENUM

resVariant :: ArgRes Float

defaultVariant :: Float

resVarList :: ArgRes [Float]

resVarIUnknown :: ArgRes (IUnknown Float)

resVarIDispatch :: ArgRes (IDispatch Float)

Functor (URec Float)

Methods

fmap :: (a -> b) -> URec Float a -> URec Float b

(<$) :: a -> URec Float b -> URec Float a

Foldable (URec Float)

Methods

fold :: Monoid m => URec Float m -> m

foldMap :: Monoid m => (a -> m) -> URec Float a -> m

foldr :: (a -> b -> b) -> b -> URec Float a -> b

foldr' :: (a -> b -> b) -> b -> URec Float a -> b

foldl :: (b -> a -> b) -> b -> URec Float a -> b

foldl' :: (b -> a -> b) -> b -> URec Float a -> b

foldr1 :: (a -> a -> a) -> URec Float a -> a

foldl1 :: (a -> a -> a) -> URec Float a -> a

toList :: URec Float a -> [a]

null :: URec Float a -> Bool

length :: URec Float a -> Int

elem :: Eq a => a -> URec Float a -> Bool

maximum :: Ord a => URec Float a -> a

minimum :: Ord a => URec Float a -> a

sum :: Num a => URec Float a -> a

product :: Num a => URec Float a -> a

Traversable (URec Float)

Methods

traverse :: Applicative f => (a -> f b) -> URec Float a -> f (URec Float b)

sequenceA :: Applicative f => URec Float (f a) -> f (URec Float a)

mapM :: Monad m => (a -> m b) -> URec Float a -> m (URec Float b)

sequence :: Monad m => URec Float (m a) -> m (URec Float a)

Generic1 (URec Float)

Associated Types

type Rep1 (URec Float :: * -> *) :: * -> *

Methods

from1 :: URec Float a -> Rep1 (URec Float) a

to1 :: Rep1 (URec Float) a -> URec Float a

Eq (URec Float p)

Methods

(==) :: URec Float p -> URec Float p -> Bool

(/=) :: URec Float p -> URec Float p -> Bool

Ord (URec Float p)

Methods

compare :: URec Float p -> URec Float p -> Ordering

(<) :: URec Float p -> URec Float p -> Bool

(<=) :: URec Float p -> URec Float p -> Bool

(>) :: URec Float p -> URec Float p -> Bool

(>=) :: URec Float p -> URec Float p -> Bool

max :: URec Float p -> URec Float p -> URec Float p

min :: URec Float p -> URec Float p -> URec Float p

Show (URec Float p)

Methods

showsPrec :: Int -> URec Float p -> ShowS

show :: URec Float p -> String

showList :: [URec Float p] -> ShowS

Generic (URec Float p)

Associated Types

type Rep (URec Float p) :: * -> *

Methods

from :: URec Float p -> Rep (URec Float p) x

to :: Rep (URec Float p) x -> URec Float p

data URec Float

Used for marking occurrences of Float#

data URec Float = UFloat {

• uFloat# :: Float#

}

type Rep1 (URec Float)

type Rep1 (URec Float) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UFloat" PrefixI True) (S1 (MetaSel (Just Symbol "uFloat#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UFloat))

type Rep (URec Float p)

type Rep (URec Float p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UFloat" PrefixI True) (S1 (MetaSel (Just Symbol "uFloat#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UFloat))

data Bool :: *

Instances

Bounded Bool

Methods

minBound :: Bool

maxBound :: Bool

Enum Bool

Methods

succ :: Bool -> Bool

pred :: Bool -> Bool

toEnum :: Int -> Bool

fromEnum :: Bool -> Int

enumFrom :: Bool -> [Bool]

enumFromThen :: Bool -> Bool -> [Bool]

enumFromTo :: Bool -> Bool -> [Bool]

enumFromThenTo :: Bool -> Bool -> Bool -> [Bool]

Eq Bool

Methods

(==) :: Bool -> Bool -> Bool

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

Ord Bool

Methods

compare :: Bool -> Bool -> Ordering

(<) :: Bool -> Bool -> Bool

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

(>) :: Bool -> Bool -> Bool

(>=) :: Bool -> Bool -> Bool

max :: Bool -> Bool -> Bool

min :: Bool -> Bool -> Bool

Show Bool

Methods

showsPrec :: Int -> Bool -> ShowS

show :: Bool -> String

showList :: [Bool] -> ShowS

Generic Bool

Associated Types

type Rep Bool :: * -> *

Methods

from :: Bool -> Rep Bool x

to :: Rep Bool x -> Bool

Storable Bool

Methods

sizeOf :: Bool -> Int

alignment :: Bool -> Int

peekElemOff :: Ptr Bool -> Int -> IO Bool

pokeElemOff :: Ptr Bool -> Int -> Bool -> IO ()

peekByteOff :: Ptr b -> Int -> IO Bool

pokeByteOff :: Ptr b -> Int -> Bool -> IO ()

peek :: Ptr Bool -> IO Bool

poke :: Ptr Bool -> Bool -> IO ()

Bits Bool

Methods

(.&.) :: Bool -> Bool -> Bool

(.|.) :: Bool -> Bool -> Bool

xor :: Bool -> Bool -> Bool

complement :: Bool -> Bool

shift :: Bool -> Int -> Bool

rotate :: Bool -> Int -> Bool

zeroBits :: Bool

bit :: Int -> Bool

setBit :: Bool -> Int -> Bool

clearBit :: Bool -> Int -> Bool

complementBit :: Bool -> Int -> Bool

testBit :: Bool -> Int -> Bool

bitSizeMaybe :: Bool -> Maybe Int

bitSize :: Bool -> Int

isSigned :: Bool -> Bool

shiftL :: Bool -> Int -> Bool

unsafeShiftL :: Bool -> Int -> Bool

shiftR :: Bool -> Int -> Bool

unsafeShiftR :: Bool -> Int -> Bool

rotateL :: Bool -> Int -> Bool

rotateR :: Bool -> Int -> Bool

popCount :: Bool -> Int

FiniteBits Bool

Methods

finiteBitSize :: Bool -> Int

countLeadingZeros :: Bool -> Int

countTrailingZeros :: Bool -> Int

Variant Bool

Methods

inVariant :: ArgIn Bool

inVarList :: ArgIn [Bool]

inVarIUnknown :: ArgIn (IUnknown Bool)

vtEltType :: Bool -> VARENUM

resVariant :: ArgRes Bool

defaultVariant :: Bool

resVarList :: ArgRes [Bool]

resVarIUnknown :: ArgRes (IUnknown Bool)

resVarIDispatch :: ArgRes (IDispatch Bool)

SingI Bool False

Methods

sing :: Sing False a

SingI Bool True

Methods

sing :: Sing True a

SingKind Bool (KProxy Bool)

Associated Types

type DemoteRep (KProxy Bool) (kparam :: KProxy (KProxy Bool)) :: *

Methods

fromSing :: Sing (KProxy Bool) a -> DemoteRep (KProxy Bool) kparam

type Rep Bool

type Rep Bool = D1 (MetaData "Bool" "GHC.Types" "ghc-prim" False) ((:+:) (C1 (MetaCons "False" PrefixI False) U1) (C1 (MetaCons "True" PrefixI False) U1))

data Sing Bool

data Sing Bool where

• STrue :: Sing Bool True
• SFalse :: Sing Bool False

type (==) Bool a b

type (==) Bool a b = EqBool a b

type DemoteRep Bool (KProxy Bool)

type DemoteRep Bool (KProxy Bool) = Bool

data Ptr a :: * -> *

A value of type Ptr a represents a pointer to an object, or an array of objects, which may be marshalled to or from Haskell values of type a.

The type a will often be an instance of class Storable which provides the marshalling operations. However this is not essential, and you can provide your own operations to access the pointer. For example you might write small foreign functions to get or set the fields of a C struct.

Instances

Eq (Ptr a)

Methods

(==) :: Ptr a -> Ptr a -> Bool

(/=) :: Ptr a -> Ptr a -> Bool

Functor (URec (Ptr ()))

Methods

fmap :: (a -> b) -> URec (Ptr ()) a -> URec (Ptr ()) b

(<$) :: a -> URec (Ptr ()) b -> URec (Ptr ()) a

Ord (Ptr a)

Methods

compare :: Ptr a -> Ptr a -> Ordering

(<) :: Ptr a -> Ptr a -> Bool

(<=) :: Ptr a -> Ptr a -> Bool

(>) :: Ptr a -> Ptr a -> Bool

(>=) :: Ptr a -> Ptr a -> Bool

max :: Ptr a -> Ptr a -> Ptr a

min :: Ptr a -> Ptr a -> Ptr a

Show (Ptr a)

Methods

showsPrec :: Int -> Ptr a -> ShowS

show :: Ptr a -> String

showList :: [Ptr a] -> ShowS

Foldable (URec (Ptr ()))

Methods

fold :: Monoid m => URec (Ptr ()) m -> m

foldMap :: Monoid m => (a -> m) -> URec (Ptr ()) a -> m

foldr :: (a -> b -> b) -> b -> URec (Ptr ()) a -> b

foldr' :: (a -> b -> b) -> b -> URec (Ptr ()) a -> b

foldl :: (b -> a -> b) -> b -> URec (Ptr ()) a -> b

foldl' :: (b -> a -> b) -> b -> URec (Ptr ()) a -> b

foldr1 :: (a -> a -> a) -> URec (Ptr ()) a -> a

foldl1 :: (a -> a -> a) -> URec (Ptr ()) a -> a

toList :: URec (Ptr ()) a -> [a]

null :: URec (Ptr ()) a -> Bool

length :: URec (Ptr ()) a -> Int

elem :: Eq a => a -> URec (Ptr ()) a -> Bool

maximum :: Ord a => URec (Ptr ()) a -> a

minimum :: Ord a => URec (Ptr ()) a -> a

sum :: Num a => URec (Ptr ()) a -> a

product :: Num a => URec (Ptr ()) a -> a

Traversable (URec (Ptr ()))

Methods

traverse :: Applicative f => (a -> f b) -> URec (Ptr ()) a -> f (URec (Ptr ()) b)

sequenceA :: Applicative f => URec (Ptr ()) (f a) -> f (URec (Ptr ()) a)

mapM :: Monad m => (a -> m b) -> URec (Ptr ()) a -> m (URec (Ptr ()) b)

sequence :: Monad m => URec (Ptr ()) (m a) -> m (URec (Ptr ()) a)

Generic1 (URec (Ptr ()))

Associated Types

type Rep1 (URec (Ptr ()) :: * -> *) :: * -> *

Methods

from1 :: URec (Ptr ()) a -> Rep1 (URec (Ptr ())) a

to1 :: Rep1 (URec (Ptr ())) a -> URec (Ptr ()) a

Storable (Ptr a)

Methods

sizeOf :: Ptr a -> Int

alignment :: Ptr a -> Int

peekElemOff :: Ptr (Ptr a) -> Int -> IO (Ptr a)

pokeElemOff :: Ptr (Ptr a) -> Int -> Ptr a -> IO ()

peekByteOff :: Ptr b -> Int -> IO (Ptr a)

pokeByteOff :: Ptr b -> Int -> Ptr a -> IO ()

peek :: Ptr (Ptr a) -> IO (Ptr a)

poke :: Ptr (Ptr a) -> Ptr a -> IO ()

Variant (Ptr a)

Methods

inVariant :: ArgIn (Ptr a)

inVarList :: ArgIn [Ptr a]

inVarIUnknown :: ArgIn (IUnknown (Ptr a))

vtEltType :: Ptr a -> VARENUM

resVariant :: ArgRes (Ptr a)

defaultVariant :: Ptr a

resVarList :: ArgRes [Ptr a]

resVarIUnknown :: ArgRes (IUnknown (Ptr a))

resVarIDispatch :: ArgRes (IDispatch (Ptr a))

Eq (URec (Ptr ()) p)

Methods

(==) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool

(/=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool

Ord (URec (Ptr ()) p)

Methods

compare :: URec (Ptr ()) p -> URec (Ptr ()) p -> Ordering

(<) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool

(<=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool

(>) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool

(>=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool

max :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p

min :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p

Generic (URec (Ptr ()) p)

Associated Types

type Rep (URec (Ptr ()) p) :: * -> *

Methods

from :: URec (Ptr ()) p -> Rep (URec (Ptr ()) p) x

to :: Rep (URec (Ptr ()) p) x -> URec (Ptr ()) p

type Rep1 (URec (Ptr ()))

type Rep1 (URec (Ptr ())) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UAddr" PrefixI True) (S1 (MetaSel (Just Symbol "uAddr#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UAddr))

data URec (Ptr ())

Used for marking occurrences of Addr#

data URec (Ptr ()) = UAddr {

• uAddr# :: Addr#

}

type Rep (URec (Ptr ()) p)

type Rep (URec (Ptr ()) p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UAddr" PrefixI True) (S1 (MetaSel (Just Symbol "uAddr#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UAddr))

data StablePtr a :: * -> *

A stable pointer is a reference to a Haskell expression that is guaranteed not to be affected by garbage collection, i.e., it will neither be deallocated nor will the value of the stable pointer itself change during garbage collection (ordinary references may be relocated during garbage collection). Consequently, stable pointers can be passed to foreign code, which can treat it as an opaque reference to a Haskell value.

A value of type StablePtr a is a stable pointer to a Haskell expression of type a.

Instances

Eq (StablePtr a)

Methods

(==) :: StablePtr a -> StablePtr a -> Bool

(/=) :: StablePtr a -> StablePtr a -> Bool

Storable (StablePtr a)

Methods

sizeOf :: StablePtr a -> Int

alignment :: StablePtr a -> Int

peekElemOff :: Ptr (StablePtr a) -> Int -> IO (StablePtr a)

pokeElemOff :: Ptr (StablePtr a) -> Int -> StablePtr a -> IO ()

peekByteOff :: Ptr b -> Int -> IO (StablePtr a)

pokeByteOff :: Ptr b -> Int -> StablePtr a -> IO ()

peek :: Ptr (StablePtr a) -> IO (StablePtr a)

poke :: Ptr (StablePtr a) -> StablePtr a -> IO ()

deRefStablePtr :: StablePtr a -> IO a

Obtain the Haskell value referenced by a stable pointer, i.e., the same value that was passed to the corresponding call to makeStablePtr. If the argument to deRefStablePtr has already been freed using freeStablePtr, the behaviour of deRefStablePtr is undefined.