Safe Haskell	None
Language	Haskell2010

Haskus.Format.Binary.Word

Contents

Some C types
Unlifted

Description

Unsigned and signed words

Synopsis

Documentation

data Int8 :: * #

8-bit signed integer type

Instances

Bounded Int8
Methods minBound :: Int8 # maxBound :: Int8 #
Enum Int8
Methods succ :: Int8 -> Int8 # pred :: Int8 -> Int8 # toEnum :: Int -> Int8 # fromEnum :: Int8 -> Int # enumFrom :: Int8 -> [Int8] # enumFromThen :: Int8 -> Int8 -> [Int8] # enumFromTo :: Int8 -> Int8 -> [Int8] # enumFromThenTo :: Int8 -> Int8 -> Int8 -> [Int8] #
Eq Int8
Methods (==) :: Int8 -> Int8 -> Bool # (/=) :: Int8 -> Int8 -> Bool #
Integral Int8
Methods quot :: Int8 -> Int8 -> Int8 # rem :: Int8 -> Int8 -> Int8 # div :: Int8 -> Int8 -> Int8 # mod :: Int8 -> Int8 -> Int8 # quotRem :: Int8 -> Int8 -> (Int8, Int8) # divMod :: Int8 -> Int8 -> (Int8, Int8) # toInteger :: Int8 -> Integer #
Data Int8
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int8 -> c Int8 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int8 # toConstr :: Int8 -> Constr # dataTypeOf :: Int8 -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Int8) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int8) # gmapT :: (forall b. Data b => b -> b) -> Int8 -> Int8 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int8 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int8 -> r # gmapQ :: (forall d. Data d => d -> u) -> Int8 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int8 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int8 -> m Int8 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int8 -> m Int8 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int8 -> m Int8 #
Num Int8
Methods (+) :: Int8 -> Int8 -> Int8 # (-) :: Int8 -> Int8 -> Int8 # (*) :: Int8 -> Int8 -> Int8 # negate :: Int8 -> Int8 # abs :: Int8 -> Int8 # signum :: Int8 -> Int8 # fromInteger :: Integer -> Int8 #
Ord Int8
Methods compare :: Int8 -> Int8 -> Ordering # (<) :: Int8 -> Int8 -> Bool # (<=) :: Int8 -> Int8 -> Bool # (>) :: Int8 -> Int8 -> Bool # (>=) :: Int8 -> Int8 -> Bool # max :: Int8 -> Int8 -> Int8 # min :: Int8 -> Int8 -> Int8 #
Read Int8
Methods readsPrec :: Int -> ReadS Int8 # readList :: ReadS [Int8] # readPrec :: ReadPrec Int8 # readListPrec :: ReadPrec [Int8] #
Real Int8
Methods toRational :: Int8 -> Rational #
Show Int8
Methods showsPrec :: Int -> Int8 -> ShowS # show :: Int8 -> String # showList :: [Int8] -> ShowS #
Ix Int8
Methods range :: (Int8, Int8) -> [Int8] # index :: (Int8, Int8) -> Int8 -> Int # unsafeIndex :: (Int8, Int8) -> Int8 -> Int inRange :: (Int8, Int8) -> Int8 -> Bool # rangeSize :: (Int8, Int8) -> Int # unsafeRangeSize :: (Int8, Int8) -> Int
Storable Int8
Methods sizeOf :: Int8 -> Int # alignment :: Int8 -> Int # peekElemOff :: Ptr Int8 -> Int -> IO Int8 # pokeElemOff :: Ptr Int8 -> Int -> Int8 -> IO () # peekByteOff :: Ptr b -> Int -> IO Int8 # pokeByteOff :: Ptr b -> Int -> Int8 -> IO () # peek :: Ptr Int8 -> IO Int8 # poke :: Ptr Int8 -> Int8 -> IO () #
Bits Int8
Methods (.&.) :: Int8 -> Int8 -> Int8 # (.\|.) :: Int8 -> Int8 -> Int8 # xor :: Int8 -> Int8 -> Int8 # complement :: Int8 -> Int8 # shift :: Int8 -> Int -> Int8 # rotate :: Int8 -> Int -> Int8 # zeroBits :: Int8 # bit :: Int -> Int8 # setBit :: Int8 -> Int -> Int8 # clearBit :: Int8 -> Int -> Int8 # complementBit :: Int8 -> Int -> Int8 # testBit :: Int8 -> Int -> Bool # bitSizeMaybe :: Int8 -> Maybe Int # bitSize :: Int8 -> Int # isSigned :: Int8 -> Bool # shiftL :: Int8 -> Int -> Int8 # unsafeShiftL :: Int8 -> Int -> Int8 # shiftR :: Int8 -> Int -> Int8 # unsafeShiftR :: Int8 -> Int -> Int8 # rotateL :: Int8 -> Int -> Int8 # rotateR :: Int8 -> Int -> Int8 # popCount :: Int8 -> Int #
FiniteBits Int8
Methods finiteBitSize :: Int8 -> Int # countLeadingZeros :: Int8 -> Int # countTrailingZeros :: Int8 -> Int #
Storable Int8 Source #
Methods peekIO :: Ptr Int8 -> IO Int8 Source # pokeIO :: Ptr Int8 -> Int8 -> IO () Source # alignment :: Int8 -> Word Source # sizeOf :: Int8 -> Word Source #
StaticStorable Int8 Source #
Associated Types type SizeOf Int8 :: Nat Source # type Alignment Int8 :: Nat Source # Methods staticPeekIO :: Ptr Int8 -> IO Int8 Source # staticPokeIO :: Ptr Int8 -> Int8 -> IO () Source #
Field Int8 Source #
Methods fromField :: Integral b => Int8 -> b toField :: Integral b => b -> Int8
type SizeOf Int8 Source #
type SizeOf Int8 = 1
type Alignment Int8 Source #
type Alignment Int8 = 1

