base-compat
Safe HaskellTrustworthy
LanguageHaskell2010

Foreign.Compat

Documentation

bitDefault :: (Bits a, Num a) => Int -> a #

popCountDefault :: (Bits a, Num a) => a -> Int #

testBitDefault :: (Bits a, Num a) => a -> Int -> Bool #

toIntegralSized :: (Integral a, Integral b, Bits a, Bits b) => a -> Maybe b #

(!<<.) :: Bits a => a -> Int -> a #

(!>>.) :: Bits a => a -> Int -> a #

(.<<.) :: Bits a => a -> Int -> a #

(.>>.) :: Bits a => a -> Int -> a #

(.^.) :: Bits a => a -> a -> a #

oneBits :: FiniteBits a => a #

mallocForeignPtrArray :: Storable a => Int -> IO (ForeignPtr a) #

mallocForeignPtrArray0 :: Storable a => Int -> IO (ForeignPtr a) #

newForeignPtr :: FinalizerPtr a -> Ptr a -> IO (ForeignPtr a) #

newForeignPtrEnv :: FinalizerEnvPtr env a -> Ptr env -> Ptr a -> IO (ForeignPtr a) #

alloca :: Storable a => (Ptr a -> IO b) -> IO b #

allocaBytes :: Int -> (Ptr a -> IO b) -> IO b #

allocaBytesAligned :: Int -> Int -> (Ptr a -> IO b) -> IO b #

calloc :: Storable a => IO (Ptr a) #

callocBytes :: Int -> IO (Ptr a) #

finalizerFree :: FinalizerPtr a #

free :: Ptr a -> IO () #

malloc :: Storable a => IO (Ptr a) #

mallocBytes :: Int -> IO (Ptr a) #

realloc :: forall a b. Storable b => Ptr a -> IO (Ptr b) #

reallocBytes :: Ptr a -> Int -> IO (Ptr a) #

advancePtr :: Storable a => Ptr a -> Int -> Ptr a #

allocaArray :: Storable a => Int -> (Ptr a -> IO b) -> IO b #

allocaArray0 :: Storable a => Int -> (Ptr a -> IO b) -> IO b #

callocArray :: Storable a => Int -> IO (Ptr a) #

callocArray0 :: Storable a => Int -> IO (Ptr a) #

copyArray :: Storable a => Ptr a -> Ptr a -> Int -> IO () #

lengthArray0 :: (Storable a, Eq a) => a -> Ptr a -> IO Int #

mallocArray :: Storable a => Int -> IO (Ptr a) #

mallocArray0 :: Storable a => Int -> IO (Ptr a) #

moveArray :: Storable a => Ptr a -> Ptr a -> Int -> IO () #

newArray :: Storable a => [a] -> IO (Ptr a) #

newArray0 :: Storable a => a -> [a] -> IO (Ptr a) #

peekArray :: Storable a => Int -> Ptr a -> IO [a] #

peekArray0 :: (Storable a, Eq a) => a -> Ptr a -> IO [a] #

pokeArray :: Storable a => Ptr a -> [a] -> IO () #

pokeArray0 :: Storable a => a -> Ptr a -> [a] -> IO () #

reallocArray :: Storable a => Ptr a -> Int -> IO (Ptr a) #

reallocArray0 :: Storable a => Ptr a -> Int -> IO (Ptr a) #

withArray :: Storable a => [a] -> (Ptr a -> IO b) -> IO b #

withArray0 :: Storable a => a -> [a] -> (Ptr a -> IO b) -> IO b #

withArrayLen :: Storable a => [a] -> (Int -> Ptr a -> IO b) -> IO b #

withArrayLen0 :: Storable a => a -> [a] -> (Int -> Ptr a -> IO b) -> IO b #

throwIf :: (a -> Bool) -> (a -> String) -> IO a -> IO a #

throwIfNeg :: (Ord a, Num a) => (a -> String) -> IO a -> IO a #

throwIfNeg_ :: (Ord a, Num a) => (a -> String) -> IO a -> IO () #

throwIfNull :: String -> IO (Ptr a) -> IO (Ptr a) #

throwIf_ :: (a -> Bool) -> (a -> String) -> IO a -> IO () #

void :: IO a -> IO () #

freePool :: Pool -> IO () #

newPool :: IO Pool #

pooledMalloc :: Storable a => Pool -> IO (Ptr a) #

pooledMallocArray :: Storable a => Pool -> Int -> IO (Ptr a) #

pooledMallocArray0 :: Storable a => Pool -> Int -> IO (Ptr a) #

pooledMallocBytes :: Pool -> Int -> IO (Ptr a) #

pooledNew :: Storable a => Pool -> a -> IO (Ptr a) #

pooledNewArray :: Storable a => Pool -> [a] -> IO (Ptr a) #

pooledNewArray0 :: Storable a => Pool -> a -> [a] -> IO (Ptr a) #

pooledRealloc :: Storable a => Pool -> Ptr a -> IO (Ptr a) #

pooledReallocArray :: Storable a => Pool -> Ptr a -> Int -> IO (Ptr a) #

pooledReallocArray0 :: Storable a => Pool -> Ptr a -> Int -> IO (Ptr a) #

pooledReallocBytes :: Pool -> Ptr a -> Int -> IO (Ptr a) #

withPool :: (Pool -> IO b) -> IO b #

copyBytes :: Ptr a -> Ptr a -> Int -> IO () #

fillBytes :: Ptr a -> Word8 -> Int -> IO () #

fromBool :: Num a => Bool -> a #

maybeNew :: (a -> IO (Ptr b)) -> Maybe a -> IO (Ptr b) #

maybePeek :: (Ptr a -> IO b) -> Ptr a -> IO (Maybe b) #

maybeWith :: (a -> (Ptr b -> IO c) -> IO c) -> Maybe a -> (Ptr b -> IO c) -> IO c #

moveBytes :: Ptr a -> Ptr a -> Int -> IO () #

new :: Storable a => a -> IO (Ptr a) #

toBool :: (Eq a, Num a) => a -> Bool #

with :: Storable a => a -> (Ptr a -> IO b) -> IO b #

withMany :: (a -> (b -> res) -> res) -> [a] -> ([b] -> res) -> res #

freeHaskellFunPtr :: FunPtr a -> IO () #

intPtrToPtr :: IntPtr -> Ptr a #

ptrToIntPtr :: Ptr a -> IntPtr #

ptrToWordPtr :: Ptr a -> WordPtr #

wordPtrToPtr :: WordPtr -> Ptr a #

addForeignPtrFinalizer :: FinalizerPtr a -> ForeignPtr a -> IO () #

addForeignPtrFinalizerEnv :: FinalizerEnvPtr env a -> Ptr env -> ForeignPtr a -> IO () #

castForeignPtr :: ForeignPtr a -> ForeignPtr b #

finalizeForeignPtr :: ForeignPtr a -> IO () #

mallocForeignPtr :: Storable a => IO (ForeignPtr a) #

mallocForeignPtrBytes :: Int -> IO (ForeignPtr a) #

newForeignPtr_ :: Ptr a -> IO (ForeignPtr a) #

plusForeignPtr :: ForeignPtr a -> Int -> ForeignPtr b #

touchForeignPtr :: ForeignPtr a -> IO () #

withForeignPtr :: ForeignPtr a -> (Ptr a -> IO b) -> IO b #

alignPtr :: Ptr a -> Int -> Ptr a #

castFunPtr :: FunPtr a -> FunPtr b #

castFunPtrToPtr :: FunPtr a -> Ptr b #

castPtr :: Ptr a -> Ptr b #

castPtrToFunPtr :: Ptr a -> FunPtr b #

minusPtr :: Ptr a -> Ptr b -> Int #

nullFunPtr :: FunPtr a #

nullPtr :: Ptr a #

plusPtr :: Ptr a -> Int -> Ptr b #

castPtrToStablePtr :: Ptr () -> StablePtr a #

castStablePtrToPtr :: StablePtr a -> Ptr () #

deRefStablePtr :: StablePtr a -> IO a #

freeStablePtr :: StablePtr a -> IO () #

newStablePtr :: a -> IO (StablePtr a) #

bitReverse16 :: Word16 -> Word16 #

bitReverse32 :: Word32 -> Word32 #

bitReverse64 :: Word64 -> Word64 #

bitReverse8 :: Word8 -> Word8 #

byteSwap16 :: Word16 -> Word16 #

byteSwap32 :: Word32 -> Word32 #

byteSwap64 :: Word64 -> Word64 #

class Eq a => Bits a where #

Minimal complete definition

(.&.), (.|.), xor, complement, (shift | shiftL, shiftR), (rotate | rotateL, rotateR), bitSize, bitSizeMaybe, isSigned, testBit, bit, popCount

Methods

(.&.) :: a -> a -> a #

(.|.) :: a -> a -> a #

xor :: a -> a -> a #

complement :: a -> a #

shift :: a -> Int -> a #

rotate :: a -> Int -> a #

zeroBits :: a #

bit :: Int -> a #

setBit :: a -> Int -> a #

clearBit :: a -> Int -> a #

complementBit :: a -> Int -> a #

testBit :: a -> Int -> Bool #

bitSizeMaybe :: a -> Maybe Int #

bitSize :: a -> Int #

isSigned :: a -> Bool #

shiftL :: a -> Int -> a #

unsafeShiftL :: a -> Int -> a #

shiftR :: a -> Int -> a #

unsafeShiftR :: a -> Int -> a #

rotateL :: a -> Int -> a #

rotateR :: a -> Int -> a #

popCount :: a -> Int #

Instances

Instances details
Bits CBool # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 #

Bits CChar # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 #

Bits CInt # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 #

Bits CIntMax # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 #

Bits CIntPtr # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 #

Bits CLLong # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 #

Bits CLong # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 #

Bits CPtrdiff # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 #

Bits CSChar # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 #

Bits CShort # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 #

Bits CSigAtomic # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 #

Bits CSize # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 #

Bits CUChar # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 #

Bits CUInt # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 #

Bits CUIntMax # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 #

Bits CUIntPtr # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 #

Bits CULLong # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 #

Bits CULong # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 #

Bits CUShort # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 #

Bits CWchar # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 #

Bits IntPtr # 
Instance details

Defined in GHC.Internal.Foreign.Ptr

Methods

(.&.) :: IntPtr -> IntPtr -> IntPtr #

(.|.) :: IntPtr -> IntPtr -> IntPtr #

xor :: IntPtr -> IntPtr -> IntPtr #

complement :: IntPtr -> IntPtr #

shift :: IntPtr -> Int -> IntPtr #

rotate :: IntPtr -> Int -> IntPtr #

zeroBits :: IntPtr #

bit :: Int -> IntPtr #

setBit :: IntPtr -> Int -> IntPtr #

clearBit :: IntPtr -> Int -> IntPtr #

complementBit :: IntPtr -> Int -> IntPtr #

testBit :: IntPtr -> Int -> Bool #

bitSizeMaybe :: IntPtr -> Maybe Int #

bitSize :: IntPtr -> Int #

isSigned :: IntPtr -> Bool #

shiftL :: IntPtr -> Int -> IntPtr #

unsafeShiftL :: IntPtr -> Int -> IntPtr #

shiftR :: IntPtr -> Int -> IntPtr #

unsafeShiftR :: IntPtr -> Int -> IntPtr #

rotateL :: IntPtr -> Int -> IntPtr #

rotateR :: IntPtr -> Int -> IntPtr #

popCount :: IntPtr -> Int #

Bits WordPtr # 
Instance details

Defined in GHC.Internal.Foreign.Ptr

Methods

(.&.) :: WordPtr -> WordPtr -> WordPtr #

(.|.) :: WordPtr -> WordPtr -> WordPtr #

xor :: WordPtr -> WordPtr -> WordPtr #

complement :: WordPtr -> WordPtr #

shift :: WordPtr -> Int -> WordPtr #

rotate :: WordPtr -> Int -> WordPtr #

zeroBits :: WordPtr #

bit :: Int -> WordPtr #

setBit :: WordPtr -> Int -> WordPtr #

clearBit :: WordPtr -> Int -> WordPtr #

complementBit :: WordPtr -> Int -> WordPtr #

testBit :: WordPtr -> Int -> Bool #

bitSizeMaybe :: WordPtr -> Maybe Int #

bitSize :: WordPtr -> Int #

isSigned :: WordPtr -> Bool #

shiftL :: WordPtr -> Int -> WordPtr #

unsafeShiftL :: WordPtr -> Int -> WordPtr #

shiftR :: WordPtr -> Int -> WordPtr #

unsafeShiftR :: WordPtr -> Int -> WordPtr #

rotateL :: WordPtr -> Int -> WordPtr #

rotateR :: WordPtr -> Int -> WordPtr #

popCount :: WordPtr -> Int #

Bits Int16 # 
Instance details

Defined in GHC.Internal.Int

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 #

Bits Int32 # 
Instance details

Defined in GHC.Internal.Int

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 #

Bits Int64 # 
Instance details

Defined in GHC.Internal.Int

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 #

Bits Int8 # 
Instance details

Defined in GHC.Internal.Int

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 #

Bits CBlkCnt # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

(.&.) :: CBlkCnt -> CBlkCnt -> CBlkCnt #

(.|.) :: CBlkCnt -> CBlkCnt -> CBlkCnt #

xor :: CBlkCnt -> CBlkCnt -> CBlkCnt #

complement :: CBlkCnt -> CBlkCnt #

shift :: CBlkCnt -> Int -> CBlkCnt #

rotate :: CBlkCnt -> Int -> CBlkCnt #

zeroBits :: CBlkCnt #

bit :: Int -> CBlkCnt #

setBit :: CBlkCnt -> Int -> CBlkCnt #

clearBit :: CBlkCnt -> Int -> CBlkCnt #

complementBit :: CBlkCnt -> Int -> CBlkCnt #

testBit :: CBlkCnt -> Int -> Bool #

bitSizeMaybe :: CBlkCnt -> Maybe Int #

bitSize :: CBlkCnt -> Int #

isSigned :: CBlkCnt -> Bool #

shiftL :: CBlkCnt -> Int -> CBlkCnt #

unsafeShiftL :: CBlkCnt -> Int -> CBlkCnt #

shiftR :: CBlkCnt -> Int -> CBlkCnt #

unsafeShiftR :: CBlkCnt -> Int -> CBlkCnt #

rotateL :: CBlkCnt -> Int -> CBlkCnt #

rotateR :: CBlkCnt -> Int -> CBlkCnt #

popCount :: CBlkCnt -> Int #

Bits CBlkSize # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

(.&.) :: CBlkSize -> CBlkSize -> CBlkSize #

(.|.) :: CBlkSize -> CBlkSize -> CBlkSize #

xor :: CBlkSize -> CBlkSize -> CBlkSize #

complement :: CBlkSize -> CBlkSize #

shift :: CBlkSize -> Int -> CBlkSize #

rotate :: CBlkSize -> Int -> CBlkSize #

zeroBits :: CBlkSize #

bit :: Int -> CBlkSize #

setBit :: CBlkSize -> Int -> CBlkSize #

clearBit :: CBlkSize -> Int -> CBlkSize #

complementBit :: CBlkSize -> Int -> CBlkSize #

testBit :: CBlkSize -> Int -> Bool #

bitSizeMaybe :: CBlkSize -> Maybe Int #

bitSize :: CBlkSize -> Int #

isSigned :: CBlkSize -> Bool #

shiftL :: CBlkSize -> Int -> CBlkSize #

unsafeShiftL :: CBlkSize -> Int -> CBlkSize #

shiftR :: CBlkSize -> Int -> CBlkSize #

unsafeShiftR :: CBlkSize -> Int -> CBlkSize #

rotateL :: CBlkSize -> Int -> CBlkSize #

rotateR :: CBlkSize -> Int -> CBlkSize #

popCount :: CBlkSize -> Int #

Bits CClockId # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

(.&.) :: CClockId -> CClockId -> CClockId #

(.|.) :: CClockId -> CClockId -> CClockId #

xor :: CClockId -> CClockId -> CClockId #

complement :: CClockId -> CClockId #

shift :: CClockId -> Int -> CClockId #

rotate :: CClockId -> Int -> CClockId #

zeroBits :: CClockId #

bit :: Int -> CClockId #

setBit :: CClockId -> Int -> CClockId #

clearBit :: CClockId -> Int -> CClockId #

complementBit :: CClockId -> Int -> CClockId #

testBit :: CClockId -> Int -> Bool #

bitSizeMaybe :: CClockId -> Maybe Int #

bitSize :: CClockId -> Int #

isSigned :: CClockId -> Bool #

shiftL :: CClockId -> Int -> CClockId #

unsafeShiftL :: CClockId -> Int -> CClockId #

shiftR :: CClockId -> Int -> CClockId #

unsafeShiftR :: CClockId -> Int -> CClockId #

rotateL :: CClockId -> Int -> CClockId #

rotateR :: CClockId -> Int -> CClockId #

popCount :: CClockId -> Int #

Bits CDev # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

(.&.) :: CDev -> CDev -> CDev #

(.|.) :: CDev -> CDev -> CDev #

xor :: CDev -> CDev -> CDev #

complement :: CDev -> CDev #

shift :: CDev -> Int -> CDev #

rotate :: CDev -> Int -> CDev #

zeroBits :: CDev #

bit :: Int -> CDev #

setBit :: CDev -> Int -> CDev #

clearBit :: CDev -> Int -> CDev #

complementBit :: CDev -> Int -> CDev #

testBit :: CDev -> Int -> Bool #

bitSizeMaybe :: CDev -> Maybe Int #

bitSize :: CDev -> Int #

isSigned :: CDev -> Bool #

shiftL :: CDev -> Int -> CDev #

unsafeShiftL :: CDev -> Int -> CDev #

shiftR :: CDev -> Int -> CDev #

unsafeShiftR :: CDev -> Int -> CDev #

rotateL :: CDev -> Int -> CDev #

rotateR :: CDev -> Int -> CDev #

popCount :: CDev -> Int #

Bits CFsBlkCnt # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

(.&.) :: CFsBlkCnt -> CFsBlkCnt -> CFsBlkCnt #

(.|.) :: CFsBlkCnt -> CFsBlkCnt -> CFsBlkCnt #

xor :: CFsBlkCnt -> CFsBlkCnt -> CFsBlkCnt #

complement :: CFsBlkCnt -> CFsBlkCnt #

shift :: CFsBlkCnt -> Int -> CFsBlkCnt #

rotate :: CFsBlkCnt -> Int -> CFsBlkCnt #

zeroBits :: CFsBlkCnt #

bit :: Int -> CFsBlkCnt #

setBit :: CFsBlkCnt -> Int -> CFsBlkCnt #

clearBit :: CFsBlkCnt -> Int -> CFsBlkCnt #

complementBit :: CFsBlkCnt -> Int -> CFsBlkCnt #

testBit :: CFsBlkCnt -> Int -> Bool #

bitSizeMaybe :: CFsBlkCnt -> Maybe Int #

bitSize :: CFsBlkCnt -> Int #

isSigned :: CFsBlkCnt -> Bool #

shiftL :: CFsBlkCnt -> Int -> CFsBlkCnt #

unsafeShiftL :: CFsBlkCnt -> Int -> CFsBlkCnt #

shiftR :: CFsBlkCnt -> Int -> CFsBlkCnt #

unsafeShiftR :: CFsBlkCnt -> Int -> CFsBlkCnt #

rotateL :: CFsBlkCnt -> Int -> CFsBlkCnt #

rotateR :: CFsBlkCnt -> Int -> CFsBlkCnt #

popCount :: CFsBlkCnt -> Int #

Bits CFsFilCnt # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

(.&.) :: CFsFilCnt -> CFsFilCnt -> CFsFilCnt #

(.|.) :: CFsFilCnt -> CFsFilCnt -> CFsFilCnt #

xor :: CFsFilCnt -> CFsFilCnt -> CFsFilCnt #

complement :: CFsFilCnt -> CFsFilCnt #

shift :: CFsFilCnt -> Int -> CFsFilCnt #

rotate :: CFsFilCnt -> Int -> CFsFilCnt #

zeroBits :: CFsFilCnt #

bit :: Int -> CFsFilCnt #

setBit :: CFsFilCnt -> Int -> CFsFilCnt #

clearBit :: CFsFilCnt -> Int -> CFsFilCnt #

complementBit :: CFsFilCnt -> Int -> CFsFilCnt #

testBit :: CFsFilCnt -> Int -> Bool #

bitSizeMaybe :: CFsFilCnt -> Maybe Int #

bitSize :: CFsFilCnt -> Int #

isSigned :: CFsFilCnt -> Bool #

shiftL :: CFsFilCnt -> Int -> CFsFilCnt #

unsafeShiftL :: CFsFilCnt -> Int -> CFsFilCnt #

shiftR :: CFsFilCnt -> Int -> CFsFilCnt #

unsafeShiftR :: CFsFilCnt -> Int -> CFsFilCnt #

rotateL :: CFsFilCnt -> Int -> CFsFilCnt #

rotateR :: CFsFilCnt -> Int -> CFsFilCnt #

popCount :: CFsFilCnt -> Int #

Bits CGid # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

(.&.) :: CGid -> CGid -> CGid #

(.|.) :: CGid -> CGid -> CGid #

xor :: CGid -> CGid -> CGid #

complement :: CGid -> CGid #

shift :: CGid -> Int -> CGid #

rotate :: CGid -> Int -> CGid #

zeroBits :: CGid #

bit :: Int -> CGid #

setBit :: CGid -> Int -> CGid #

clearBit :: CGid -> Int -> CGid #

complementBit :: CGid -> Int -> CGid #

testBit :: CGid -> Int -> Bool #

bitSizeMaybe :: CGid -> Maybe Int #

bitSize :: CGid -> Int #

isSigned :: CGid -> Bool #

shiftL :: CGid -> Int -> CGid #

unsafeShiftL :: CGid -> Int -> CGid #

shiftR :: CGid -> Int -> CGid #

unsafeShiftR :: CGid -> Int -> CGid #

rotateL :: CGid -> Int -> CGid #

rotateR :: CGid -> Int -> CGid #

popCount :: CGid -> Int #

Bits CId # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

(.&.) :: CId -> CId -> CId #

(.|.) :: CId -> CId -> CId #

xor :: CId -> CId -> CId #

complement :: CId -> CId #

shift :: CId -> Int -> CId #

rotate :: CId -> Int -> CId #

zeroBits :: CId #

bit :: Int -> CId #

setBit :: CId -> Int -> CId #

clearBit :: CId -> Int -> CId #

complementBit :: CId -> Int -> CId #

testBit :: CId -> Int -> Bool #

bitSizeMaybe :: CId -> Maybe Int #

bitSize :: CId -> Int #

isSigned :: CId -> Bool #

shiftL :: CId -> Int -> CId #

unsafeShiftL :: CId -> Int -> CId #

shiftR :: CId -> Int -> CId #

unsafeShiftR :: CId -> Int -> CId #

rotateL :: CId -> Int -> CId #

rotateR :: CId -> Int -> CId #

popCount :: CId -> Int #

Bits CIno # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

(.&.) :: CIno -> CIno -> CIno #

(.|.) :: CIno -> CIno -> CIno #

xor :: CIno -> CIno -> CIno #

complement :: CIno -> CIno #

shift :: CIno -> Int -> CIno #

rotate :: CIno -> Int -> CIno #

zeroBits :: CIno #

bit :: Int -> CIno #

setBit :: CIno -> Int -> CIno #

clearBit :: CIno -> Int -> CIno #

complementBit :: CIno -> Int -> CIno #

testBit :: CIno -> Int -> Bool #

bitSizeMaybe :: CIno -> Maybe Int #

bitSize :: CIno -> Int #

isSigned :: CIno -> Bool #

shiftL :: CIno -> Int -> CIno #

unsafeShiftL :: CIno -> Int -> CIno #

shiftR :: CIno -> Int -> CIno #

unsafeShiftR :: CIno -> Int -> CIno #

rotateL :: CIno -> Int -> CIno #

rotateR :: CIno -> Int -> CIno #

popCount :: CIno -> Int #

Bits CKey # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

(.&.) :: CKey -> CKey -> CKey #

(.|.) :: CKey -> CKey -> CKey #

xor :: CKey -> CKey -> CKey #

complement :: CKey -> CKey #

shift :: CKey -> Int -> CKey #

rotate :: CKey -> Int -> CKey #

zeroBits :: CKey #

bit :: Int -> CKey #

setBit :: CKey -> Int -> CKey #

clearBit :: CKey -> Int -> CKey #

complementBit :: CKey -> Int -> CKey #

testBit :: CKey -> Int -> Bool #

bitSizeMaybe :: CKey -> Maybe Int #

bitSize :: CKey -> Int #

isSigned :: CKey -> Bool #

shiftL :: CKey -> Int -> CKey #

unsafeShiftL :: CKey -> Int -> CKey #

shiftR :: CKey -> Int -> CKey #

unsafeShiftR :: CKey -> Int -> CKey #

rotateL :: CKey -> Int -> CKey #

rotateR :: CKey -> Int -> CKey #

popCount :: CKey -> Int #

Bits CMode # 
Instance details

Defined in GHC.Internal.System.Posix.Types

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 #

Bits CNfds # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

(.&.) :: CNfds -> CNfds -> CNfds #

(.|.) :: CNfds -> CNfds -> CNfds #

xor :: CNfds -> CNfds -> CNfds #

complement :: CNfds -> CNfds #

shift :: CNfds -> Int -> CNfds #

rotate :: CNfds -> Int -> CNfds #

zeroBits :: CNfds #

bit :: Int -> CNfds #

setBit :: CNfds -> Int -> CNfds #

clearBit :: CNfds -> Int -> CNfds #

complementBit :: CNfds -> Int -> CNfds #

testBit :: CNfds -> Int -> Bool #

bitSizeMaybe :: CNfds -> Maybe Int #

bitSize :: CNfds -> Int #

isSigned :: CNfds -> Bool #

shiftL :: CNfds -> Int -> CNfds #

unsafeShiftL :: CNfds -> Int -> CNfds #

shiftR :: CNfds -> Int -> CNfds #

unsafeShiftR :: CNfds -> Int -> CNfds #

rotateL :: CNfds -> Int -> CNfds #

rotateR :: CNfds -> Int -> CNfds #

popCount :: CNfds -> Int #

Bits CNlink # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

(.&.) :: CNlink -> CNlink -> CNlink #

(.|.) :: CNlink -> CNlink -> CNlink #

xor :: CNlink -> CNlink -> CNlink #

complement :: CNlink -> CNlink #

shift :: CNlink -> Int -> CNlink #

rotate :: CNlink -> Int -> CNlink #

zeroBits :: CNlink #

bit :: Int -> CNlink #

setBit :: CNlink -> Int -> CNlink #

clearBit :: CNlink -> Int -> CNlink #

complementBit :: CNlink -> Int -> CNlink #

testBit :: CNlink -> Int -> Bool #

bitSizeMaybe :: CNlink -> Maybe Int #

bitSize :: CNlink -> Int #

isSigned :: CNlink -> Bool #

shiftL :: CNlink -> Int -> CNlink #

unsafeShiftL :: CNlink -> Int -> CNlink #

shiftR :: CNlink -> Int -> CNlink #

unsafeShiftR :: CNlink -> Int -> CNlink #

rotateL :: CNlink -> Int -> CNlink #

rotateR :: CNlink -> Int -> CNlink #

popCount :: CNlink -> Int #

Bits COff # 
Instance details

Defined in GHC.Internal.System.Posix.Types

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 #

Bits CPid # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

(.&.) :: CPid -> CPid -> CPid #

(.|.) :: CPid -> CPid -> CPid #

xor :: CPid -> CPid -> CPid #

complement :: CPid -> CPid #

shift :: CPid -> Int -> CPid #

rotate :: CPid -> Int -> CPid #

zeroBits :: CPid #

bit :: Int -> CPid #

setBit :: CPid -> Int -> CPid #

clearBit :: CPid -> Int -> CPid #

complementBit :: CPid -> Int -> CPid #

testBit :: CPid -> Int -> Bool #

bitSizeMaybe :: CPid -> Maybe Int #

bitSize :: CPid -> Int #

isSigned :: CPid -> Bool #

shiftL :: CPid -> Int -> CPid #

unsafeShiftL :: CPid -> Int -> CPid #

shiftR :: CPid -> Int -> CPid #

unsafeShiftR :: CPid -> Int -> CPid #

rotateL :: CPid -> Int -> CPid #

rotateR :: CPid -> Int -> CPid #

popCount :: CPid -> Int #

Bits CRLim # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

(.&.) :: CRLim -> CRLim -> CRLim #

(.|.) :: CRLim -> CRLim -> CRLim #

xor :: CRLim -> CRLim -> CRLim #

complement :: CRLim -> CRLim #

shift :: CRLim -> Int -> CRLim #

rotate :: CRLim -> Int -> CRLim #

zeroBits :: CRLim #

bit :: Int -> CRLim #

setBit :: CRLim -> Int -> CRLim #

clearBit :: CRLim -> Int -> CRLim #

complementBit :: CRLim -> Int -> CRLim #

testBit :: CRLim -> Int -> Bool #

bitSizeMaybe :: CRLim -> Maybe Int #

bitSize :: CRLim -> Int #

isSigned :: CRLim -> Bool #

shiftL :: CRLim -> Int -> CRLim #

unsafeShiftL :: CRLim -> Int -> CRLim #

shiftR :: CRLim -> Int -> CRLim #

unsafeShiftR :: CRLim -> Int -> CRLim #

rotateL :: CRLim -> Int -> CRLim #

rotateR :: CRLim -> Int -> CRLim #

popCount :: CRLim -> Int #

Bits CSocklen # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

(.&.) :: CSocklen -> CSocklen -> CSocklen #

(.|.) :: CSocklen -> CSocklen -> CSocklen #

xor :: CSocklen -> CSocklen -> CSocklen #

complement :: CSocklen -> CSocklen #

shift :: CSocklen -> Int -> CSocklen #

rotate :: CSocklen -> Int -> CSocklen #

zeroBits :: CSocklen #

bit :: Int -> CSocklen #

setBit :: CSocklen -> Int -> CSocklen #

clearBit :: CSocklen -> Int -> CSocklen #

complementBit :: CSocklen -> Int -> CSocklen #

testBit :: CSocklen -> Int -> Bool #

bitSizeMaybe :: CSocklen -> Maybe Int #

bitSize :: CSocklen -> Int #

isSigned :: CSocklen -> Bool #

shiftL :: CSocklen -> Int -> CSocklen #

unsafeShiftL :: CSocklen -> Int -> CSocklen #

shiftR :: CSocklen -> Int -> CSocklen #

unsafeShiftR :: CSocklen -> Int -> CSocklen #

rotateL :: CSocklen -> Int -> CSocklen #

rotateR :: CSocklen -> Int -> CSocklen #

popCount :: CSocklen -> Int #

Bits CSsize # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

(.&.) :: CSsize -> CSsize -> CSsize #

(.|.) :: CSsize -> CSsize -> CSsize #

xor :: CSsize -> CSsize -> CSsize #

complement :: CSsize -> CSsize #

shift :: CSsize -> Int -> CSsize #

rotate :: CSsize -> Int -> CSsize #

zeroBits :: CSsize #

bit :: Int -> CSsize #

setBit :: CSsize -> Int -> CSsize #

clearBit :: CSsize -> Int -> CSsize #