data Int16 :: * #

16-bit signed integer type

Instances

Bounded Int16
Methods minBound :: Int16 # maxBound :: Int16 #
Enum Int16
Methods succ :: Int16 -> Int16 # pred :: Int16 -> Int16 # toEnum :: Int -> Int16 # fromEnum :: Int16 -> Int # enumFrom :: Int16 -> [Int16] # enumFromThen :: Int16 -> Int16 -> [Int16] # enumFromTo :: Int16 -> Int16 -> [Int16] # enumFromThenTo :: Int16 -> Int16 -> Int16 -> [Int16] #
Eq Int16
Methods (==) :: Int16 -> Int16 -> Bool # (/=) :: Int16 -> Int16 -> Bool #
Integral Int16
Methods quot :: Int16 -> Int16 -> Int16 # rem :: Int16 -> Int16 -> Int16 # div :: Int16 -> Int16 -> Int16 # mod :: Int16 -> Int16 -> Int16 # quotRem :: Int16 -> Int16 -> (Int16, Int16) # divMod :: Int16 -> Int16 -> (Int16, Int16) # toInteger :: Int16 -> Integer #
Data Int16
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int16 -> c Int16 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int16 # toConstr :: Int16 -> Constr # dataTypeOf :: Int16 -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Int16) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int16) # gmapT :: (forall b. Data b => b -> b) -> Int16 -> Int16 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int16 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int16 -> r # gmapQ :: (forall d. Data d => d -> u) -> Int16 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int16 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int16 -> m Int16 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int16 -> m Int16 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int16 -> m Int16 #
Num Int16
Methods (+) :: Int16 -> Int16 -> Int16 # (-) :: Int16 -> Int16 -> Int16 # (*) :: Int16 -> Int16 -> Int16 # negate :: Int16 -> Int16 # abs :: Int16 -> Int16 # signum :: Int16 -> Int16 # fromInteger :: Integer -> Int16 #
Ord Int16
Methods compare :: Int16 -> Int16 -> Ordering # (<) :: Int16 -> Int16 -> Bool # (<=) :: Int16 -> Int16 -> Bool # (>) :: Int16 -> Int16 -> Bool # (>=) :: Int16 -> Int16 -> Bool # max :: Int16 -> Int16 -> Int16 # min :: Int16 -> Int16 -> Int16 #
Read Int16
Methods readsPrec :: Int -> ReadS Int16 # readList :: ReadS [Int16] # readPrec :: ReadPrec Int16 # readListPrec :: ReadPrec [Int16] #
Real Int16
Methods toRational :: Int16 -> Rational #
Show Int16
Methods showsPrec :: Int -> Int16 -> ShowS # show :: Int16 -> String # showList :: [Int16] -> ShowS #
Ix Int16
Methods range :: (Int16, Int16) -> [Int16] # index :: (Int16, Int16) -> Int16 -> Int # unsafeIndex :: (Int16, Int16) -> Int16 -> Int inRange :: (Int16, Int16) -> Int16 -> Bool # rangeSize :: (Int16, Int16) -> Int # unsafeRangeSize :: (Int16, Int16) -> Int
Storable Int16
Methods sizeOf :: Int16 -> Int # alignment :: Int16 -> Int # peekElemOff :: Ptr Int16 -> Int -> IO Int16 # pokeElemOff :: Ptr Int16 -> Int -> Int16 -> IO () # peekByteOff :: Ptr b -> Int -> IO Int16 # pokeByteOff :: Ptr b -> Int -> Int16 -> IO () # peek :: Ptr Int16 -> IO Int16 # poke :: Ptr Int16 -> Int16 -> IO () #
Bits Int16
Methods (.&.) :: Int16 -> Int16 -> Int16 # (.\|.) :: Int16 -> Int16 -> Int16 # xor :: Int16 -> Int16 -> Int16 # complement :: Int16 -> Int16 # shift :: Int16 -> Int -> Int16 # rotate :: Int16 -> Int -> Int16 # zeroBits :: Int16 # bit :: Int -> Int16 # setBit :: Int16 -> Int -> Int16 # clearBit :: Int16 -> Int -> Int16 # complementBit :: Int16 -> Int -> Int16 # testBit :: Int16 -> Int -> Bool # bitSizeMaybe :: Int16 -> Maybe Int # bitSize :: Int16 -> Int # isSigned :: Int16 -> Bool # shiftL :: Int16 -> Int -> Int16 # unsafeShiftL :: Int16 -> Int -> Int16 # shiftR :: Int16 -> Int -> Int16 # unsafeShiftR :: Int16 -> Int -> Int16 # rotateL :: Int16 -> Int -> Int16 # rotateR :: Int16 -> Int -> Int16 # popCount :: Int16 -> Int #
FiniteBits Int16
Methods finiteBitSize :: Int16 -> Int # countLeadingZeros :: Int16 -> Int # countTrailingZeros :: Int16 -> Int #
Storable Int16 Source #
Methods peekIO :: Ptr Int16 -> IO Int16 Source # pokeIO :: Ptr Int16 -> Int16 -> IO () Source # alignment :: Int16 -> Word Source # sizeOf :: Int16 -> Word Source #
StaticStorable Int16 Source #
Associated Types type SizeOf Int16 :: Nat Source # type Alignment Int16 :: Nat Source # Methods staticPeekIO :: Ptr Int16 -> IO Int16 Source # staticPokeIO :: Ptr Int16 -> Int16 -> IO () Source #
Field Int16 Source #
Methods fromField :: Integral b => Int16 -> b toField :: Integral b => b -> Int16
type SizeOf Int16 Source #
type SizeOf Int16 = 2
type Alignment Int16 Source #
type Alignment Int16 = 2