complementBit :: CSsize -> Int -> CSsize #

testBit :: CSsize -> Int -> Bool #

bitSizeMaybe :: CSsize -> Maybe Int #

bitSize :: CSsize -> Int #

isSigned :: CSsize -> Bool #

shiftL :: CSsize -> Int -> CSsize #

unsafeShiftL :: CSsize -> Int -> CSsize #

shiftR :: CSsize -> Int -> CSsize #

unsafeShiftR :: CSsize -> Int -> CSsize #

rotateL :: CSsize -> Int -> CSsize #

rotateR :: CSsize -> Int -> CSsize #

popCount :: CSsize -> Int #

Bits CTcflag # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

(.&.) :: CTcflag -> CTcflag -> CTcflag #

(.|.) :: CTcflag -> CTcflag -> CTcflag #

xor :: CTcflag -> CTcflag -> CTcflag #

complement :: CTcflag -> CTcflag #

shift :: CTcflag -> Int -> CTcflag #

rotate :: CTcflag -> Int -> CTcflag #

zeroBits :: CTcflag #

bit :: Int -> CTcflag #

setBit :: CTcflag -> Int -> CTcflag #

clearBit :: CTcflag -> Int -> CTcflag #

complementBit :: CTcflag -> Int -> CTcflag #

testBit :: CTcflag -> Int -> Bool #

bitSizeMaybe :: CTcflag -> Maybe Int #

bitSize :: CTcflag -> Int #

isSigned :: CTcflag -> Bool #

shiftL :: CTcflag -> Int -> CTcflag #

unsafeShiftL :: CTcflag -> Int -> CTcflag #

shiftR :: CTcflag -> Int -> CTcflag #

unsafeShiftR :: CTcflag -> Int -> CTcflag #

rotateL :: CTcflag -> Int -> CTcflag #

rotateR :: CTcflag -> Int -> CTcflag #

popCount :: CTcflag -> Int #

Bits CUid # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

(.&.) :: CUid -> CUid -> CUid #

(.|.) :: CUid -> CUid -> CUid #

xor :: CUid -> CUid -> CUid #

complement :: CUid -> CUid #

shift :: CUid -> Int -> CUid #

rotate :: CUid -> Int -> CUid #

zeroBits :: CUid #

bit :: Int -> CUid #

setBit :: CUid -> Int -> CUid #

clearBit :: CUid -> Int -> CUid #

complementBit :: CUid -> Int -> CUid #

testBit :: CUid -> Int -> Bool #

bitSizeMaybe :: CUid -> Maybe Int #

bitSize :: CUid -> Int #

isSigned :: CUid -> Bool #

shiftL :: CUid -> Int -> CUid #

unsafeShiftL :: CUid -> Int -> CUid #

shiftR :: CUid -> Int -> CUid #

unsafeShiftR :: CUid -> Int -> CUid #

rotateL :: CUid -> Int -> CUid #

rotateR :: CUid -> Int -> CUid #

popCount :: CUid -> Int #

Bits Fd # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

(.&.) :: Fd -> Fd -> Fd #

(.|.) :: Fd -> Fd -> Fd #

xor :: Fd -> Fd -> Fd #

complement :: Fd -> Fd #

shift :: Fd -> Int -> Fd #

rotate :: Fd -> Int -> Fd #

zeroBits :: Fd #

bit :: Int -> Fd #

setBit :: Fd -> Int -> Fd #

clearBit :: Fd -> Int -> Fd #

complementBit :: Fd -> Int -> Fd #

testBit :: Fd -> Int -> Bool #

bitSizeMaybe :: Fd -> Maybe Int #

bitSize :: Fd -> Int #

isSigned :: Fd -> Bool #

shiftL :: Fd -> Int -> Fd #

unsafeShiftL :: Fd -> Int -> Fd #

shiftR :: Fd -> Int -> Fd #

unsafeShiftR :: Fd -> Int -> Fd #

rotateL :: Fd -> Int -> Fd #

rotateR :: Fd -> Int -> Fd #

popCount :: Fd -> Int #

Bits Word16 # 
Instance details

Defined in GHC.Internal.Word

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 #

Bits Word32 # 
Instance details

Defined in GHC.Internal.Word

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 #

Bits Word64 # 
Instance details

Defined in GHC.Internal.Word

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 #

Bits Word8 # 
Instance details

Defined in GHC.Internal.Word

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 #

Bits Integer # 
Instance details

Defined in GHC.Internal.Bits

Methods

(.&.) :: Integer -> Integer -> Integer #

(.|.) :: Integer -> Integer -> Integer #

xor :: Integer -> Integer -> Integer #

complement :: Integer -> Integer #

shift :: Integer -> Int -> Integer #

rotate :: Integer -> Int -> Integer #

zeroBits :: Integer #

bit :: Int -> Integer #

setBit :: Integer -> Int -> Integer #

clearBit :: Integer -> Int -> Integer #

complementBit :: Integer -> Int -> Integer #

testBit :: Integer -> Int -> Bool #

bitSizeMaybe :: Integer -> Maybe Int #

bitSize :: Integer -> Int #

isSigned :: Integer -> Bool #

shiftL :: Integer -> Int -> Integer #

unsafeShiftL :: Integer -> Int -> Integer #

shiftR :: Integer -> Int -> Integer #

unsafeShiftR :: Integer -> Int -> Integer #

rotateL :: Integer -> Int -> Integer #

rotateR :: Integer -> Int -> Integer #

popCount :: Integer -> Int #

Bits Natural # 
Instance details

Defined in GHC.Internal.Bits

Methods

(.&.) :: Natural -> Natural -> Natural #

(.|.) :: Natural -> Natural -> Natural #

xor :: Natural -> Natural -> Natural #

complement :: Natural -> Natural #

shift :: Natural -> Int -> Natural #

rotate :: Natural -> Int -> Natural #

zeroBits :: Natural #

bit :: Int -> Natural #

setBit :: Natural -> Int -> Natural #

clearBit :: Natural -> Int -> Natural #

complementBit :: Natural -> Int -> Natural #

testBit :: Natural -> Int -> Bool #

bitSizeMaybe :: Natural -> Maybe Int #

bitSize :: Natural -> Int #

isSigned :: Natural -> Bool #

shiftL :: Natural -> Int -> Natural #

unsafeShiftL :: Natural -> Int -> Natural #

shiftR :: Natural -> Int -> Natural #

unsafeShiftR :: Natural -> Int -> Natural #

rotateL :: Natural -> Int -> Natural #

rotateR :: Natural -> Int -> Natural #

popCount :: Natural -> Int #

Bits Bool # 
Instance details

Defined in GHC.Internal.Bits

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 #

Bits Int # 
Instance details

Defined in GHC.Internal.Bits

Methods

(.&.) :: Int -> Int -> Int #

(.|.) :: Int -> Int -> Int #

xor :: Int -> Int -> Int #

complement :: Int -> Int #

shift :: Int -> Int -> Int #

rotate :: Int -> Int -> Int #

zeroBits :: Int #

bit :: Int -> Int #

setBit :: Int -> Int -> Int #

clearBit :: Int -> Int -> Int #

complementBit :: Int -> Int -> Int #

testBit :: Int -> Int -> Bool #

bitSizeMaybe :: Int -> Maybe Int #

bitSize :: Int -> Int #

isSigned :: Int -> Bool #

shiftL :: Int -> Int -> Int #

unsafeShiftL :: Int -> Int -> Int #

shiftR :: Int -> Int -> Int #

unsafeShiftR :: Int -> Int -> Int #

rotateL :: Int -> Int -> Int #

rotateR :: Int -> Int -> Int #

popCount :: Int -> Int #

Bits Word # 
Instance details

Defined in GHC.Internal.Bits

Methods

(.&.) :: Word -> Word -> Word #

(.|.) :: Word -> Word -> Word #

xor :: Word -> Word -> Word #

complement :: Word -> Word #

shift :: Word -> Int -> Word #

rotate :: Word -> Int -> Word #

zeroBits :: Word #

bit :: Int -> Word #

setBit :: Word -> Int -> Word #

clearBit :: Word -> Int -> Word #

complementBit :: Word -> Int -> Word #

testBit :: Word -> Int -> Bool #

bitSizeMaybe :: Word -> Maybe Int #

bitSize :: Word -> Int #

isSigned :: Word -> Bool #

shiftL :: Word -> Int -> Word #

unsafeShiftL :: Word -> Int -> Word #

shiftR :: Word -> Int -> Word #

unsafeShiftR :: Word -> Int -> Word #

rotateL :: Word -> Int -> Word #

rotateR :: Word -> Int -> Word #

popCount :: Word -> Int #

Bits a => Bits (And a) # 
Instance details

Defined in GHC.Internal.Data.Bits

Methods

(.&.) :: And a -> And a -> And a #

(.|.) :: And a -> And a -> And a #

xor :: And a -> And a -> And a #

complement :: And a -> And a #

shift :: And a -> Int -> And a #

rotate :: And a -> Int -> And a #

zeroBits :: And a #

bit :: Int -> And a #

setBit :: And a -> Int -> And a #

clearBit :: And a -> Int -> And a #

complementBit :: And a -> Int -> And a #

testBit :: And a -> Int -> Bool #

bitSizeMaybe :: And a -> Maybe Int #

bitSize :: And a -> Int #

isSigned :: And a -> Bool #

shiftL :: And a -> Int -> And a #

unsafeShiftL :: And a -> Int -> And a #

shiftR :: And a -> Int -> And a #

unsafeShiftR :: And a -> Int -> And a #

rotateL :: And a -> Int -> And a #

rotateR :: And a -> Int -> And a #

popCount :: And a -> Int #

Bits a => Bits (Iff a) # 
Instance details

Defined in GHC.Internal.Data.Bits

Methods

(.&.) :: Iff a -> Iff a -> Iff a #

(.|.) :: Iff a -> Iff a -> Iff a #

xor :: Iff a -> Iff a -> Iff a #

complement :: Iff a -> Iff a #

shift :: Iff a -> Int -> Iff a #

rotate :: Iff a -> Int -> Iff a #

zeroBits :: Iff a #

bit :: Int -> Iff a #

setBit :: Iff a -> Int -> Iff a #

clearBit :: Iff a -> Int -> Iff a #

complementBit :: Iff a -> Int -> Iff a #

testBit :: Iff a -> Int -> Bool #

bitSizeMaybe :: Iff a -> Maybe Int #

bitSize :: Iff a -> Int #

isSigned :: Iff a -> Bool #

shiftL :: Iff a -> Int -> Iff a #

unsafeShiftL :: Iff a -> Int -> Iff a #

shiftR :: Iff a -> Int -> Iff a #

unsafeShiftR :: Iff a -> Int -> Iff a #

rotateL :: Iff a -> Int -> Iff a #

rotateR :: Iff a -> Int -> Iff a #

popCount :: Iff a -> Int #

Bits a => Bits (Ior a) # 
Instance details

Defined in GHC.Internal.Data.Bits

Methods

(.&.) :: Ior a -> Ior a -> Ior a #

(.|.) :: Ior a -> Ior a -> Ior a #

xor :: Ior a -> Ior a -> Ior a #

complement :: Ior a -> Ior a #

shift :: Ior a -> Int -> Ior a #

rotate :: Ior a -> Int -> Ior a #

zeroBits :: Ior a #

bit :: Int -> Ior a #

setBit :: Ior a -> Int -> Ior a #

clearBit :: Ior a -> Int -> Ior a #

complementBit :: Ior a -> Int -> Ior a #

testBit :: Ior a -> Int -> Bool #

bitSizeMaybe :: Ior a -> Maybe Int #

bitSize :: Ior a -> Int #

isSigned :: Ior a -> Bool #

shiftL :: Ior a -> Int -> Ior a #

unsafeShiftL :: Ior a -> Int -> Ior a #

shiftR :: Ior a -> Int -> Ior a #

unsafeShiftR :: Ior a -> Int -> Ior a #

rotateL :: Ior a -> Int -> Ior a #

rotateR :: Ior a -> Int -> Ior a #

popCount :: Ior a -> Int #

Bits a => Bits (Xor a) # 
Instance details

Defined in GHC.Internal.Data.Bits

Methods

(.&.) :: Xor a -> Xor a -> Xor a #

(.|.) :: Xor a -> Xor a -> Xor a #

xor :: Xor a -> Xor a -> Xor a #

complement :: Xor a -> Xor a #

shift :: Xor a -> Int -> Xor a #

rotate :: Xor a -> Int -> Xor a #

zeroBits :: Xor a #

bit :: Int -> Xor a #

setBit :: Xor a -> Int -> Xor a #

clearBit :: Xor a -> Int -> Xor a #

complementBit :: Xor a -> Int -> Xor a #

testBit :: Xor a -> Int -> Bool #

bitSizeMaybe :: Xor a -> Maybe Int #

bitSize :: Xor a -> Int #

isSigned :: Xor a -> Bool #

shiftL :: Xor a -> Int -> Xor a #

unsafeShiftL :: Xor a -> Int -> Xor a #

shiftR :: Xor a -> Int -> Xor a #

unsafeShiftR :: Xor a -> Int -> Xor a #

rotateL :: Xor a -> Int -> Xor a #

rotateR :: Xor a -> Int -> Xor a #

popCount :: Xor a -> Int #

Bits a => Bits (Identity a) # 
Instance details

Defined in GHC.Internal.Data.Functor.Identity

Methods

(.&.) :: Identity a -> Identity a -> Identity a #

(.|.) :: Identity a -> Identity a -> Identity a #

xor :: Identity a -> Identity a -> Identity a #

complement :: Identity a -> Identity a #

shift :: Identity a -> Int -> Identity a #

rotate :: Identity a -> Int -> Identity a #

zeroBits :: Identity a #

bit :: Int -> Identity a #

setBit :: Identity a -> Int -> Identity a #

clearBit :: Identity a -> Int -> Identity a #

complementBit :: Identity a -> Int -> Identity a #

testBit :: Identity a -> Int -> Bool #

bitSizeMaybe :: Identity a -> Maybe Int #

bitSize :: Identity a -> Int #

isSigned :: Identity a -> Bool #

shiftL :: Identity a -> Int -> Identity a #

unsafeShiftL :: Identity a -> Int -> Identity a #

shiftR :: Identity a -> Int -> Identity a #

unsafeShiftR :: Identity a -> Int -> Identity a #

rotateL :: Identity a -> Int -> Identity a #

rotateR :: Identity a -> Int -> Identity a #

popCount :: Identity a -> Int #

Bits a => Bits (Const a b) # 
Instance details

Defined in GHC.Internal.Data.Functor.Const

Methods

(.&.) :: Const a b -> Const a b -> Const a b #

(.|.) :: Const a b -> Const a b -> Const a b #

xor :: Const a b -> Const a b -> Const a b #

complement :: Const a b -> Const a b #

shift :: Const a b -> Int -> Const a b #

rotate :: Const a b -> Int -> Const a b #

zeroBits :: Const a b #

bit :: Int -> Const a b #

setBit :: Const a b -> Int -> Const a b #

clearBit :: Const a b -> Int -> Const a b #

complementBit :: Const a b -> Int -> Const a b #

testBit :: Const a b -> Int -> Bool #

bitSizeMaybe :: Const a b -> Maybe Int #

bitSize :: Const a b -> Int #

isSigned :: Const a b -> Bool #

shiftL :: Const a b -> Int -> Const a b #

unsafeShiftL :: Const a b -> Int -> Const a b #

shiftR :: Const a b -> Int -> Const a b #

unsafeShiftR :: Const a b -> Int -> Const a b #

rotateL :: Const a b -> Int -> Const a b #

rotateR :: Const a b -> Int -> Const a b #

popCount :: Const a b -> Int #

class Bits b => FiniteBits b where #

Minimal complete definition

finiteBitSize

Methods

finiteBitSize :: b -> Int #

countLeadingZeros :: b -> Int #

countTrailingZeros :: b -> Int #

Instances

Instances details
FiniteBits CBool # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

finiteBitSize :: CBool -> Int #

countLeadingZeros :: CBool -> Int #

countTrailingZeros :: CBool -> Int #

FiniteBits CChar # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

finiteBitSize :: CChar -> Int #

countLeadingZeros :: CChar -> Int #

countTrailingZeros :: CChar -> Int #

FiniteBits CInt # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

finiteBitSize :: CInt -> Int #

countLeadingZeros :: CInt -> Int #

countTrailingZeros :: CInt -> Int #

FiniteBits CIntMax # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

finiteBitSize :: CIntMax -> Int #

countLeadingZeros :: CIntMax -> Int #

countTrailingZeros :: CIntMax -> Int #

FiniteBits CIntPtr # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

finiteBitSize :: CIntPtr -> Int #

countLeadingZeros :: CIntPtr -> Int #

countTrailingZeros :: CIntPtr -> Int #

FiniteBits CLLong # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

finiteBitSize :: CLLong -> Int #

countLeadingZeros :: CLLong -> Int #

countTrailingZeros :: CLLong -> Int #

FiniteBits CLong # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

finiteBitSize :: CLong -> Int #

countLeadingZeros :: CLong -> Int #

countTrailingZeros :: CLong -> Int #

FiniteBits CPtrdiff # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

finiteBitSize :: CPtrdiff -> Int #

countLeadingZeros :: CPtrdiff -> Int #

countTrailingZeros :: CPtrdiff -> Int #

FiniteBits CSChar # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

finiteBitSize :: CSChar -> Int #

countLeadingZeros :: CSChar -> Int #

countTrailingZeros :: CSChar -> Int #

FiniteBits CShort # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

finiteBitSize :: CShort -> Int #

countLeadingZeros :: CShort -> Int #

countTrailingZeros :: CShort -> Int #

FiniteBits CSigAtomic # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

finiteBitSize :: CSigAtomic -> Int #

countLeadingZeros :: CSigAtomic -> Int #

countTrailingZeros :: CSigAtomic -> Int #

FiniteBits CSize # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

finiteBitSize :: CSize -> Int #

countLeadingZeros :: CSize -> Int #

countTrailingZeros :: CSize -> Int #

FiniteBits CUChar # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

finiteBitSize :: CUChar -> Int #

countLeadingZeros :: CUChar -> Int #

countTrailingZeros :: CUChar -> Int #

FiniteBits CUInt # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

finiteBitSize :: CUInt -> Int #

countLeadingZeros :: CUInt -> Int #

countTrailingZeros :: CUInt -> Int #

FiniteBits CUIntMax # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

finiteBitSize :: CUIntMax -> Int #

countLeadingZeros :: CUIntMax -> Int #

countTrailingZeros :: CUIntMax -> Int #

FiniteBits CUIntPtr # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

finiteBitSize :: CUIntPtr -> Int #

countLeadingZeros :: CUIntPtr -> Int #

countTrailingZeros :: CUIntPtr -> Int #

FiniteBits CULLong # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

finiteBitSize :: CULLong -> Int #

countLeadingZeros :: CULLong -> Int #

countTrailingZeros :: CULLong -> Int #

FiniteBits CULong # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

finiteBitSize :: CULong -> Int #

countLeadingZeros :: CULong -> Int #

countTrailingZeros :: CULong -> Int #

FiniteBits CUShort # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

finiteBitSize :: CUShort -> Int #

countLeadingZeros :: CUShort -> Int #

countTrailingZeros :: CUShort -> Int #

FiniteBits CWchar # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

Methods

finiteBitSize :: CWchar -> Int #

countLeadingZeros :: CWchar -> Int #

countTrailingZeros :: CWchar -> Int #

FiniteBits IntPtr # 
Instance details

Defined in GHC.Internal.Foreign.Ptr

Methods

finiteBitSize :: IntPtr -> Int #

countLeadingZeros :: IntPtr -> Int #

countTrailingZeros :: IntPtr -> Int #

FiniteBits WordPtr # 
Instance details

Defined in GHC.Internal.Foreign.Ptr

Methods

finiteBitSize :: WordPtr -> Int #

countLeadingZeros :: WordPtr -> Int #

countTrailingZeros :: WordPtr -> Int #

FiniteBits Int16 # 
Instance details

Defined in GHC.Internal.Int

Methods

finiteBitSize :: Int16 -> Int #

countLeadingZeros :: Int16 -> Int #

countTrailingZeros :: Int16 -> Int #

FiniteBits Int32 # 
Instance details

Defined in GHC.Internal.Int

Methods

finiteBitSize :: Int32 -> Int #

countLeadingZeros :: Int32 -> Int #

countTrailingZeros :: Int32 -> Int #

FiniteBits Int64 # 
Instance details

Defined in GHC.Internal.Int

Methods

finiteBitSize :: Int64 -> Int #

countLeadingZeros :: Int64 -> Int #

countTrailingZeros :: Int64 -> Int #

FiniteBits Int8 # 
Instance details

Defined in GHC.Internal.Int

Methods

finiteBitSize :: Int8 -> Int #

countLeadingZeros :: Int8 -> Int #

countTrailingZeros :: Int8 -> Int #

FiniteBits CBlkCnt # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

finiteBitSize :: CBlkCnt -> Int #

countLeadingZeros :: CBlkCnt -> Int #

countTrailingZeros :: CBlkCnt -> Int #

FiniteBits CBlkSize # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

finiteBitSize :: CBlkSize -> Int #

countLeadingZeros :: CBlkSize -> Int #

countTrailingZeros :: CBlkSize -> Int #

FiniteBits CClockId # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

finiteBitSize :: CClockId -> Int #

countLeadingZeros :: CClockId -> Int #

countTrailingZeros :: CClockId -> Int #

FiniteBits CDev # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

finiteBitSize :: CDev -> Int #

countLeadingZeros :: CDev -> Int #

countTrailingZeros :: CDev -> Int #

FiniteBits CFsBlkCnt # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

finiteBitSize :: CFsBlkCnt -> Int #

countLeadingZeros :: CFsBlkCnt -> Int #

countTrailingZeros :: CFsBlkCnt -> Int #

FiniteBits CFsFilCnt # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

finiteBitSize :: CFsFilCnt -> Int #

countLeadingZeros :: CFsFilCnt -> Int #

countTrailingZeros :: CFsFilCnt -> Int #

FiniteBits CGid # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

finiteBitSize :: CGid -> Int #

countLeadingZeros :: CGid -> Int #

countTrailingZeros :: CGid -> Int #

FiniteBits CId # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

finiteBitSize :: CId -> Int #

countLeadingZeros :: CId -> Int #

countTrailingZeros :: CId -> Int #

FiniteBits CIno # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

finiteBitSize :: CIno -> Int #

countLeadingZeros :: CIno -> Int #

countTrailingZeros :: CIno -> Int #

FiniteBits CKey # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

finiteBitSize :: CKey -> Int #

countLeadingZeros :: CKey -> Int #

countTrailingZeros :: CKey -> Int #

FiniteBits CMode # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

finiteBitSize :: CMode -> Int #

countLeadingZeros :: CMode -> Int #

countTrailingZeros :: CMode -> Int #

FiniteBits CNfds # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

finiteBitSize :: CNfds -> Int #

countLeadingZeros :: CNfds -> Int #

countTrailingZeros :: CNfds -> Int #

FiniteBits CNlink # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

finiteBitSize :: CNlink -> Int #

countLeadingZeros :: CNlink -> Int #

countTrailingZeros :: CNlink -> Int #

FiniteBits COff # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

finiteBitSize :: COff -> Int #

countLeadingZeros :: COff -> Int #

countTrailingZeros :: COff -> Int #

FiniteBits CPid # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

finiteBitSize :: CPid -> Int #

countLeadingZeros :: CPid -> Int #

countTrailingZeros :: CPid -> Int #

FiniteBits CRLim # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

finiteBitSize :: CRLim -> Int #

countLeadingZeros :: CRLim -> Int #

countTrailingZeros :: CRLim -> Int #

FiniteBits CSocklen # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

finiteBitSize :: CSocklen -> Int #

countLeadingZeros :: CSocklen -> Int #

countTrailingZeros :: CSocklen -> Int #

FiniteBits CSsize # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

finiteBitSize :: CSsize -> Int #

countLeadingZeros :: CSsize -> Int #

countTrailingZeros :: CSsize -> Int #

FiniteBits CTcflag # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

finiteBitSize :: CTcflag -> Int #

countLeadingZeros :: CTcflag -> Int #

countTrailingZeros :: CTcflag -> Int #

FiniteBits CUid # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

finiteBitSize :: CUid -> Int #

countLeadingZeros :: CUid -> Int #

countTrailingZeros :: CUid -> Int #

FiniteBits Fd # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

finiteBitSize :: Fd -> Int #

countLeadingZeros :: Fd -> Int #

countTrailingZeros :: Fd -> Int #

FiniteBits Word16 # 
Instance details

Defined in GHC.Internal.Word

Methods

finiteBitSize :: Word16 -> Int #

countLeadingZeros :: Word16 -> Int #

countTrailingZeros :: Word16 -> Int #

FiniteBits Word32 # 
Instance details

Defined in GHC.Internal.Word

Methods

finiteBitSize :: Word32 -> Int #

countLeadingZeros :: Word32 -> Int #

countTrailingZeros :: Word32 -> Int #

FiniteBits Word64 # 
Instance details

Defined in GHC.Internal.Word

Methods

finiteBitSize :: Word64 -> Int #

countLeadingZeros :: Word64 -> Int #

countTrailingZeros :: Word64 -> Int #

FiniteBits Word8 # 
Instance details

Defined in GHC.Internal.Word

Methods

finiteBitSize :: Word8 -> Int #

countLeadingZeros :: Word8 -> Int #

countTrailingZeros :: Word8 -> Int #

FiniteBits Bool # 
Instance details

Defined in GHC.Internal.Bits

Methods

finiteBitSize :: Bool -> Int #

countLeadingZeros :: Bool -> Int #

countTrailingZeros :: Bool -> Int #

FiniteBits Int # 
Instance details

Defined in GHC.Internal.Bits

Methods

finiteBitSize :: Int -> Int #

countLeadingZeros :: Int -> Int #

countTrailingZeros :: Int -> Int #

FiniteBits Word # 
Instance details

Defined in GHC.Internal.Bits

Methods

finiteBitSize :: Word -> Int #

countLeadingZeros :: Word -> Int #

countTrailingZeros :: Word -> Int #

FiniteBits a => FiniteBits (And a) # 
Instance details

Defined in GHC.Internal.Data.Bits

Methods

finiteBitSize :: And a -> Int #

countLeadingZeros :: And a -> Int #

countTrailingZeros :: And a -> Int #

FiniteBits a => FiniteBits (Iff a) # 
Instance details

Defined in GHC.Internal.Data.Bits

Methods

finiteBitSize :: Iff a -> Int #

countLeadingZeros :: Iff a -> Int #

countTrailingZeros :: Iff a -> Int #

FiniteBits a => FiniteBits (Ior a) # 
Instance details

Defined in GHC.Internal.Data.Bits

Methods

finiteBitSize :: Ior a -> Int #

countLeadingZeros :: Ior a -> Int #

countTrailingZeros :: Ior a -> Int #

FiniteBits a => FiniteBits (Xor a) # 
Instance details

Defined in GHC.Internal.Data.Bits

Methods

finiteBitSize :: Xor a -> Int #

countLeadingZeros :: Xor a -> Int #

countTrailingZeros :: Xor a -> Int #

FiniteBits a => FiniteBits (Identity a) # 
Instance details

Defined in GHC.Internal.Data.Functor.Identity

Methods

finiteBitSize :: Identity a -> Int #

countLeadingZeros :: Identity a -> Int #

countTrailingZeros :: Identity a -> Int #

FiniteBits a => FiniteBits (Const a b) # 
Instance details

Defined in GHC.Internal.Data.Functor.Const

Methods

finiteBitSize :: Const a b -> Int #

countLeadingZeros :: Const a b -> Int #

countTrailingZeros :: Const a b -> Int #

newtype And a #

Constructors

And 

Fields

Instances

Instances details
FiniteBits a => Monoid (And a) # 
Instance details

Defined in GHC.Internal.Data.Bits

Methods

mempty :: And a #

mappend :: And a -> And a -> And a #

mconcat :: [And a] -> And a #

Bits a => Semigroup (And a) # 
Instance details

Defined in GHC.Internal.Data.Bits

Methods

(<>) :: And a -> And a -> And a #

sconcat :: NonEmpty (And a) -> And a #

stimes :: Integral b => b -> And a -> And a #

Bits a => Bits (And a) # 
Instance details

Defined in GHC.Internal.Data.Bits

Methods

(.&.) :: And a -> And a -> And a #

(.|.) :: And a -> And a -> And a #

xor :: And a -> And a -> And a #

complement :: And a -> And a #

shift :: And a -> Int -> And a #

rotate :: And a -> Int -> And a #

zeroBits :: And a #

bit :: Int -> And a #

setBit :: And a -> Int -> And a #

clearBit :: And a -> Int -> And a #

complementBit :: And a -> Int -> And a #

testBit :: And a -> Int -> Bool #

bitSizeMaybe :: And a -> Maybe Int #

bitSize :: And a -> Int #

isSigned :: And a -> Bool #

shiftL :: And a -> Int -> And a #

unsafeShiftL :: And a -> Int -> And a #

shiftR :: And a -> Int -> And a #

unsafeShiftR :: And a -> Int -> And a #

rotateL :: And a -> Int -> And a #

rotateR :: And a -> Int -> And a #

popCount :: And a -> Int #

FiniteBits a => FiniteBits (And a) # 
Instance details

Defined in GHC.Internal.Data.Bits

Methods

finiteBitSize :: And a -> Int #

countLeadingZeros :: And a -> Int #

countTrailingZeros :: And a -> Int #

Bounded a => Bounded (And a) # 
Instance details

Defined in GHC.Internal.Data.Bits

Methods

minBound :: And a #

maxBound :: And a #

Enum a => Enum (And a) # 
Instance details

Defined in GHC.Internal.Data.Bits

Methods

succ :: And a -> And a #

pred :: And a -> And a #

toEnum :: Int -> And a #

fromEnum :: And a -> Int #

enumFrom :: And a -> [And a] #

enumFromThen :: And a -> And a -> [And a] #

enumFromTo :: And a -> And a -> [And a] #

enumFromThenTo :: And a -> And a -> And a -> [And a] #

Read a => Read (And a) # 
Instance details

Defined in GHC.Internal.Data.Bits

Methods

readsPrec :: Int -> ReadS (And a) #

readList :: ReadS [And a] #

readPrec :: ReadPrec (And a) #

readListPrec :: ReadPrec [And a] #

Show a => Show (And a) # 
Instance details

Defined in GHC.Internal.Data.Bits

Methods

showsPrec :: Int -> And a -> ShowS #

show :: And a -> String #

showList :: [And a] -> ShowS #

Eq a => Eq (And a) # 
Instance details

Defined in GHC.Internal.Data.Bits

Methods

(==) :: And a -> And a -> Bool #

(/=) :: And a -> And a -> Bool #

newtype Iff a #

Constructors

Iff 

Fields

Instances

Instances details
FiniteBits a => Monoid (Iff a) # 
Instance details

Defined in GHC.Internal.Data.Bits

Methods

mempty :: Iff a #

mappend :: Iff a -> Iff a -> Iff a #

mconcat :: [Iff a] -> Iff a #

FiniteBits a => Semigroup (Iff a) # 
Instance details

Defined in GHC.Internal.Data.Bits

Methods