data Int32 :: * #

32-bit signed integer type

Instances

Bounded Int32
Methods minBound :: Int32 # maxBound :: Int32 #
Enum Int32
Methods succ :: Int32 -> Int32 # pred :: Int32 -> Int32 # toEnum :: Int -> Int32 # fromEnum :: Int32 -> Int # enumFrom :: Int32 -> [Int32] # enumFromThen :: Int32 -> Int32 -> [Int32] # enumFromTo :: Int32 -> Int32 -> [Int32] # enumFromThenTo :: Int32 -> Int32 -> Int32 -> [Int32] #
Eq Int32
Methods (==) :: Int32 -> Int32 -> Bool # (/=) :: Int32 -> Int32 -> Bool #
Integral Int32
Methods quot :: Int32 -> Int32 -> Int32 # rem :: Int32 -> Int32 -> Int32 # div :: Int32 -> Int32 -> Int32 # mod :: Int32 -> Int32 -> Int32 # quotRem :: Int32 -> Int32 -> (Int32, Int32) # divMod :: Int32 -> Int32 -> (Int32, Int32) # toInteger :: Int32 -> Integer #
Data Int32
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int32 -> c Int32 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int32 # toConstr :: Int32 -> Constr # dataTypeOf :: Int32 -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Int32) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int32) # gmapT :: (forall b. Data b => b -> b) -> Int32 -> Int32 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int32 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int32 -> r # gmapQ :: (forall d. Data d => d -> u) -> Int32 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int32 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int32 -> m Int32 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int32 -> m Int32 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int32 -> m Int32 #
Num Int32
Methods (+) :: Int32 -> Int32 -> Int32 # (-) :: Int32 -> Int32 -> Int32 # (*) :: Int32 -> Int32 -> Int32 # negate :: Int32 -> Int32 # abs :: Int32 -> Int32 # signum :: Int32 -> Int32 # fromInteger :: Integer -> Int32 #
Ord Int32
Methods compare :: Int32 -> Int32 -> Ordering # (<) :: Int32 -> Int32 -> Bool # (<=) :: Int32 -> Int32 -> Bool # (>) :: Int32 -> Int32 -> Bool # (>=) :: Int32 -> Int32 -> Bool # max :: Int32 -> Int32 -> Int32 # min :: Int32 -> Int32 -> Int32 #
Read Int32
Methods readsPrec :: Int -> ReadS Int32 # readList :: ReadS [Int32] # readPrec :: ReadPrec Int32 # readListPrec :: ReadPrec [Int32] #
Real Int32
Methods toRational :: Int32 -> Rational #
Show Int32
Methods showsPrec :: Int -> Int32 -> ShowS # show :: Int32 -> String # showList :: [Int32] -> ShowS #
Ix Int32
Methods range :: (Int32, Int32) -> [Int32] # index :: (Int32, Int32) -> Int32 -> Int # unsafeIndex :: (Int32, Int32) -> Int32 -> Int inRange :: (Int32, Int32) -> Int32 -> Bool # rangeSize :: (Int32, Int32) -> Int # unsafeRangeSize :: (Int32, Int32) -> Int
Storable Int32
Methods sizeOf :: Int32 -> Int # alignment :: Int32 -> Int # peekElemOff :: Ptr Int32 -> Int -> IO Int32 # pokeElemOff :: Ptr Int32 -> Int -> Int32 -> IO () # peekByteOff :: Ptr b -> Int -> IO Int32 # pokeByteOff :: Ptr b -> Int -> Int32 -> IO () # peek :: Ptr Int32 -> IO Int32 # poke :: Ptr Int32 -> Int32 -> IO () #
Bits Int32
Methods (.&.) :: Int32 -> Int32 -> Int32 # (.\|.) :: Int32 -> Int32 -> Int32 # xor :: Int32 -> Int32 -> Int32 # complement :: Int32 -> Int32 # shift :: Int32 -> Int -> Int32 # rotate :: Int32 -> Int -> Int32 # zeroBits :: Int32 # bit :: Int -> Int32 # setBit :: Int32 -> Int -> Int32 # clearBit :: Int32 -> Int -> Int32 # complementBit :: Int32 -> Int -> Int32 # testBit :: Int32 -> Int -> Bool # bitSizeMaybe :: Int32 -> Maybe Int # bitSize :: Int32 -> Int # isSigned :: Int32 -> Bool # shiftL :: Int32 -> Int -> Int32 # unsafeShiftL :: Int32 -> Int -> Int32 # shiftR :: Int32 -> Int -> Int32 # unsafeShiftR :: Int32 -> Int -> Int32 # rotateL :: Int32 -> Int -> Int32 # rotateR :: Int32 -> Int -> Int32 # popCount :: Int32 -> Int #
FiniteBits Int32
Methods finiteBitSize :: Int32 -> Int # countLeadingZeros :: Int32 -> Int # countTrailingZeros :: Int32 -> Int #
Storable Int32 Source #
Methods peekIO :: Ptr Int32 -> IO Int32 Source # pokeIO :: Ptr Int32 -> Int32 -> IO () Source # alignment :: Int32 -> Word Source # sizeOf :: Int32 -> Word Source #
StaticStorable Int32 Source #
Associated Types type SizeOf Int32 :: Nat Source # type Alignment Int32 :: Nat Source # Methods staticPeekIO :: Ptr Int32 -> IO Int32 Source # staticPokeIO :: Ptr Int32 -> Int32 -> IO () Source #
Field Int32 Source #
Methods fromField :: Integral b => Int32 -> b toField :: Integral b => b -> Int32
type SizeOf Int32 Source #
type SizeOf Int32 = 4
type Alignment Int32 Source #
type Alignment Int32 = 4