(<>) :: Iff a -> Iff a -> Iff a #

sconcat :: NonEmpty (Iff a) -> Iff a #

stimes :: Integral b => b -> Iff a -> Iff a #

Bits a => Bits (Iff a) # 
Instance details

Defined in GHC.Internal.Data.Bits

Methods

(.&.) :: Iff a -> Iff a -> Iff a #

(.|.) :: Iff a -> Iff a -> Iff a #

xor :: Iff a -> Iff a -> Iff a #

complement :: Iff a -> Iff a #

shift :: Iff a -> Int -> Iff a #

rotate :: Iff a -> Int -> Iff a #

zeroBits :: Iff a #

bit :: Int -> Iff a #

setBit :: Iff a -> Int -> Iff a #

clearBit :: Iff a -> Int -> Iff a #

complementBit :: Iff a -> Int -> Iff a #

testBit :: Iff a -> Int -> Bool #

bitSizeMaybe :: Iff a -> Maybe Int #

bitSize :: Iff a -> Int #

isSigned :: Iff a -> Bool #

shiftL :: Iff a -> Int -> Iff a #

unsafeShiftL :: Iff a -> Int -> Iff a #

shiftR :: Iff a -> Int -> Iff a #

unsafeShiftR :: Iff a -> Int -> Iff a #

rotateL :: Iff a -> Int -> Iff a #

rotateR :: Iff a -> Int -> Iff a #

popCount :: Iff a -> Int #

FiniteBits a => FiniteBits (Iff a) # 
Instance details

Defined in GHC.Internal.Data.Bits

Methods

finiteBitSize :: Iff a -> Int #

countLeadingZeros :: Iff a -> Int #

countTrailingZeros :: Iff a -> Int #

Bounded a => Bounded (Iff a) # 
Instance details

Defined in GHC.Internal.Data.Bits

Methods

minBound :: Iff a #

maxBound :: Iff a #

Enum a => Enum (Iff a) # 
Instance details

Defined in GHC.Internal.Data.Bits

Methods

succ :: Iff a -> Iff a #

pred :: Iff a -> Iff a #

toEnum :: Int -> Iff a #

fromEnum :: Iff a -> Int #

enumFrom :: Iff a -> [Iff a] #

enumFromThen :: Iff a -> Iff a -> [Iff a] #

enumFromTo :: Iff a -> Iff a -> [Iff a] #

enumFromThenTo :: Iff a -> Iff a -> Iff a -> [Iff a] #

Read a => Read (Iff a) # 
Instance details

Defined in GHC.Internal.Data.Bits

Methods

readsPrec :: Int -> ReadS (Iff a) #

readList :: ReadS [Iff a] #

readPrec :: ReadPrec (Iff a) #

readListPrec :: ReadPrec [Iff a] #

Show a => Show (Iff a) # 
Instance details

Defined in GHC.Internal.Data.Bits

Methods

showsPrec :: Int -> Iff a -> ShowS #

show :: Iff a -> String #

showList :: [Iff a] -> ShowS #

Eq a => Eq (Iff a) # 
Instance details

Defined in GHC.Internal.Data.Bits

Methods

(==) :: Iff a -> Iff a -> Bool #

(/=) :: Iff a -> Iff a -> Bool #

newtype Ior a #

Constructors

Ior 

Fields

Instances

Instances details
Bits a => Monoid (Ior a) # 
Instance details

Defined in GHC.Internal.Data.Bits

Methods

mempty :: Ior a #

mappend :: Ior a -> Ior a -> Ior a #

mconcat :: [Ior a] -> Ior a #

Bits a => Semigroup (Ior a) # 
Instance details

Defined in GHC.Internal.Data.Bits

Methods

(<>) :: Ior a -> Ior a -> Ior a #

sconcat :: NonEmpty (Ior a) -> Ior a #

stimes :: Integral b => b -> Ior a -> Ior a #

Bits a => Bits (Ior a) # 
Instance details

Defined in GHC.Internal.Data.Bits

Methods

(.&.) :: Ior a -> Ior a -> Ior a #

(.|.) :: Ior a -> Ior a -> Ior a #

xor :: Ior a -> Ior a -> Ior a #

complement :: Ior a -> Ior a #

shift :: Ior a -> Int -> Ior a #

rotate :: Ior a -> Int -> Ior a #

zeroBits :: Ior a #

bit :: Int -> Ior a #

setBit :: Ior a -> Int -> Ior a #

clearBit :: Ior a -> Int -> Ior a #

complementBit :: Ior a -> Int -> Ior a #

testBit :: Ior a -> Int -> Bool #

bitSizeMaybe :: Ior a -> Maybe Int #

bitSize :: Ior a -> Int #

isSigned :: Ior a -> Bool #

shiftL :: Ior a -> Int -> Ior a #

unsafeShiftL :: Ior a -> Int -> Ior a #

shiftR :: Ior a -> Int -> Ior a #

unsafeShiftR :: Ior a -> Int -> Ior a #

rotateL :: Ior a -> Int -> Ior a #

rotateR :: Ior a -> Int -> Ior a #

popCount :: Ior a -> Int #

FiniteBits a => FiniteBits (Ior a) # 
Instance details

Defined in GHC.Internal.Data.Bits

Methods

finiteBitSize :: Ior a -> Int #

countLeadingZeros :: Ior a -> Int #

countTrailingZeros :: Ior a -> Int #

Bounded a => Bounded (Ior a) # 
Instance details

Defined in GHC.Internal.Data.Bits

Methods

minBound :: Ior a #

maxBound :: Ior a #

Enum a => Enum (Ior a) # 
Instance details

Defined in GHC.Internal.Data.Bits

Methods

succ :: Ior a -> Ior a #

pred :: Ior a -> Ior a #

toEnum :: Int -> Ior a #

fromEnum :: Ior a -> Int #

enumFrom :: Ior a -> [Ior a] #

enumFromThen :: Ior a -> Ior a -> [Ior a] #

enumFromTo :: Ior a -> Ior a -> [Ior a] #

enumFromThenTo :: Ior a -> Ior a -> Ior a -> [Ior a] #

Read a => Read (Ior a) # 
Instance details

Defined in GHC.Internal.Data.Bits

Methods

readsPrec :: Int -> ReadS (Ior a) #

readList :: ReadS [Ior a] #

readPrec :: ReadPrec (Ior a) #

readListPrec :: ReadPrec [Ior a] #

Show a => Show (Ior a) # 
Instance details

Defined in GHC.Internal.Data.Bits

Methods

showsPrec :: Int -> Ior a -> ShowS #

show :: Ior a -> String #

showList :: [Ior a] -> ShowS #

Eq a => Eq (Ior a) # 
Instance details

Defined in GHC.Internal.Data.Bits

Methods

(==) :: Ior a -> Ior a -> Bool #

(/=) :: Ior a -> Ior a -> Bool #

newtype Xor a #

Constructors

Xor 

Fields

Instances

Instances details
Bits a => Monoid (Xor a) # 
Instance details

Defined in GHC.Internal.Data.Bits

Methods

mempty :: Xor a #

mappend :: Xor a -> Xor a -> Xor a #

mconcat :: [Xor a] -> Xor a #

Bits a => Semigroup (Xor a) # 
Instance details

Defined in GHC.Internal.Data.Bits

Methods

(<>) :: Xor a -> Xor a -> Xor a #

sconcat :: NonEmpty (Xor a) -> Xor a #

stimes :: Integral b => b -> Xor a -> Xor a #

Bits a => Bits (Xor a) # 
Instance details

Defined in GHC.Internal.Data.Bits

Methods

(.&.) :: Xor a -> Xor a -> Xor a #

(.|.) :: Xor a -> Xor a -> Xor a #

xor :: Xor a -> Xor a -> Xor a #

complement :: Xor a -> Xor a #

shift :: Xor a -> Int -> Xor a #

rotate :: Xor a -> Int -> Xor a #

zeroBits :: Xor a #

bit :: Int -> Xor a #

setBit :: Xor a -> Int -> Xor a #

clearBit :: Xor a -> Int -> Xor a #

complementBit :: Xor a -> Int -> Xor a #

testBit :: Xor a -> Int -> Bool #

bitSizeMaybe :: Xor a -> Maybe Int #

bitSize :: Xor a -> Int #

isSigned :: Xor a -> Bool #

shiftL :: Xor a -> Int -> Xor a #

unsafeShiftL :: Xor a -> Int -> Xor a #

shiftR :: Xor a -> Int -> Xor a #

unsafeShiftR :: Xor a -> Int -> Xor a #

rotateL :: Xor a -> Int -> Xor a #

rotateR :: Xor a -> Int -> Xor a #

popCount :: Xor a -> Int #

FiniteBits a => FiniteBits (Xor a) # 
Instance details

Defined in GHC.Internal.Data.Bits

Methods

finiteBitSize :: Xor a -> Int #

countLeadingZeros :: Xor a -> Int #

countTrailingZeros :: Xor a -> Int #

Bounded a => Bounded (Xor a) # 
Instance details

Defined in GHC.Internal.Data.Bits

Methods

minBound :: Xor a #

maxBound :: Xor a #

Enum a => Enum (Xor a) # 
Instance details

Defined in GHC.Internal.Data.Bits

Methods

succ :: Xor a -> Xor a #

pred :: Xor a -> Xor a #

toEnum :: Int -> Xor a #

fromEnum :: Xor a -> Int #

enumFrom :: Xor a -> [Xor a] #

enumFromThen :: Xor a -> Xor a -> [Xor a] #

enumFromTo :: Xor a -> Xor a -> [Xor a] #

enumFromThenTo :: Xor a -> Xor a -> Xor a -> [Xor a] #

Read a => Read (Xor a) # 
Instance details

Defined in GHC.Internal.Data.Bits

Methods

readsPrec :: Int -> ReadS (Xor a) #

readList :: ReadS [Xor a] #

readPrec :: ReadPrec (Xor a) #

readListPrec :: ReadPrec [Xor a] #

Show a => Show (Xor a) # 
Instance details

Defined in GHC.Internal.Data.Bits

Methods

showsPrec :: Int -> Xor a -> ShowS #

show :: Xor a -> String #

showList :: [Xor a] -> ShowS #

Eq a => Eq (Xor a) # 
Instance details

Defined in GHC.Internal.Data.Bits

Methods

(==) :: Xor a -> Xor a -> Bool #

(/=) :: Xor a -> Xor a -> Bool #

data Pool #

newtype IntPtr #

Constructors

IntPtr Int 

Instances

Instances details
Bits IntPtr # 
Instance details

Defined in GHC.Internal.Foreign.Ptr

Methods

(.&.) :: IntPtr -> IntPtr -> IntPtr #

(.|.) :: IntPtr -> IntPtr -> IntPtr #

xor :: IntPtr -> IntPtr -> IntPtr #

complement :: IntPtr -> IntPtr #

shift :: IntPtr -> Int -> IntPtr #

rotate :: IntPtr -> Int -> IntPtr #

zeroBits :: IntPtr #

bit :: Int -> IntPtr #

setBit :: IntPtr -> Int -> IntPtr #

clearBit :: IntPtr -> Int -> IntPtr #

complementBit :: IntPtr -> Int -> IntPtr #

testBit :: IntPtr -> Int -> Bool #

bitSizeMaybe :: IntPtr -> Maybe Int #

bitSize :: IntPtr -> Int #

isSigned :: IntPtr -> Bool #

shiftL :: IntPtr -> Int -> IntPtr #

unsafeShiftL :: IntPtr -> Int -> IntPtr #

shiftR :: IntPtr -> Int -> IntPtr #

unsafeShiftR :: IntPtr -> Int -> IntPtr #

rotateL :: IntPtr -> Int -> IntPtr #

rotateR :: IntPtr -> Int -> IntPtr #

popCount :: IntPtr -> Int #

FiniteBits IntPtr # 
Instance details

Defined in GHC.Internal.Foreign.Ptr

Methods

finiteBitSize :: IntPtr -> Int #

countLeadingZeros :: IntPtr -> Int #

countTrailingZeros :: IntPtr -> Int #

Bounded IntPtr # 
Instance details

Defined in GHC.Internal.Foreign.Ptr

Methods

minBound :: IntPtr #

maxBound :: IntPtr #

Enum IntPtr # 
Instance details

Defined in GHC.Internal.Foreign.Ptr

Methods

succ :: IntPtr -> IntPtr #

pred :: IntPtr -> IntPtr #

toEnum :: Int -> IntPtr #

fromEnum :: IntPtr -> Int #

enumFrom :: IntPtr -> [IntPtr] #

enumFromThen :: IntPtr -> IntPtr -> [IntPtr] #

enumFromTo :: IntPtr -> IntPtr -> [IntPtr] #

enumFromThenTo :: IntPtr -> IntPtr -> IntPtr -> [IntPtr] #

Storable IntPtr # 
Instance details

Defined in GHC.Internal.Foreign.Ptr

Methods

sizeOf :: IntPtr -> Int #

alignment :: IntPtr -> Int #

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

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

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

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

peek :: Ptr IntPtr -> IO IntPtr #

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

Ix IntPtr # 
Instance details

Defined in GHC.Internal.Foreign.Ptr

Methods

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

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

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

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

rangeSize :: (IntPtr, IntPtr) -> Int

unsafeRangeSize :: (IntPtr, IntPtr) -> Int

Num IntPtr # 
Instance details

Defined in GHC.Internal.Foreign.Ptr

Methods

(+) :: IntPtr -> IntPtr -> IntPtr #

(-) :: IntPtr -> IntPtr -> IntPtr #

(*) :: IntPtr -> IntPtr -> IntPtr #

negate :: IntPtr -> IntPtr #

abs :: IntPtr -> IntPtr #

signum :: IntPtr -> IntPtr #

fromInteger :: Integer -> IntPtr #

Read IntPtr # 
Instance details

Defined in GHC.Internal.Foreign.Ptr

Methods

readsPrec :: Int -> ReadS IntPtr #

readList :: ReadS [IntPtr] #

readPrec :: ReadPrec IntPtr #

readListPrec :: ReadPrec [IntPtr] #

Integral IntPtr # 
Instance details

Defined in GHC.Internal.Foreign.Ptr

Methods

quot :: IntPtr -> IntPtr -> IntPtr #

rem :: IntPtr -> IntPtr -> IntPtr #

div :: IntPtr -> IntPtr -> IntPtr #

mod :: IntPtr -> IntPtr -> IntPtr #

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

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

toInteger :: IntPtr -> Integer #

Real IntPtr # 
Instance details

Defined in GHC.Internal.Foreign.Ptr

Methods

toRational :: IntPtr -> Rational #

Show IntPtr # 
Instance details

Defined in GHC.Internal.Foreign.Ptr

Methods

showsPrec :: Int -> IntPtr -> ShowS #

show :: IntPtr -> String #

showList :: [IntPtr] -> ShowS #

Eq IntPtr # 
Instance details

Defined in GHC.Internal.Foreign.Ptr

Methods

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

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

Ord IntPtr # 
Instance details

Defined in GHC.Internal.Foreign.Ptr

Methods

compare :: IntPtr -> IntPtr -> Ordering #

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

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

(>) :: IntPtr -> IntPtr -> Bool #

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

max :: IntPtr -> IntPtr -> IntPtr #

min :: IntPtr -> IntPtr -> IntPtr #

newtype WordPtr #

Constructors

WordPtr Word 

Instances

Instances details
Bits WordPtr # 
Instance details

Defined in GHC.Internal.Foreign.Ptr

Methods

(.&.) :: WordPtr -> WordPtr -> WordPtr #

(.|.) :: WordPtr -> WordPtr -> WordPtr #

xor :: WordPtr -> WordPtr -> WordPtr #

complement :: WordPtr -> WordPtr #

shift :: WordPtr -> Int -> WordPtr #

rotate :: WordPtr -> Int -> WordPtr #

zeroBits :: WordPtr #

bit :: Int -> WordPtr #

setBit :: WordPtr -> Int -> WordPtr #

clearBit :: WordPtr -> Int -> WordPtr #

complementBit :: WordPtr -> Int -> WordPtr #

testBit :: WordPtr -> Int -> Bool #

bitSizeMaybe :: WordPtr -> Maybe Int #

bitSize :: WordPtr -> Int #

isSigned :: WordPtr -> Bool #

shiftL :: WordPtr -> Int -> WordPtr #

unsafeShiftL :: WordPtr -> Int -> WordPtr #

shiftR :: WordPtr -> Int -> WordPtr #

unsafeShiftR :: WordPtr -> Int -> WordPtr #

rotateL :: WordPtr -> Int -> WordPtr #

rotateR :: WordPtr -> Int -> WordPtr #

popCount :: WordPtr -> Int #

FiniteBits WordPtr # 
Instance details

Defined in GHC.Internal.Foreign.Ptr

Methods

finiteBitSize :: WordPtr -> Int #

countLeadingZeros :: WordPtr -> Int #

countTrailingZeros :: WordPtr -> Int #

Bounded WordPtr # 
Instance details

Defined in GHC.Internal.Foreign.Ptr

Methods

minBound :: WordPtr #

maxBound :: WordPtr #

Enum WordPtr # 
Instance details

Defined in GHC.Internal.Foreign.Ptr

Methods

succ :: WordPtr -> WordPtr #

pred :: WordPtr -> WordPtr #

toEnum :: Int -> WordPtr #

fromEnum :: WordPtr -> Int #

enumFrom :: WordPtr -> [WordPtr] #

enumFromThen :: WordPtr -> WordPtr -> [WordPtr] #

enumFromTo :: WordPtr -> WordPtr -> [WordPtr] #

enumFromThenTo :: WordPtr -> WordPtr -> WordPtr -> [WordPtr] #

Storable WordPtr # 
Instance details

Defined in GHC.Internal.Foreign.Ptr

Methods

sizeOf :: WordPtr -> Int #

alignment :: WordPtr -> Int #

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

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

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

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

peek :: Ptr WordPtr -> IO WordPtr #

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

Ix WordPtr # 
Instance details

Defined in GHC.Internal.Foreign.Ptr

Methods

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

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

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

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

rangeSize :: (WordPtr, WordPtr) -> Int

unsafeRangeSize :: (WordPtr, WordPtr) -> Int

Num WordPtr # 
Instance details

Defined in GHC.Internal.Foreign.Ptr

Methods

(+) :: WordPtr -> WordPtr -> WordPtr #

(-) :: WordPtr -> WordPtr -> WordPtr #

(*) :: WordPtr -> WordPtr -> WordPtr #

negate :: WordPtr -> WordPtr #

abs :: WordPtr -> WordPtr #

signum :: WordPtr -> WordPtr #

fromInteger :: Integer -> WordPtr #

Read WordPtr # 
Instance details

Defined in GHC.Internal.Foreign.Ptr

Methods

readsPrec :: Int -> ReadS WordPtr #

readList :: ReadS [WordPtr] #

readPrec :: ReadPrec WordPtr #

readListPrec :: ReadPrec [WordPtr] #

Integral WordPtr # 
Instance details

Defined in GHC.Internal.Foreign.Ptr

Methods

quot :: WordPtr -> WordPtr -> WordPtr #

rem :: WordPtr -> WordPtr -> WordPtr #

div :: WordPtr -> WordPtr -> WordPtr #

mod :: WordPtr -> WordPtr -> WordPtr #

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

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

toInteger :: WordPtr -> Integer #

Real WordPtr # 
Instance details

Defined in GHC.Internal.Foreign.Ptr

Methods

toRational :: WordPtr -> Rational #

Show WordPtr # 
Instance details

Defined in GHC.Internal.Foreign.Ptr

Methods

showsPrec :: Int -> WordPtr -> ShowS #

show :: WordPtr -> String #

showList :: [WordPtr] -> ShowS #

Eq WordPtr # 
Instance details

Defined in GHC.Internal.Foreign.Ptr

Methods

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

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

Ord WordPtr # 
Instance details

Defined in GHC.Internal.Foreign.Ptr

Methods

compare :: WordPtr -> WordPtr -> Ordering #

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

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

(>) :: WordPtr -> WordPtr -> Bool #

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

max :: WordPtr -> WordPtr -> WordPtr #

min :: WordPtr -> WordPtr -> WordPtr #

class Storable a where #

Minimal complete definition

sizeOf, alignment, (peek | peekElemOff | peekByteOff), (poke | pokeElemOff | pokeByteOff)

Methods

sizeOf :: a -> Int #

alignment :: a -> Int #

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

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

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

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

peek :: Ptr a -> IO a #

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

Instances

Instances details
Storable Fingerprint # 
Instance details

Defined in GHC.Internal.Foreign.Storable

Methods

sizeOf :: Fingerprint -> Int #

alignment :: Fingerprint -> Int #

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

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

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

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

peek :: Ptr Fingerprint -> IO Fingerprint #

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

Storable CBool # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 () #

Storable CChar # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 () #

Storable CClock # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 () #

Storable CDouble # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 () #

Storable CFloat # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 () #

Storable CInt # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 () #

Storable CIntMax # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 () #

Storable CIntPtr # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 () #

Storable CLLong # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 () #

Storable CLong # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 () #

Storable CPtrdiff # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 () #

Storable CSChar # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 () #

Storable CSUSeconds # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 () #

Storable CShort # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 () #

Storable CSigAtomic # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 () #

Storable CSize # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 () #

Storable CTime # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 () #

Storable CUChar # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 () #

Storable CUInt # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 () #

Storable CUIntMax # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 () #

Storable CUIntPtr # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 () #

Storable CULLong # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 () #

Storable CULong # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 () #

Storable CUSeconds # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 () #

Storable CUShort # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 () #

Storable CWchar # 
Instance details

Defined in GHC.Internal.Foreign.C.Types

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 () #

Storable IntPtr # 
Instance details

Defined in GHC.Internal.Foreign.Ptr

Methods

sizeOf :: IntPtr -> Int #

alignment :: IntPtr -> Int #

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

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

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

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

peek :: Ptr IntPtr -> IO IntPtr #

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

Storable WordPtr # 
Instance details

Defined in GHC.Internal.Foreign.Ptr

Methods

sizeOf :: WordPtr -> Int #

alignment :: WordPtr -> Int #

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

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

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

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

peek :: Ptr WordPtr -> IO WordPtr #

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

Storable Int16 # 
Instance details

Defined in GHC.Internal.Foreign.Storable

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 () #

Storable Int32 # 
Instance details

Defined in GHC.Internal.Foreign.Storable

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 () #

Storable Int64 # 
Instance details

Defined in GHC.Internal.Foreign.Storable

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 () #

Storable Int8 # 
Instance details

Defined in GHC.Internal.Foreign.Storable

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 () #

Storable CBlkCnt # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: CBlkCnt -> Int #

alignment :: CBlkCnt -> Int #

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

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

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

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

peek :: Ptr CBlkCnt -> IO CBlkCnt #

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

Storable CBlkSize # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: CBlkSize -> Int #

alignment :: CBlkSize -> Int #

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

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

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

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

peek :: Ptr CBlkSize -> IO CBlkSize #

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

Storable CCc # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: CCc -> Int #

alignment :: CCc -> Int #

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

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

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

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

peek :: Ptr CCc -> IO CCc #

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

Storable CClockId # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: CClockId -> Int #

alignment :: CClockId -> Int #

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

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

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

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

peek :: Ptr CClockId -> IO CClockId #

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

Storable CDev # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: CDev -> Int #

alignment :: CDev -> Int #

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

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

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

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

peek :: Ptr CDev -> IO CDev #

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

Storable CFsBlkCnt # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: CFsBlkCnt -> Int #

alignment :: CFsBlkCnt -> Int #

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

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

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

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

peek :: Ptr CFsBlkCnt -> IO CFsBlkCnt #

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

Storable CFsFilCnt # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: CFsFilCnt -> Int #

alignment :: CFsFilCnt -> Int #

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

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

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

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

peek :: Ptr CFsFilCnt -> IO CFsFilCnt #

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

Storable CGid # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: CGid -> Int #

alignment :: CGid -> Int #

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

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

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

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

peek :: Ptr CGid -> IO CGid #

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

Storable CId # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: CId -> Int #

alignment :: CId -> Int #

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

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

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

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

peek :: Ptr CId -> IO CId #

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

Storable CIno # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: CIno -> Int #

alignment :: CIno -> Int #

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

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

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

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

peek :: Ptr CIno -> IO CIno #

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

Storable CKey # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: CKey -> Int #

alignment :: CKey -> Int #

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

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

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

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

peek :: Ptr CKey -> IO CKey #

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

Storable CMode # 
Instance details

Defined in GHC.Internal.System.Posix.Types

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 () #

Storable CNfds # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: CNfds -> Int #

alignment :: CNfds -> Int #

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

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

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

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

peek :: Ptr CNfds -> IO CNfds #

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

Storable CNlink # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: CNlink -> Int #

alignment :: CNlink -> Int #

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

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

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

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

peek :: Ptr CNlink -> IO CNlink #

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

Storable COff # 
Instance details

Defined in GHC.Internal.System.Posix.Types

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 () #

Storable CPid # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: CPid -> Int #

alignment :: CPid -> Int #

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

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

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

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

peek :: Ptr CPid -> IO CPid #

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

Storable CRLim # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: CRLim -> Int #

alignment :: CRLim -> Int #

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

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

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

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

peek :: Ptr CRLim -> IO CRLim #

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

Storable CSocklen # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: CSocklen -> Int #

alignment :: CSocklen -> Int #

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

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

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

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

peek :: Ptr CSocklen -> IO CSocklen #

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

Storable CSpeed # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: CSpeed -> Int #

alignment :: CSpeed -> Int #

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

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

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

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

peek :: Ptr CSpeed -> IO CSpeed #

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

Storable CSsize # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: CSsize -> Int #

alignment :: CSsize -> Int #

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

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

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

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

peek :: Ptr CSsize -> IO CSsize #

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

Storable CTcflag # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: CTcflag -> Int #

alignment :: CTcflag -> Int #

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

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

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

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

peek :: Ptr CTcflag -> IO CTcflag #

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

Storable CTimer # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: CTimer -> Int #

alignment :: CTimer -> Int #

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

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

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

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

peek :: Ptr CTimer -> IO CTimer #

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

Storable CUid # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: CUid -> Int #

alignment :: CUid -> Int #

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

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

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

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

peek :: Ptr CUid -> IO CUid #

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

Storable Fd # 
Instance details

Defined in GHC.Internal.System.Posix.Types

Methods

sizeOf :: Fd -> Int #

alignment :: Fd -> Int #

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

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

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

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

peek :: Ptr Fd -> IO Fd #

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

Storable Word16 # 
Instance details

Defined in GHC.Internal.Foreign.Storable

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 () #

Storable Word32 # 
Instance details

Defined in GHC.Internal.Foreign.Storable

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 () #

Storable Word64 # 
Instance details

Defined in GHC.Internal.Foreign.Storable

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 () #

Storable Word8 # 
Instance details

Defined in GHC.Internal.Foreign.Storable

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 () #

Storable () # 
Instance details

Defined in GHC.Internal.Foreign.Storable

Methods

sizeOf :: () -> Int #

alignment :: () -> Int #

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

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

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

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

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

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

Storable Bool # 
Instance details

Defined in GHC.Internal.Foreign.Storable

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 () #

Storable Char # 
Instance details

Defined in GHC.Internal.Foreign.Storable

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 () #

Storable Double # 
Instance details

Defined in GHC.Internal.Foreign.Storable

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 () #

Storable Float # 
Instance details

Defined in GHC.Internal.Foreign.Storable

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 () #

Storable Int # 
Instance details

Defined in GHC.Internal.Foreign.Storable

Methods

sizeOf :: Int -> Int #

alignment :: Int -> Int #

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

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

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

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

peek :: Ptr Int -> IO Int #

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

Storable Word # 
Instance details

Defined in GHC.Internal.Foreign.Storable

Methods

sizeOf :: Word -> Int #

alignment :: Word -> Int #

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

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

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

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

peek :: Ptr Word -> IO Word #

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

Storable a => Storable (Complex a) # 
Instance details

Defined in Data.Complex

Methods

sizeOf :: Complex a -> Int #

alignment :: Complex a -> Int #

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

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

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

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

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

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

Storable a => Storable (Identity a) # 
Instance details

Defined in GHC.Internal.Data.Functor.Identity

Methods

sizeOf :: Identity a -> Int #

alignment :: Identity a -> Int #

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

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

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

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

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

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

Storable (ConstPtr a) # 
Instance details

Defined in GHC.Internal.Foreign.Storable

Methods

sizeOf :: ConstPtr a -> Int #

alignment :: ConstPtr a -> Int #

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

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

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

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

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

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

Storable (FunPtr a) # 
Instance details

Defined in GHC.Internal.Foreign.Storable

Methods

sizeOf :: FunPtr a -> Int #

alignment :: FunPtr a -> Int #

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

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

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

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

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

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

Storable (Ptr a) # 
Instance details

Defined in GHC.Internal.Foreign.Storable

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 () #

(Storable a, Integral a) => Storable (Ratio a) # 
Instance details

Defined in GHC.Internal.Foreign.Storable

Methods

sizeOf :: Ratio a -> Int #

alignment :: Ratio a -> Int #

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

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

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

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

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

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

Storable (StablePtr a) # 
Instance details

Defined in GHC.Internal.Foreign.Storable

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 () #

Storable a => Storable (Const a b) # 
Instance details

Defined in GHC.Internal.Data.Functor.Const

Methods

sizeOf :: Const a b -> Int #

alignment :: Const a b -> Int #

peekElemOff :: Ptr (Const a b) -> Int -> IO (Const a b) #

pokeElemOff :: Ptr (Const a b) -> Int -> Const a b -> IO () #

peekByteOff :: Ptr b0 -> Int -> IO (Const a b) #

pokeByteOff :: Ptr b0 -> Int -> Const a b -> IO () #

peek :: Ptr (Const a b) -> IO (Const a b) #

poke :: Ptr (Const a b) -> Const a b -> IO () #

type FinalizerEnvPtr env a = FunPtr (Ptr env -> Ptr a -> IO ()) #

type FinalizerPtr a = FunPtr (Ptr a -> IO ()) #

data ForeignPtr a #

Instances

Instances details
Show (ForeignPtr a) # 
Instance details

Defined in GHC.Internal.ForeignPtr

Methods

showsPrec :: Int -> ForeignPtr a -> ShowS #

show :: ForeignPtr a -> String #

showList :: [ForeignPtr a] -> ShowS #

Eq (ForeignPtr a) # 
Instance details

Defined in GHC.Internal.ForeignPtr

Methods

(==) :: ForeignPtr a -> ForeignPtr a -> Bool #

(/=) :: ForeignPtr a -> ForeignPtr a -> Bool #

Ord (ForeignPtr a) # 
Instance details

Defined in GHC.Internal.ForeignPtr

Methods

compare :: ForeignPtr a -> ForeignPtr a -> Ordering #

(<) :: ForeignPtr a -> ForeignPtr a -> Bool #

(<=) :: ForeignPtr a -> ForeignPtr a -> Bool #

(>) :: ForeignPtr a -> ForeignPtr a -> Bool #

(>=) :: ForeignPtr a -> ForeignPtr a -> Bool #

max :: ForeignPtr a -> ForeignPtr a -> ForeignPtr a #

min :: ForeignPtr a -> ForeignPtr a -> ForeignPtr a #

data Int16 #

Instances

Instances details
PrintfArg Int16 # 
Instance details