data Int64 :: * #

64-bit signed integer type

Instances

Bounded Int64
Methods minBound :: Int64 # maxBound :: Int64 #
Enum Int64
Methods succ :: Int64 -> Int64 # pred :: Int64 -> Int64 # toEnum :: Int -> Int64 # fromEnum :: Int64 -> Int # enumFrom :: Int64 -> [Int64] # enumFromThen :: Int64 -> Int64 -> [Int64] # enumFromTo :: Int64 -> Int64 -> [Int64] # enumFromThenTo :: Int64 -> Int64 -> Int64 -> [Int64] #
Eq Int64
Methods (==) :: Int64 -> Int64 -> Bool # (/=) :: Int64 -> Int64 -> Bool #
Integral Int64
Methods quot :: Int64 -> Int64 -> Int64 # rem :: Int64 -> Int64 -> Int64 # div :: Int64 -> Int64 -> Int64 # mod :: Int64 -> Int64 -> Int64 # quotRem :: Int64 -> Int64 -> (Int64, Int64) # divMod :: Int64 -> Int64 -> (Int64, Int64) # toInteger :: Int64 -> Integer #
Data Int64
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int64 -> c Int64 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int64 # toConstr :: Int64 -> Constr # dataTypeOf :: Int64 -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Int64) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int64) # gmapT :: (forall b. Data b => b -> b) -> Int64 -> Int64 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int64 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int64 -> r # gmapQ :: (forall d. Data d => d -> u) -> Int64 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int64 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int64 -> m Int64 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int64 -> m Int64 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int64 -> m Int64 #
Num Int64
Methods (+) :: Int64 -> Int64 -> Int64 # (-) :: Int64 -> Int64 -> Int64 # (*) :: Int64 -> Int64 -> Int64 # negate :: Int64 -> Int64 # abs :: Int64 -> Int64 # signum :: Int64 -> Int64 # fromInteger :: Integer -> Int64 #
Ord Int64
Methods compare :: Int64 -> Int64 -> Ordering # (<) :: Int64 -> Int64 -> Bool # (<=) :: Int64 -> Int64 -> Bool # (>) :: Int64 -> Int64 -> Bool # (>=) :: Int64 -> Int64 -> Bool # max :: Int64 -> Int64 -> Int64 # min :: Int64 -> Int64 -> Int64 #
Read Int64
Methods readsPrec :: Int -> ReadS Int64 # readList :: ReadS [Int64] # readPrec :: ReadPrec Int64 # readListPrec :: ReadPrec [Int64] #
Real Int64
Methods toRational :: Int64 -> Rational #
Show Int64
Methods showsPrec :: Int -> Int64 -> ShowS # show :: Int64 -> String # showList :: [Int64] -> ShowS #
Ix Int64
Methods range :: (Int64, Int64) -> [Int64] # index :: (Int64, Int64) -> Int64 -> Int # unsafeIndex :: (Int64, Int64) -> Int64 -> Int inRange :: (Int64, Int64) -> Int64 -> Bool # rangeSize :: (Int64, Int64) -> Int # unsafeRangeSize :: (Int64, Int64) -> Int
Storable Int64
Methods sizeOf :: Int64 -> Int # alignment :: Int64 -> Int # peekElemOff :: Ptr Int64 -> Int -> IO Int64 # pokeElemOff :: Ptr Int64 -> Int -> Int64 -> IO () # peekByteOff :: Ptr b -> Int -> IO Int64 # pokeByteOff :: Ptr b -> Int -> Int64 -> IO () # peek :: Ptr Int64 -> IO Int64 # poke :: Ptr Int64 -> Int64 -> IO () #
Bits Int64
Methods (.&.) :: Int64 -> Int64 -> Int64 # (.\|.) :: Int64 -> Int64 -> Int64 # xor :: Int64 -> Int64 -> Int64 # complement :: Int64 -> Int64 # shift :: Int64 -> Int -> Int64 # rotate :: Int64 -> Int -> Int64 # zeroBits :: Int64 # bit :: Int -> Int64 # setBit :: Int64 -> Int -> Int64 # clearBit :: Int64 -> Int -> Int64 # complementBit :: Int64 -> Int -> Int64 # testBit :: Int64 -> Int -> Bool # bitSizeMaybe :: Int64 -> Maybe Int # bitSize :: Int64 -> Int # isSigned :: Int64 -> Bool # shiftL :: Int64 -> Int -> Int64 # unsafeShiftL :: Int64 -> Int -> Int64 # shiftR :: Int64 -> Int -> Int64 # unsafeShiftR :: Int64 -> Int -> Int64 # rotateL :: Int64 -> Int -> Int64 # rotateR :: Int64 -> Int -> Int64 # popCount :: Int64 -> Int #
FiniteBits Int64
Methods finiteBitSize :: Int64 -> Int # countLeadingZeros :: Int64 -> Int # countTrailingZeros :: Int64 -> Int #
Storable Int64 Source #
Methods peekIO :: Ptr Int64 -> IO Int64 Source # pokeIO :: Ptr Int64 -> Int64 -> IO () Source # alignment :: Int64 -> Word Source # sizeOf :: Int64 -> Word Source #
StaticStorable Int64 Source #
Associated Types type SizeOf Int64 :: Nat Source # type Alignment Int64 :: Nat Source # Methods staticPeekIO :: Ptr Int64 -> IO Int64 Source # staticPokeIO :: Ptr Int64 -> Int64 -> IO () Source #
Field Int64 Source #
Methods fromField :: Integral b => Int64 -> b toField :: Integral b => b -> Int64
type SizeOf Int64 Source #
type SizeOf Int64 = 8
type Alignment Int64 Source #
type Alignment Int64 = 8

type family BitSize a :: Nat Source #

Bit size

Instances

type BitSize Word8 Source #
type BitSize Word8 = 8
type BitSize Word16 Source #
type BitSize Word16 = 16
type BitSize Word32 Source #
type BitSize Word32 = 32
type BitSize Word64 Source #
type BitSize Word64 = 64

type family WordAtLeast (n :: Nat) where ... Source #

Return a Word with at least n bits

Equations

WordAtLeast n = If (n <=? 8) Word8 (If (n <=? 16) Word16 (If (n <=? 32) Word32 (If (n <=? 64) Word64 (TypeError (Text "Cannot find Word with size " :<>: ShowType n)))))

Some C types

newtype CSize :: * #

Haskell type representing the C size_t type.

Constructors

CSize Word64

Instances

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

data CUShort :: * #

Haskell type representing the C unsigned short type.

Instances

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

data CShort :: * #

Haskell type representing the C short type.

Instances

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

data CUInt :: * #

Haskell type representing the C unsigned int type.

Instances

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

data CInt :: * #

Haskell type representing the C int type.

Instances

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

data CULong :: * #

Haskell type representing the C unsigned long type.

Instances

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

data CLong :: * #

Haskell type representing the C long type.

Instances

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