Defined in Text.Printf

Methods

formatArg :: Int16 -> FieldFormatter

parseFormat :: Int16 -> ModifierParser

Bits Int16 # 
Instance details

Defined in GHC.Internal.Int

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 # 
Instance details

Defined in GHC.Internal.Int

Methods

finiteBitSize :: Int16 -> Int #

countLeadingZeros :: Int16 -> Int #

countTrailingZeros :: Int16 -> Int #

Bounded Int16 # 
Instance details

Defined in GHC.Internal.Int

Methods

minBound :: Int16 #

maxBound :: Int16 #

Enum Int16 # 
Instance details

Defined in GHC.Internal.Int

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] #

Storable Int16 # 
Instance details

Defined in GHC.Internal.Foreign.Storable

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 () #

Ix Int16 # 
Instance details

Defined in GHC.Internal.Int

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

Num Int16 # 
Instance details

Defined in GHC.Internal.Int

Methods

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

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

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

negate :: Int16 -> Int16 #

abs :: Int16 -> Int16 #

signum :: Int16 -> Int16 #

fromInteger :: Integer -> Int16 #

Read Int16 # 
Instance details

Defined in GHC.Internal.Int

Methods

readsPrec :: Int -> ReadS Int16 #

readList :: ReadS [Int16] #

readPrec :: ReadPrec Int16 #

readListPrec :: ReadPrec [Int16] #

Integral Int16 # 
Instance details

Defined in GHC.Internal.Int

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 #

Real Int16 # 
Instance details

Defined in GHC.Internal.Int

Methods

toRational :: Int16 -> Rational #

Show Int16 # 
Instance details

Defined in GHC.Internal.Int

Methods

showsPrec :: Int -> Int16 -> ShowS #

show :: Int16 -> String #

showList :: [Int16] -> ShowS #

Eq Int16 # 
Instance details

Defined in GHC.Internal.Int

Methods

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

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

Ord Int16 # 
Instance details

Defined in GHC.Internal.Int

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 #

data Int32 #

Instances

Instances details
PrintfArg Int32 # 
Instance details

Defined in Text.Printf

Methods

formatArg :: Int32 -> FieldFormatter

parseFormat :: Int32 -> ModifierParser

Bits Int32 # 
Instance details

Defined in GHC.Internal.Int

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 # 
Instance details

Defined in GHC.Internal.Int

Methods

finiteBitSize :: Int32 -> Int #

countLeadingZeros :: Int32 -> Int #

countTrailingZeros :: Int32 -> Int #

Bounded Int32 # 
Instance details

Defined in GHC.Internal.Int

Methods

minBound :: Int32 #

maxBound :: Int32 #

Enum Int32 # 
Instance details

Defined in GHC.Internal.Int

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] #

Storable Int32 # 
Instance details

Defined in GHC.Internal.Foreign.Storable

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 () #

Ix Int32 # 
Instance details

Defined in GHC.Internal.Int

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

Num Int32 # 
Instance details

Defined in GHC.Internal.Int

Methods

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

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

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

negate :: Int32 -> Int32 #

abs :: Int32 -> Int32 #

signum :: Int32 -> Int32 #

fromInteger :: Integer -> Int32 #

Read Int32 # 
Instance details

Defined in GHC.Internal.Int

Methods

readsPrec :: Int -> ReadS Int32 #

readList :: ReadS [Int32] #

readPrec :: ReadPrec Int32 #

readListPrec :: ReadPrec [Int32] #

Integral Int32 # 
Instance details

Defined in GHC.Internal.Int

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 #

Real Int32 # 
Instance details

Defined in GHC.Internal.Int

Methods

toRational :: Int32 -> Rational #

Show Int32 # 
Instance details

Defined in GHC.Internal.Int

Methods

showsPrec :: Int -> Int32 -> ShowS #

show :: Int32 -> String #

showList :: [Int32] -> ShowS #

Eq Int32 # 
Instance details

Defined in GHC.Internal.Int

Methods

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

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

Ord Int32 # 
Instance details

Defined in GHC.Internal.Int

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 #

data Int64 #

Instances

Instances details
PrintfArg Int64 # 
Instance details

Defined in Text.Printf

Methods

formatArg :: Int64 -> FieldFormatter

parseFormat :: Int64 -> ModifierParser

Bits Int64 # 
Instance details

Defined in GHC.Internal.Int

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 # 
Instance details

Defined in GHC.Internal.Int

Methods

finiteBitSize :: Int64 -> Int #

countLeadingZeros :: Int64 -> Int #

countTrailingZeros :: Int64 -> Int #

Bounded Int64 # 
Instance details

Defined in GHC.Internal.Int

Methods

minBound :: Int64 #

maxBound :: Int64 #

Enum Int64 # 
Instance details

Defined in GHC.Internal.Int

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] #

Storable Int64 # 
Instance details

Defined in GHC.Internal.Foreign.Storable

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 () #

Ix Int64 # 
Instance details

Defined in GHC.Internal.Int

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

Num Int64 # 
Instance details

Defined in GHC.Internal.Int

Methods

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

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

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

negate :: Int64 -> Int64 #

abs :: Int64 -> Int64 #

signum :: Int64 -> Int64 #

fromInteger :: Integer -> Int64 #

Read Int64 # 
Instance details

Defined in GHC.Internal.Int

Methods

readsPrec :: Int -> ReadS Int64 #

readList :: ReadS [Int64] #

readPrec :: ReadPrec Int64 #

readListPrec :: ReadPrec [Int64] #

Integral Int64 # 
Instance details

Defined in GHC.Internal.Int

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 #

Real Int64 # 
Instance details

Defined in GHC.Internal.Int

Methods

toRational :: Int64 -> Rational #

Show Int64 # 
Instance details

Defined in GHC.Internal.Int

Methods

showsPrec :: Int -> Int64 -> ShowS #

show :: Int64 -> String #

showList :: [Int64] -> ShowS #

Eq Int64 # 
Instance details

Defined in GHC.Internal.Int

Methods

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

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

Ord Int64 # 
Instance details

Defined in GHC.Internal.Int

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 #

data Int8 #

Instances

Instances details
PrintfArg Int8 # 
Instance details

Defined in Text.Printf

Methods

formatArg :: Int8 -> FieldFormatter

parseFormat :: Int8 -> ModifierParser

Bits Int8 # 
Instance details

Defined in GHC.Internal.Int

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 # 
Instance details

Defined in GHC.Internal.Int

Methods

finiteBitSize :: Int8 -> Int #

countLeadingZeros :: Int8 -> Int #

countTrailingZeros :: Int8 -> Int #

Bounded Int8 # 
Instance details

Defined in GHC.Internal.Int

Methods

minBound :: Int8 #

maxBound :: Int8 #

Enum Int8 # 
Instance details

Defined in GHC.Internal.Int

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] #

Storable Int8 # 
Instance details

Defined in GHC.Internal.Foreign.Storable

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 () #

Ix Int8 # 
Instance details

Defined in GHC.Internal.Int

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

Num Int8 # 
Instance details

Defined in GHC.Internal.Int

Methods

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

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

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

negate :: Int8 -> Int8 #

abs :: Int8 -> Int8 #

signum :: Int8 -> Int8 #

fromInteger :: Integer -> Int8 #

Read Int8 # 
Instance details

Defined in GHC.Internal.Int

Methods

readsPrec :: Int -> ReadS Int8 #

readList :: ReadS [Int8] #

readPrec :: ReadPrec Int8 #

readListPrec :: ReadPrec [Int8] #

Integral Int8 # 
Instance details

Defined in GHC.Internal.Int

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 #

Real Int8 # 
Instance details

Defined in GHC.Internal.Int

Methods

toRational :: Int8 -> Rational #

Show Int8 # 
Instance details

Defined in GHC.Internal.Int

Methods

showsPrec :: Int -> Int8 -> ShowS #

show :: Int8 -> String #

showList :: [Int8] -> ShowS #

Eq Int8 # 
Instance details

Defined in GHC.Internal.Int

Methods

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

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

Ord Int8 # 
Instance details

Defined in GHC.Internal.Int

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 #

data FunPtr a #

Instances

Instances details
Storable (FunPtr a) # 
Instance details

Defined in GHC.Internal.Foreign.Storable

Methods

sizeOf :: FunPtr a -> Int #

alignment :: FunPtr a -> Int #

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

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

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

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

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

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

Show (FunPtr a) # 
Instance details

Defined in GHC.Internal.Ptr

Methods

showsPrec :: Int -> FunPtr a -> ShowS #

show :: FunPtr a -> String #

showList :: [FunPtr a] -> ShowS #

Eq (FunPtr a) # 
Instance details

Defined in GHC.Internal.Ptr

Methods

(==) :: FunPtr a -> FunPtr a -> Bool #

(/=) :: FunPtr a -> FunPtr a -> Bool #

Ord (FunPtr a) # 
Instance details

Defined in GHC.Internal.Ptr

Methods

compare :: FunPtr a -> FunPtr a -> Ordering #

(<) :: FunPtr a -> FunPtr a -> Bool #

(<=) :: FunPtr a -> FunPtr a -> Bool #

(>) :: FunPtr a -> FunPtr a -> Bool #

(>=) :: FunPtr a -> FunPtr a -> Bool #

max :: FunPtr a -> FunPtr a -> FunPtr a #

min :: FunPtr a -> FunPtr a -> FunPtr a #

data Ptr a #

Instances

Instances details
Eq1 (UAddr :: Type -> Type) # 
Instance details

Defined in Data.Functor.Classes

Methods

liftEq :: (a -> b -> Bool) -> UAddr a -> UAddr b -> Bool

Ord1 (UAddr :: Type -> Type) # 
Instance details

Defined in Data.Functor.Classes

Methods

liftCompare :: (a -> b -> Ordering) -> UAddr a -> UAddr b -> Ordering

Show1 (UAddr :: Type -> Type) # 
Instance details

Defined in Data.Functor.Classes

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> UAddr a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [UAddr a] -> ShowS

Foldable (UAddr :: Type -> Type) # 
Instance details

Defined in GHC.Internal.Data.Foldable

Methods

fold :: Monoid m => UAddr m -> m #

foldMap :: Monoid m => (a -> m) -> UAddr a -> m #

foldMap' :: Monoid m => (a -> m) -> UAddr a -> m #

foldr :: (a -> b -> b) -> b -> UAddr a -> b #

foldr' :: (a -> b -> b) -> b -> UAddr a -> b #

foldl :: (b -> a -> b) -> b -> UAddr a -> b #

foldl' :: (b -> a -> b) -> b -> UAddr a -> b #

foldr1 :: (a -> a -> a) -> UAddr a -> a #

foldl1 :: (a -> a -> a) -> UAddr a -> a #

toList :: UAddr a -> [a] #

null :: UAddr a -> Bool #

length :: UAddr a -> Int #

elem :: Eq a => a -> UAddr a -> Bool #

maximum :: Ord a => UAddr a -> a #

minimum :: Ord a => UAddr a -> a #

sum :: Num a => UAddr a -> a #

product :: Num a => UAddr a -> a #

Traversable (UAddr :: Type -> Type) # 
Instance details

Defined in GHC.Internal.Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> UAddr a -> f (UAddr b) #

sequenceA :: Applicative f => UAddr (f a) -> f (UAddr a) #

mapM :: Monad m => (a -> m b) -> UAddr a -> m (UAddr b) #

sequence :: Monad m => UAddr (m a) -> m (UAddr a) #

Storable (Ptr a) # 
Instance details

Defined in GHC.Internal.Foreign.Storable

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 () #

Show (Ptr a) # 
Instance details

Defined in GHC.Internal.Ptr

Methods

showsPrec :: Int -> Ptr a -> ShowS #

show :: Ptr a -> String #

showList :: [Ptr a] -> ShowS #

Eq (Ptr a) # 
Instance details

Defined in GHC.Internal.Ptr

Methods

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

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

Ord (Ptr a) # 
Instance details

Defined in GHC.Internal.Ptr

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 #

data StablePtr a #

Instances

Instances details
Storable (StablePtr a) # 
Instance details

Defined in GHC.Internal.Foreign.Storable

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 () #

Eq (StablePtr a) # 
Instance details

Defined in GHC.Internal.Stable

Methods

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

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

data Word16 #

Instances

Instances details
PrintfArg Word16 # 
Instance details

Defined in Text.Printf

Methods

formatArg :: Word16 -> FieldFormatter

parseFormat :: Word16 -> ModifierParser

Bits Word16 # 
Instance details

Defined in GHC.Internal.Word

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 # 
Instance details

Defined in GHC.Internal.Word

Methods

finiteBitSize :: Word16 -> Int #

countLeadingZeros :: Word16 -> Int #

countTrailingZeros :: Word16 -> Int #

Bounded Word16 # 
Instance details

Defined in GHC.Internal.Word

Methods

minBound :: Word16 #

maxBound :: Word16 #

Enum Word16 # 
Instance details

Defined in GHC.Internal.Word

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] #

Storable Word16 # 
Instance details

Defined in GHC.Internal.Foreign.Storable

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 () #

Ix Word16 # 
Instance details

Defined in GHC.Internal.Word

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

Num Word16 # 
Instance details

Defined in GHC.Internal.Word

Methods

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

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

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

negate :: Word16 -> Word16 #

abs :: Word16 -> Word16 #

signum :: Word16 -> Word16 #

fromInteger :: Integer -> Word16 #

Read Word16 # 
Instance details

Defined in GHC.Internal.Read

Methods

readsPrec :: Int -> ReadS Word16 #

readList :: ReadS [Word16] #

readPrec :: ReadPrec Word16 #

readListPrec :: ReadPrec [Word16] #

Integral Word16 # 
Instance details

Defined in GHC.Internal.Word

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 #

Real Word16 # 
Instance details

Defined in GHC.Internal.Word

Methods

toRational :: Word16 -> Rational #

Show Word16 # 
Instance details

Defined in GHC.Internal.Word

Methods

showsPrec :: Int -> Word16 -> ShowS #

show :: Word16 -> String #

showList :: [Word16] -> ShowS #

Eq Word16 # 
Instance details

Defined in GHC.Internal.Word

Methods

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

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

Ord Word16 # 
Instance details

Defined in GHC.Internal.Word

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 #

data Word32 #

Instances

Instances details
PrintfArg Word32 # 
Instance details

Defined in Text.Printf

Methods

formatArg :: Word32 -> FieldFormatter

parseFormat :: Word32 -> ModifierParser

Bits Word32 # 
Instance details

Defined in GHC.Internal.Word

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 # 
Instance details

Defined in GHC.Internal.Word

Methods

finiteBitSize :: Word32 -> Int #

countLeadingZeros :: Word32 -> Int #

countTrailingZeros :: Word32 -> Int #

Bounded Word32 # 
Instance details

Defined in GHC.Internal.Word

Methods

minBound :: Word32 #

maxBound :: Word32 #

Enum Word32 # 
Instance details

Defined in GHC.Internal.Word

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] #

Storable Word32 # 
Instance details

Defined in GHC.Internal.Foreign.Storable

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 () #

Ix Word32 # 
Instance details

Defined in GHC.Internal.Word

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

Num Word32 # 
Instance details

Defined in GHC.Internal.Word

Methods

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

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

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

negate :: Word32 -> Word32 #

abs :: Word32 -> Word32 #

signum :: Word32 -> Word32 #

fromInteger :: Integer -> Word32 #

Read Word32 # 
Instance details

Defined in GHC.Internal.Read

Methods

readsPrec :: Int -> ReadS Word32 #

readList :: ReadS [Word32] #

readPrec :: ReadPrec Word32 #

readListPrec :: ReadPrec [Word32] #

Integral Word32 # 
Instance details

Defined in GHC.Internal.Word

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 #

Real Word32 # 
Instance details

Defined in GHC.Internal.Word

Methods

toRational :: Word32 -> Rational #

Show Word32 # 
Instance details

Defined in GHC.Internal.Word

Methods

showsPrec :: Int -> Word32 -> ShowS #

show :: Word32 -> String #

showList :: [Word32] -> ShowS #

Eq Word32 # 
Instance details

Defined in GHC.Internal.Word

Methods

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

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

Ord Word32 # 
Instance details

Defined in GHC.Internal.Word

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 #

data Word64 #

Instances

Instances details
PrintfArg Word64 # 
Instance details

Defined in Text.Printf

Methods

formatArg :: Word64 -> FieldFormatter

parseFormat :: Word64 -> ModifierParser

Bits Word64 # 
Instance details

Defined in GHC.Internal.Word

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 # 
Instance details

Defined in GHC.Internal.Word

Methods

finiteBitSize :: Word64 -> Int #

countLeadingZeros :: Word64 -> Int #

countTrailingZeros :: Word64 -> Int #

Bounded Word64 # 
Instance details

Defined in GHC.Internal.Word

Methods

minBound :: Word64 #

maxBound :: Word64 #

Enum Word64 # 
Instance details

Defined in GHC.Internal.Word

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] #

Storable Word64 # 
Instance details

Defined in GHC.Internal.Foreign.Storable

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 () #

Ix Word64 # 
Instance details

Defined in GHC.Internal.Word

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

Num Word64 # 
Instance details

Defined in GHC.Internal.Word

Methods

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

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

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

negate :: Word64 -> Word64 #

abs :: Word64 -> Word64 #

signum :: Word64 -> Word64 #

fromInteger :: Integer -> Word64 #

Read Word64 # 
Instance details

Defined in GHC.Internal.Read

Methods

readsPrec :: Int -> ReadS Word64 #

readList :: ReadS [Word64] #

readPrec :: ReadPrec Word64 #

readListPrec :: ReadPrec [Word64] #

Integral Word64 # 
Instance details

Defined in GHC.Internal.Word

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 #

Real Word64 # 
Instance details

Defined in GHC.Internal.Word

Methods

toRational :: Word64 -> Rational #

Show Word64 # 
Instance details

Defined in GHC.Internal.Word

Methods

showsPrec :: Int -> Word64 -> ShowS #

show :: Word64 -> String #

showList :: [Word64] -> ShowS #

Eq Word64 # 
Instance details

Defined in GHC.Internal.Word

Methods

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

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

Ord Word64 # 
Instance details

Defined in GHC.Internal.Word

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 #

data Word8 #

Instances

Instances details
PrintfArg Word8 # 
Instance details

Defined in Text.Printf

Methods

formatArg :: Word8 -> FieldFormatter

parseFormat :: Word8 -> ModifierParser

Bits Word8 # 
Instance details

Defined in GHC.Internal.Word

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 # 
Instance details

Defined in GHC.Internal.Word

Methods

finiteBitSize :: Word8 -> Int #

countLeadingZeros :: Word8 -> Int #

countTrailingZeros :: Word8 -> Int #

Bounded Word8 # 
Instance details

Defined in GHC.Internal.Word

Methods

minBound :: Word8 #

maxBound :: Word8 #

Enum Word8 # 
Instance details

Defined in GHC.Internal.Word

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] #

Storable Word8 # 
Instance details

Defined in GHC.Internal.Foreign.Storable

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 () #

Ix Word8 # 
Instance details

Defined in GHC.Internal.Word

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

Num Word8 # 
Instance details

Defined in GHC.Internal.Word

Methods

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

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

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

negate :: Word8 -> Word8 #

abs :: Word8 -> Word8 #

signum :: Word8 -> Word8 #

fromInteger :: Integer -> Word8 #

Read Word8 # 
Instance details

Defined in GHC.Internal.Read

Methods

readsPrec :: Int -> ReadS Word8 #

readList :: ReadS [Word8] #

readPrec :: ReadPrec Word8 #

readListPrec :: ReadPrec [Word8] #

Integral Word8 # 
Instance details

Defined in GHC.Internal.Word

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 #

Real Word8 # 
Instance details

Defined in GHC.Internal.Word

Methods

toRational :: Word8 -> Rational #

Show Word8 # 
Instance details

Defined in GHC.Internal.Word

Methods

showsPrec :: Int -> Word8 -> ShowS #

show :: Word8 -> String #

showList :: [Word8] -> ShowS #

Eq Word8 # 
Instance details

Defined in GHC.Internal.Word

Methods

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

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

Ord Word8 # 
Instance details

Defined in GHC.Internal.Word

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 #

data Int #

Instances

Instances details
PrintfArg Int # 
Instance details

Defined in Text.Printf

Methods

formatArg :: Int -> FieldFormatter

parseFormat :: Int -> ModifierParser

Bits Int # 
Instance details

Defined in GHC.Internal.Bits

Methods

(.&.) :: Int -> Int -> Int #

(.|.) :: Int -> Int -> Int #

xor :: Int -> Int -> Int #

complement :: Int -> Int #

shift :: Int -> Int -> Int #

rotate :: Int -> Int -> Int #

zeroBits :: Int #

bit :: Int -> Int #

setBit :: Int -> Int -> Int #

clearBit :: Int -> Int -> Int #

complementBit :: Int -> Int -> Int #

testBit :: Int -> Int -> Bool #

bitSizeMaybe :: Int -> Maybe Int #

bitSize :: Int -> Int #

isSigned :: Int -> Bool #

shiftL :: Int -> Int -> Int #

unsafeShiftL :: Int -> Int -> Int #

shiftR :: Int -> Int -> Int #

unsafeShiftR :: Int -> Int -> Int #

rotateL :: Int -> Int -> Int #

rotateR :: Int -> Int -> Int #

popCount :: Int -> Int #

FiniteBits Int # 
Instance details

Defined in GHC.Internal.Bits

Methods

finiteBitSize :: Int -> Int #

countLeadingZeros :: Int -> Int #

countTrailingZeros :: Int -> Int #

Bounded Int # 
Instance details

Defined in GHC.Internal.Enum

Methods

minBound :: Int #

maxBound :: Int #

Enum Int # 
Instance details

Defined in GHC.Internal.Enum

Methods

succ :: Int -> Int #

pred :: Int -> Int #

toEnum :: Int -> Int #

fromEnum :: Int -> Int #

enumFrom :: Int -> [Int] #

enumFromThen :: Int -> Int -> [Int] #

enumFromTo :: Int -> Int -> [Int] #

enumFromThenTo :: Int -> Int -> Int -> [Int] #

Storable Int # 
Instance details

Defined in GHC.Internal.Foreign.Storable

Methods

sizeOf :: Int -> Int #

alignment :: Int -> Int #

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

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

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

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

peek :: Ptr Int -> IO Int #

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

Num Int # 
Instance details

Defined in GHC.Internal.Num

Methods

(+) :: Int -> Int -> Int #

(-) :: Int -> Int -> Int #

(*) :: Int -> Int -> Int #

negate :: Int -> Int #

abs :: Int -> Int #

signum :: Int -> Int #

fromInteger :: Integer -> Int #

Read Int # 
Instance details

Defined in GHC.Internal.Read

Methods

readsPrec :: Int -> ReadS Int #

readList :: ReadS [Int] #

readPrec :: ReadPrec Int #

readListPrec :: ReadPrec [Int] #

Integral Int # 
Instance details

Defined in GHC.Internal.Real

Methods

quot :: Int -> Int -> Int #

rem :: Int -> Int -> Int #

div :: Int -> Int -> Int #

mod :: Int -> Int -> Int #

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

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

toInteger :: Int -> Integer #

Real Int # 
Instance details

Defined in GHC.Internal.Real

Methods

toRational :: Int -> Rational #

Show Int # 
Instance details

Defined in GHC.Internal.Show

Methods

showsPrec :: Int -> Int -> ShowS #

show :: Int -> String #

showList :: [Int] -> ShowS #

Eq Int # 
Instance details

Defined in GHC.Classes

Methods

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

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

Ord Int # 
Instance details

Defined in GHC.Classes

Methods

compare :: Int -> Int -> Ordering #

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

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

(>) :: Int -> Int -> Bool #

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

max :: Int -> Int -> Int #

min :: Int -> Int -> Int #

Eq1 (UInt :: Type -> Type) # 
Instance details

Defined in Data.Functor.Classes

Methods

liftEq :: (a -> b -> Bool) -> UInt a -> UInt b -> Bool

Ord1 (UInt :: Type -> Type) # 
Instance details

Defined in Data.Functor.Classes

Methods

liftCompare :: (a -> b -> Ordering) -> UInt a -> UInt b -> Ordering

Show1 (UInt :: Type -> Type) # 
Instance details

Defined in Data.Functor.Classes

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> UInt a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [UInt a] -> ShowS

Foldable (UInt :: Type -> Type) # 
Instance details

Defined in GHC.Internal.Data.Foldable

Methods

fold :: Monoid m => UInt m -> m #

foldMap :: Monoid m => (a -> m) -> UInt a -> m #

foldMap' :: Monoid m => (a -> m) -> UInt a -> m #

foldr :: (a -> b -> b) -> b -> UInt a -> b #

foldr' :: (a -> b -> b) -> b -> UInt a -> b #

foldl :: (b -> a -> b) -> b -> UInt a -> b #

foldl' :: (b -> a -> b) -> b -> UInt a -> b #

foldr1 :: (a -> a -> a) -> UInt a -> a #

foldl1 :: (a -> a -> a) -> UInt a -> a #

toList :: UInt a -> [a] #

null :: UInt a -> Bool #

length :: UInt a -> Int #

elem :: Eq a => a -> UInt a -> Bool #

maximum :: Ord a => UInt a -> a #

minimum :: Ord a => UInt a -> a #

sum :: Num a => UInt a -> a #

product :: Num a => UInt a -> a #

Traversable (UInt :: Type -> Type) # 
Instance details

Defined in GHC.Internal.Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> UInt a -> f (UInt b) #

sequenceA :: Applicative f => UInt (f a) -> f (UInt a) #

mapM :: Monad m => (a -> m b) -> UInt a -> m (UInt b) #

sequence :: Monad m => UInt (m a) -> m (UInt a) #

data Word #

Instances

Instances details
PrintfArg Word # 
Instance details

Defined in Text.Printf

Methods

formatArg :: Word -> FieldFormatter

parseFormat :: Word -> ModifierParser

Bits Word # 
Instance details

Defined in GHC.Internal.Bits

Methods

(.&.) :: Word -> Word -> Word #

(.|.) :: Word -> Word -> Word #

xor :: Word -> Word -> Word #

complement :: Word -> Word #

shift :: Word -> Int -> Word #

rotate :: Word -> Int -> Word #

zeroBits :: Word #

bit :: Int -> Word #

setBit :: Word -> Int -> Word #

clearBit :: Word -> Int -> Word #

complementBit :: Word -> Int -> Word #

testBit :: Word -> Int -> Bool #

bitSizeMaybe :: Word -> Maybe Int #

bitSize :: Word -> Int #

isSigned :: Word -> Bool #

shiftL :: Word -> Int -> Word #

unsafeShiftL :: Word -> Int -> Word #

shiftR :: Word -> Int -> Word #

unsafeShiftR :: Word -> Int -> Word #

rotateL :: Word -> Int -> Word #

rotateR :: Word -> Int -> Word #

popCount :: Word -> Int #

FiniteBits Word # 
Instance details

Defined in GHC.Internal.Bits

Methods

finiteBitSize :: Word -> Int #

countLeadingZeros :: Word -> Int #

countTrailingZeros :: Word -> Int #

Bounded Word # 
Instance details

Defined in GHC.Internal.Enum

Methods

minBound :: Word #

maxBound :: Word #

Enum Word # 
Instance details

Defined in GHC.Internal.Enum

Methods

succ :: Word -> Word #

pred :: Word -> Word #

toEnum :: Int -> Word #

fromEnum :: Word -> Int #

enumFrom :: Word -> [Word] #

enumFromThen :: Word -> Word -> [Word] #

enumFromTo :: Word -> Word -> [Word] #

enumFromThenTo :: Word -> Word -> Word -> [Word] #

Storable Word # 
Instance details

Defined in GHC.Internal.Foreign.Storable

Methods

sizeOf :: Word -> Int #

alignment :: Word -> Int #

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

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

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

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

peek :: Ptr Word -> IO Word #

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

Num Word # 
Instance details

Defined in GHC.Internal.Num

Methods

(+) :: Word -> Word -> Word #

(-) :: Word -> Word -> Word #

(*) :: Word -> Word -> Word #

negate :: Word -> Word #

abs :: Word -> Word #

signum :: Word -> Word #

fromInteger :: Integer -> Word #

Read Word # 
Instance details

Defined in GHC.Internal.Read

Methods

readsPrec :: Int -> ReadS Word #

readList :: ReadS [Word] #

readPrec :: ReadPrec Word #

readListPrec :: ReadPrec [Word] #

Integral Word # 
Instance details

Defined in GHC.Internal.Real

Methods

quot :: Word -> Word -> Word #

rem :: Word -> Word -> Word #

div :: Word -> Word -> Word #

mod :: Word -> Word -> Word #

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

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

toInteger :: Word -> Integer #

Real Word # 
Instance details

Defined in GHC.Internal.Real

Methods

toRational :: Word -> Rational #

Show Word # 
Instance details

Defined in GHC.Internal.Show

Methods

showsPrec :: Int -> Word -> ShowS #

show :: Word -> String #

showList :: [Word] -> ShowS #

Eq Word # 
Instance details

Defined in GHC.Classes

Methods

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

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

Ord Word # 
Instance details

Defined in GHC.Classes

Methods

compare :: Word -> Word -> Ordering #

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

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

(>) :: Word -> Word -> Bool #

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

max :: Word -> Word -> Word #

min :: Word -> Word -> Word #

Eq1 (UWord :: Type -> Type) # 
Instance details

Defined in Data.Functor.Classes

Methods

liftEq :: (a -> b -> Bool) -> UWord a -> UWord b -> Bool

Ord1 (UWord :: Type -> Type) # 
Instance details

Defined in Data.Functor.Classes

Methods

liftCompare :: (a -> b -> Ordering) -> UWord a -> UWord b -> Ordering

Show1 (UWord :: Type -> Type) # 
Instance details

Defined in Data.Functor.Classes

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> UWord a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [UWord a] -> ShowS

Foldable (UWord :: Type -> Type) # 
Instance details

Defined in GHC.Internal.Data.Foldable

Methods

fold :: Monoid m => UWord m -> m #

foldMap :: Monoid m => (a -> m) -> UWord a -> m #

foldMap' :: Monoid m => (a -> m) -> UWord a -> m #

foldr :: (a -> b -> b) -> b -> UWord a -> b #

foldr' :: (a -> b -> b) -> b -> UWord a -> b #

foldl :: (b -> a -> b) -> b -> UWord a -> b #

foldl' :: (b -> a -> b) -> b -> UWord a -> b #

foldr1 :: (a -> a -> a) -> UWord a -> a #

foldl1 :: (a -> a -> a) -> UWord a -> a #

toList :: UWord a -> [a] #

null :: UWord a -> Bool #

length :: UWord a -> Int #

elem :: Eq a => a -> UWord a -> Bool #

maximum :: Ord a => UWord a -> a #

minimum :: Ord a => UWord a -> a #

sum :: Num a => UWord a -> a #

product :: Num a => UWord a -> a #

Traversable (UWord :: Type -> Type) # 
Instance details

Defined in GHC.Internal.Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> UWord a -> f (UWord b) #

sequenceA :: Applicative f => UWord (f a) -> f (UWord a) #

mapM :: Monad m => (a -> m b) -> UWord a -> m (UWord b) #

sequence :: Monad m => UWord (m a) -> m (UWord a) #

module Foreign.Marshal.Compat