OpenAFP.Internals.Binary

Documentation

data N0

Constructors

N0

Instances

Bounded N0

Methods

minBound :: N0

maxBound :: N0

Enum N0

Methods

succ :: N0 -> N0

pred :: N0 -> N0

toEnum :: Int -> N0

fromEnum :: N0 -> Int

enumFrom :: N0 -> [N0]

enumFromThen :: N0 -> N0 -> [N0]

enumFromTo :: N0 -> N0 -> [N0]

enumFromThenTo :: N0 -> N0 -> N0 -> [N0]

Eq N0

Methods

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

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

Num N0

Methods

(+) :: N0 -> N0 -> N0

(-) :: N0 -> N0 -> N0

(*) :: N0 -> N0 -> N0

negate :: N0 -> N0

abs :: N0 -> N0

signum :: N0 -> N0

fromInteger :: Integer -> N0

Ord N0

Methods

compare :: N0 -> N0 -> Ordering

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

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

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

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

max :: N0 -> N0 -> N0

min :: N0 -> N0 -> N0

Show N0

Methods

showsPrec :: Int -> N0 -> ShowS

show :: N0 -> String

showList :: [N0] -> ShowS

Ix N0

Methods

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

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

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

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

rangeSize :: (N0, N0) -> Int

unsafeRangeSize :: (N0, N0) -> Int

Binary N0

Methods

put :: N0 -> Put

get :: Get N0

putList :: [N0] -> Put

newtype N1

Constructors

N1

Fields

• fromN1 :: Word8

Instances

Bounded N1

Methods

minBound :: N1

maxBound :: N1

Enum N1

Methods

succ :: N1 -> N1

pred :: N1 -> N1

toEnum :: Int -> N1

fromEnum :: N1 -> Int

enumFrom :: N1 -> [N1]

enumFromThen :: N1 -> N1 -> [N1]

enumFromTo :: N1 -> N1 -> [N1]

enumFromThenTo :: N1 -> N1 -> N1 -> [N1]

Eq N1

Methods

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

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

Integral N1

Methods

quot :: N1 -> N1 -> N1

rem :: N1 -> N1 -> N1

div :: N1 -> N1 -> N1

mod :: N1 -> N1 -> N1

quotRem :: N1 -> N1 -> (N1, N1)

divMod :: N1 -> N1 -> (N1, N1)

toInteger :: N1 -> Integer

Num N1

Methods

(+) :: N1 -> N1 -> N1

(-) :: N1 -> N1 -> N1

(*) :: N1 -> N1 -> N1

negate :: N1 -> N1

abs :: N1 -> N1

signum :: N1 -> N1

fromInteger :: Integer -> N1

Ord N1

Methods

compare :: N1 -> N1 -> Ordering

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

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

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

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

max :: N1 -> N1 -> N1

min :: N1 -> N1 -> N1

Real N1

Methods

toRational :: N1 -> Rational

Show N1

Methods

showsPrec :: Int -> N1 -> ShowS

show :: N1 -> String

showList :: [N1] -> ShowS

Ix N1

Methods

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

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

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

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

rangeSize :: (N1, N1) -> Int

unsafeRangeSize :: (N1, N1) -> Int

Storable N1

Methods

sizeOf :: N1 -> Int

alignment :: N1 -> Int

peekElemOff :: Ptr N1 -> Int -> IO N1

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

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

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

peek :: Ptr N1 -> IO N1

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

Bits N1

Methods

(.&.) :: N1 -> N1 -> N1

(.|.) :: N1 -> N1 -> N1

xor :: N1 -> N1 -> N1

complement :: N1 -> N1

shift :: N1 -> Int -> N1

rotate :: N1 -> Int -> N1

zeroBits :: N1

bit :: Int -> N1

setBit :: N1 -> Int -> N1

clearBit :: N1 -> Int -> N1

complementBit :: N1 -> Int -> N1

testBit :: N1 -> Int -> Bool

bitSizeMaybe :: N1 -> Maybe Int

bitSize :: N1 -> Int

isSigned :: N1 -> Bool

shiftL :: N1 -> Int -> N1

unsafeShiftL :: N1 -> Int -> N1

shiftR :: N1 -> Int -> N1

unsafeShiftR :: N1 -> Int -> N1

rotateL :: N1 -> Int -> N1

rotateR :: N1 -> Int -> N1

popCount :: N1 -> Int

Binary N1

Methods

put :: N1 -> Put

get :: Get N1

putList :: [N1] -> Put

Hashable N1

Methods

hashWithSalt :: Int -> N1 -> Int

hash :: N1 -> Int

Rec N1

Methods

recGet :: Get N1

recPut :: N1 -> Put

recSizeOf :: N1 -> Int

recView :: N1 -> ViewRecord

recType :: N1 -> Int

newtype N2

Constructors

N2

Fields

• fromN2 :: Word16

Instances

Bounded N2

Methods

minBound :: N2

maxBound :: N2

Enum N2

Methods

succ :: N2 -> N2

pred :: N2 -> N2

toEnum :: Int -> N2

fromEnum :: N2 -> Int

enumFrom :: N2 -> [N2]

enumFromThen :: N2 -> N2 -> [N2]

enumFromTo :: N2 -> N2 -> [N2]

enumFromThenTo :: N2 -> N2 -> N2 -> [N2]

Eq N2

Methods

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

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

Integral N2

Methods

quot :: N2 -> N2 -> N2

rem :: N2 -> N2 -> N2

div :: N2 -> N2 -> N2

mod :: N2 -> N2 -> N2

quotRem :: N2 -> N2 -> (N2, N2)

divMod :: N2 -> N2 -> (N2, N2)

toInteger :: N2 -> Integer

Num N2

Methods

(+) :: N2 -> N2 -> N2

(-) :: N2 -> N2 -> N2

(*) :: N2 -> N2 -> N2

negate :: N2 -> N2

abs :: N2 -> N2

signum :: N2 -> N2

fromInteger :: Integer -> N2

Ord N2

Methods

compare :: N2 -> N2 -> Ordering

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

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

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

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

max :: N2 -> N2 -> N2

min :: N2 -> N2 -> N2

Real N2

Methods

toRational :: N2 -> Rational

Show N2

Methods

showsPrec :: Int -> N2 -> ShowS

show :: N2 -> String

showList :: [N2] -> ShowS

Storable N2

Methods

sizeOf :: N2 -> Int

alignment :: N2 -> Int

peekElemOff :: Ptr N2 -> Int -> IO N2

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

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

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

peek :: Ptr N2 -> IO N2

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

Bits N2

Methods

(.&.) :: N2 -> N2 -> N2

(.|.) :: N2 -> N2 -> N2

xor :: N2 -> N2 -> N2

complement :: N2 -> N2

shift :: N2 -> Int -> N2

rotate :: N2 -> Int -> N2

zeroBits :: N2

bit :: Int -> N2

setBit :: N2 -> Int -> N2

clearBit :: N2 -> Int -> N2

complementBit :: N2 -> Int -> N2

testBit :: N2 -> Int -> Bool

bitSizeMaybe :: N2 -> Maybe Int

bitSize :: N2 -> Int

isSigned :: N2 -> Bool

shiftL :: N2 -> Int -> N2

unsafeShiftL :: N2 -> Int -> N2

shiftR :: N2 -> Int -> N2

unsafeShiftR :: N2 -> Int -> N2

rotateL :: N2 -> Int -> N2

rotateR :: N2 -> Int -> N2

popCount :: N2 -> Int

Binary N2

Methods

put :: N2 -> Put

get :: Get N2

putList :: [N2] -> Put

Hashable N2

Methods

hashWithSalt :: Int -> N2 -> Int

hash :: N2 -> Int

newtype N3

Constructors

N3

Fields

• fromN3 :: Word32

Instances

Bounded N3

Methods

minBound :: N3

maxBound :: N3

Enum N3

Methods

succ :: N3 -> N3

pred :: N3 -> N3

toEnum :: Int -> N3

fromEnum :: N3 -> Int

enumFrom :: N3 -> [N3]

enumFromThen :: N3 -> N3 -> [N3]

enumFromTo :: N3 -> N3 -> [N3]

enumFromThenTo :: N3 -> N3 -> N3 -> [N3]

Eq N3

Methods

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

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

Integral N3

Methods

quot :: N3 -> N3 -> N3

rem :: N3 -> N3 -> N3

div :: N3 -> N3 -> N3

mod :: N3 -> N3 -> N3

quotRem :: N3 -> N3 -> (N3, N3)

divMod :: N3 -> N3 -> (N3, N3)

toInteger :: N3 -> Integer

Num N3

Methods

(+) :: N3 -> N3 -> N3

(-) :: N3 -> N3 -> N3

(*) :: N3 -> N3 -> N3

negate :: N3 -> N3

abs :: N3 -> N3

signum :: N3 -> N3

fromInteger :: Integer -> N3

Ord N3

Methods

compare :: N3 -> N3 -> Ordering

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

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

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

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

max :: N3 -> N3 -> N3

min :: N3 -> N3 -> N3

Real N3

Methods

toRational :: N3 -> Rational

Show N3

Methods

showsPrec :: Int -> N3 -> ShowS

show :: N3 -> String

showList :: [N3] -> ShowS

Storable N3

Methods

sizeOf :: N3 -> Int

alignment :: N3 -> Int

peekElemOff :: Ptr N3 -> Int -> IO N3

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

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

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

peek :: Ptr N3 -> IO N3

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

Bits N3

Methods

(.&.) :: N3 -> N3 -> N3

(.|.) :: N3 -> N3 -> N3

xor :: N3 -> N3 -> N3

complement :: N3 -> N3

shift :: N3 -> Int -> N3

rotate :: N3 -> Int -> N3

zeroBits :: N3

bit :: Int -> N3

setBit :: N3 -> Int -> N3

clearBit :: N3 -> Int -> N3

complementBit :: N3 -> Int -> N3

testBit :: N3 -> Int -> Bool

bitSizeMaybe :: N3 -> Maybe Int

bitSize :: N3 -> Int

isSigned :: N3 -> Bool

shiftL :: N3 -> Int -> N3

unsafeShiftL :: N3 -> Int -> N3

shiftR :: N3 -> Int -> N3

unsafeShiftR :: N3 -> Int -> N3

rotateL :: N3 -> Int -> N3

rotateR :: N3 -> Int -> N3

popCount :: N3 -> Int

Binary N3

Methods

put :: N3 -> Put

get :: Get N3

putList :: [N3] -> Put

Hashable N3

Methods

hashWithSalt :: Int -> N3 -> Int

hash :: N3 -> Int

newtype N4

Constructors

N4

Fields

• fromN4 :: Word32

Instances

Bounded N4

Methods

minBound :: N4

maxBound :: N4

Enum N4

Methods

succ :: N4 -> N4

pred :: N4 -> N4

toEnum :: Int -> N4

fromEnum :: N4 -> Int

enumFrom :: N4 -> [N4]

enumFromThen :: N4 -> N4 -> [N4]

enumFromTo :: N4 -> N4 -> [N4]

enumFromThenTo :: N4 -> N4 -> N4 -> [N4]

Eq N4

Methods

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

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

Integral N4

Methods

quot :: N4 -> N4 -> N4

rem :: N4 -> N4 -> N4

div :: N4 -> N4 -> N4

mod :: N4 -> N4 -> N4

quotRem :: N4 -> N4 -> (N4, N4)

divMod :: N4 -> N4 -> (N4, N4)

toInteger :: N4 -> Integer

Num N4

Methods

(+) :: N4 -> N4 -> N4

(-) :: N4 -> N4 -> N4

(*) :: N4 -> N4 -> N4

negate :: N4 -> N4

abs :: N4 -> N4

signum :: N4 -> N4

fromInteger :: Integer -> N4

Ord N4

Methods

compare :: N4 -> N4 -> Ordering

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

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

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

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

max :: N4 -> N4 -> N4

min :: N4 -> N4 -> N4

Real N4

Methods

toRational :: N4 -> Rational

Show N4

Methods

showsPrec :: Int -> N4 -> ShowS

show :: N4 -> String

showList :: [N4] -> ShowS

Storable N4

Methods

sizeOf :: N4 -> Int

alignment :: N4 -> Int

peekElemOff :: Ptr N4 -> Int -> IO N4

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

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

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

peek :: Ptr N4 -> IO N4

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

Bits N4

Methods

(.&.) :: N4 -> N4 -> N4

(.|.) :: N4 -> N4 -> N4

xor :: N4 -> N4 -> N4

complement :: N4 -> N4

shift :: N4 -> Int -> N4

rotate :: N4 -> Int -> N4

zeroBits :: N4

bit :: Int -> N4

setBit :: N4 -> Int -> N4

clearBit :: N4 -> Int -> N4

complementBit :: N4 -> Int -> N4

testBit :: N4 -> Int -> Bool

bitSizeMaybe :: N4 -> Maybe Int

bitSize :: N4 -> Int

isSigned :: N4 -> Bool

shiftL :: N4 -> Int -> N4

unsafeShiftL :: N4 -> Int -> N4

shiftR :: N4 -> Int -> N4

unsafeShiftR :: N4 -> Int -> N4

rotateL :: N4 -> Int -> N4

rotateR :: N4 -> Int -> N4

popCount :: N4 -> Int

Binary N4

Methods

put :: N4 -> Put

get :: Get N4

putList :: [N4] -> Put

Hashable N4

Methods

hashWithSalt :: Int -> N4 -> Int

hash :: N4 -> Int

newtype I1

Constructors

I1 Int8

Instances

Enum I1

Methods

succ :: I1 -> I1

pred :: I1 -> I1

toEnum :: Int -> I1

fromEnum :: I1 -> Int

enumFrom :: I1 -> [I1]

enumFromThen :: I1 -> I1 -> [I1]

enumFromTo :: I1 -> I1 -> [I1]

enumFromThenTo :: I1 -> I1 -> I1 -> [I1]

Eq I1

Methods

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

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

Integral I1

Methods

quot :: I1 -> I1 -> I1

rem :: I1 -> I1 -> I1

div :: I1 -> I1 -> I1

mod :: I1 -> I1 -> I1

quotRem :: I1 -> I1 -> (I1, I1)

divMod :: I1 -> I1 -> (I1, I1)

toInteger :: I1 -> Integer

Num I1

Methods

(+) :: I1 -> I1 -> I1

(-) :: I1 -> I1 -> I1

(*) :: I1 -> I1 -> I1

negate :: I1 -> I1

abs :: I1 -> I1

signum :: I1 -> I1

fromInteger :: Integer -> I1

Ord I1

Methods

compare :: I1 -> I1 -> Ordering

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

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

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

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

max :: I1 -> I1 -> I1

min :: I1 -> I1 -> I1

Real I1

Methods

toRational :: I1 -> Rational

Show I1

Methods

showsPrec :: Int -> I1 -> ShowS

show :: I1 -> String

showList :: [I1] -> ShowS

Ix I1

Methods

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

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

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

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

rangeSize :: (I1, I1) -> Int

unsafeRangeSize :: (I1, I1) -> Int

Storable I1

Methods

sizeOf :: I1 -> Int

alignment :: I1 -> Int

peekElemOff :: Ptr I1 -> Int -> IO I1

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

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

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

peek :: Ptr I1 -> IO I1

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

Bits I1

Methods

(.&.) :: I1 -> I1 -> I1

(.|.) :: I1 -> I1 -> I1

xor :: I1 -> I1 -> I1

complement :: I1 -> I1

shift :: I1 -> Int -> I1

rotate :: I1 -> Int -> I1

zeroBits :: I1

bit :: Int -> I1

setBit :: I1 -> Int -> I1

clearBit :: I1 -> Int -> I1

complementBit :: I1 -> Int -> I1

testBit :: I1 -> Int -> Bool

bitSizeMaybe :: I1 -> Maybe Int

bitSize :: I1 -> Int

isSigned :: I1 -> Bool

shiftL :: I1 -> Int -> I1

unsafeShiftL :: I1 -> Int -> I1

shiftR :: I1 -> Int -> I1

unsafeShiftR :: I1 -> Int -> I1

rotateL :: I1 -> Int -> I1

rotateR :: I1 -> Int -> I1

popCount :: I1 -> Int

Binary I1

Methods

put :: I1 -> Put

get :: Get I1

putList :: [I1] -> Put

Hashable I1

Methods

hashWithSalt :: Int -> I1 -> Int

hash :: I1 -> Int

newtype I2

Constructors

I2 Int16

Instances

Enum I2

Methods

succ :: I2 -> I2

pred :: I2 -> I2

toEnum :: Int -> I2

fromEnum :: I2 -> Int

enumFrom :: I2 -> [I2]

enumFromThen :: I2 -> I2 -> [I2]

enumFromTo :: I2 -> I2 -> [I2]

enumFromThenTo :: I2 -> I2 -> I2 -> [I2]

Eq I2

Methods

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

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

Integral I2

Methods

quot :: I2 -> I2 -> I2

rem :: I2 -> I2 -> I2

div :: I2 -> I2 -> I2

mod :: I2 -> I2 -> I2

quotRem :: I2 -> I2 -> (I2, I2)

divMod :: I2 -> I2 -> (I2, I2)

toInteger :: I2 -> Integer

Num I2

Methods

(+) :: I2 -> I2 -> I2

(-) :: I2 -> I2 -> I2

(*) :: I2 -> I2 -> I2

negate :: I2 -> I2

abs :: I2 -> I2

signum :: I2 -> I2

fromInteger :: Integer -> I2

Ord I2

Methods

compare :: I2 -> I2 -> Ordering

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

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

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

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

max :: I2 -> I2 -> I2

min :: I2 -> I2 -> I2

Real I2

Methods

toRational :: I2 -> Rational

Show I2

Methods

showsPrec :: Int -> I2 -> ShowS

show :: I2 -> String

showList :: [I2] -> ShowS

Ix I2

Methods

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

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

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

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

rangeSize :: (I2, I2) -> Int

unsafeRangeSize :: (I2, I2) -> Int

Storable I2

Methods

sizeOf :: I2 -> Int

alignment :: I2 -> Int

peekElemOff :: Ptr I2 -> Int -> IO I2

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

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

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

peek :: Ptr I2 -> IO I2

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

Bits I2

Methods

(.&.) :: I2 -> I2 -> I2

(.|.) :: I2 -> I2 -> I2

xor :: I2 -> I2 -> I2

complement :: I2 -> I2

shift :: I2 -> Int -> I2

rotate :: I2 -> Int -> I2

zeroBits :: I2

bit :: Int -> I2

setBit :: I2 -> Int -> I2

clearBit :: I2 -> Int -> I2

complementBit :: I2 -> Int -> I2

testBit :: I2 -> Int -> Bool

bitSizeMaybe :: I2 -> Maybe Int

bitSize :: I2 -> Int

isSigned :: I2 -> Bool

shiftL :: I2 -> Int -> I2

unsafeShiftL :: I2 -> Int -> I2

shiftR :: I2 -> Int -> I2

unsafeShiftR :: I2 -> Int -> I2

rotateL :: I2 -> Int -> I2

rotateR :: I2 -> Int -> I2

popCount :: I2 -> Int

Binary I2

Methods

put :: I2 -> Put

get :: Get I2

putList :: [I2] -> Put

Hashable I2

Methods

hashWithSalt :: Int -> I2 -> Int

hash :: I2 -> Int

newtype I4

Constructors

I4 Int32

Instances

Enum I4

Methods

succ :: I4 -> I4

pred :: I4 -> I4

toEnum :: Int -> I4

fromEnum :: I4 -> Int

enumFrom :: I4 -> [I4]

enumFromThen :: I4 -> I4 -> [I4]

enumFromTo :: I4 -> I4 -> [I4]

enumFromThenTo :: I4 -> I4 -> I4 -> [I4]

Eq I4

Methods

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

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

Integral I4

Methods

quot :: I4 -> I4 -> I4

rem :: I4 -> I4 -> I4

div :: I4 -> I4 -> I4

mod :: I4 -> I4 -> I4

quotRem :: I4 -> I4 -> (I4, I4)

divMod :: I4 -> I4 -> (I4, I4)

toInteger :: I4 -> Integer

Num I4

Methods

(+) :: I4 -> I4 -> I4

(-) :: I4 -> I4 -> I4

(*) :: I4 -> I4 -> I4

negate :: I4 -> I4

abs :: I4 -> I4

signum :: I4 -> I4

fromInteger :: Integer -> I4

Ord I4

Methods

compare :: I4 -> I4 -> Ordering

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

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

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

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

max :: I4 -> I4 -> I4

min :: I4 -> I4 -> I4

Real I4

Methods

toRational :: I4 -> Rational

Show I4

Methods

showsPrec :: Int -> I4 -> ShowS

show :: I4 -> String

showList :: [I4] -> ShowS

Ix I4

Methods

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

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

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

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

rangeSize :: (I4, I4) -> Int

unsafeRangeSize :: (I4, I4) -> Int

Storable I4

Methods

sizeOf :: I4 -> Int

alignment :: I4 -> Int

peekElemOff :: Ptr I4 -> Int -> IO I4

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

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

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

peek :: Ptr I4 -> IO I4

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

Bits I4

Methods

(.&.) :: I4 -> I4 -> I4

(.|.) :: I4 -> I4 -> I4

xor :: I4 -> I4 -> I4

complement :: I4 -> I4

shift :: I4 -> Int -> I4

rotate :: I4 -> Int -> I4

zeroBits :: I4

bit :: Int -> I4

setBit :: I4 -> Int -> I4

clearBit :: I4 -> Int -> I4

complementBit :: I4 -> Int -> I4

testBit :: I4 -> Int -> Bool

bitSizeMaybe :: I4 -> Maybe Int

bitSize :: I4 -> Int

isSigned :: I4 -> Bool

shiftL :: I4 -> Int -> I4

unsafeShiftL :: I4 -> Int -> I4

shiftR :: I4 -> Int -> I4

unsafeShiftR :: I4 -> Int -> I4

rotateL :: I4 -> Int -> I4

rotateR :: I4 -> Int -> I4

popCount :: I4 -> Int

Binary I4

Methods

put :: I4 -> Put

get :: Get I4

putList :: [I4] -> Put

Hashable I4

Methods

hashWithSalt :: Int -> I4 -> Int

hash :: I4 -> Int

newtype I8

Constructors

I8 Int64

Instances

Enum I8

Methods

succ :: I8 -> I8

pred :: I8 -> I8

toEnum :: Int -> I8

fromEnum :: I8 -> Int

enumFrom :: I8 -> [I8]

enumFromThen :: I8 -> I8 -> [I8]

enumFromTo :: I8 -> I8 -> [I8]

enumFromThenTo :: I8 -> I8 -> I8 -> [I8]

Eq I8

Methods

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

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

Integral I8

Methods

quot :: I8 -> I8 -> I8

rem :: I8 -> I8 -> I8

div :: I8 -> I8 -> I8

mod :: I8 -> I8 -> I8

quotRem :: I8 -> I8 -> (I8, I8)

divMod :: I8 -> I8 -> (I8, I8)

toInteger :: I8 -> Integer

Num I8

Methods

(+) :: I8 -> I8 -> I8

(-) :: I8 -> I8 -> I8

(*) :: I8 -> I8 -> I8

negate :: I8 -> I8

abs :: I8 -> I8

signum :: I8 -> I8

fromInteger :: Integer -> I8

Ord I8

Methods

compare :: I8 -> I8 -> Ordering

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

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

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

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

max :: I8 -> I8 -> I8

min :: I8 -> I8 -> I8

Real I8

Methods

toRational :: I8 -> Rational

Show I8

Methods

showsPrec :: Int -> I8 -> ShowS

show :: I8 -> String

showList :: [I8] -> ShowS

Ix I8

Methods

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

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

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

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

rangeSize :: (I8, I8) -> Int

unsafeRangeSize :: (I8, I8) -> Int

Storable I8

Methods

sizeOf :: I8 -> Int

alignment :: I8 -> Int

peekElemOff :: Ptr I8 -> Int -> IO I8

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

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

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

peek :: Ptr I8 -> IO I8

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

Bits I8

Methods

(.&.) :: I8 -> I8 -> I8

(.|.) :: I8 -> I8 -> I8

xor :: I8 -> I8 -> I8

complement :: I8 -> I8

shift :: I8 -> Int -> I8

rotate :: I8 -> Int -> I8

zeroBits :: I8

bit :: Int -> I8

setBit :: I8 -> Int -> I8

clearBit :: I8 -> Int -> I8

complementBit :: I8 -> Int -> I8

testBit :: I8 -> Int -> Bool

bitSizeMaybe :: I8 -> Maybe Int

bitSize :: I8 -> Int

isSigned :: I8 -> Bool

shiftL :: I8 -> Int -> I8

unsafeShiftL :: I8 -> Int -> I8

shiftR :: I8 -> Int -> I8

unsafeShiftR :: I8 -> Int -> I8

rotateL :: I8 -> Int -> I8

rotateR :: I8 -> Int -> I8

popCount :: I8 -> Int

Binary I8

Methods

put :: I8 -> Put

get :: Get I8

putList :: [I8] -> Put

Hashable I8

Methods

hashWithSalt :: Int -> I8 -> Int

hash :: I8 -> Int

newtype A1

Constructors

A1 Word8

Instances

Bounded A1

Methods

minBound :: A1

maxBound :: A1

Enum A1

Methods

succ :: A1 -> A1

pred :: A1 -> A1

toEnum :: Int -> A1

fromEnum :: A1 -> Int

enumFrom :: A1 -> [A1]

enumFromThen :: A1 -> A1 -> [A1]

enumFromTo :: A1 -> A1 -> [A1]

enumFromThenTo :: A1 -> A1 -> A1 -> [A1]

Eq A1

Methods

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

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

Integral A1

Methods

quot :: A1 -> A1 -> A1

rem :: A1 -> A1 -> A1

div :: A1 -> A1 -> A1

mod :: A1 -> A1 -> A1

quotRem :: A1 -> A1 -> (A1, A1)

divMod :: A1 -> A1 -> (A1, A1)

toInteger :: A1 -> Integer

Num A1

Methods

(+) :: A1 -> A1 -> A1

(-) :: A1 -> A1 -> A1

(*) :: A1 -> A1 -> A1

negate :: A1 -> A1

abs :: A1 -> A1

signum :: A1 -> A1

fromInteger :: Integer -> A1

Ord A1

Methods

compare :: A1 -> A1 -> Ordering

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

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

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

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

max :: A1 -> A1 -> A1

min :: A1 -> A1 -> A1

Real A1

Methods

toRational :: A1 -> Rational

Show A1

Methods

showsPrec :: Int -> A1 -> ShowS

show :: A1 -> String

showList :: [A1] -> ShowS

Storable A1

Methods

sizeOf :: A1 -> Int

alignment :: A1 -> Int

peekElemOff :: Ptr A1 -> Int -> IO A1

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

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

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

peek :: Ptr A1 -> IO A1

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

Bits A1

Methods

(.&.) :: A1 -> A1 -> A1

(.|.) :: A1 -> A1 -> A1

xor :: A1 -> A1 -> A1

complement :: A1 -> A1

shift :: A1 -> Int -> A1

rotate :: A1 -> Int -> A1

zeroBits :: A1

bit :: Int -> A1

setBit :: A1 -> Int -> A1

clearBit :: A1 -> Int -> A1

complementBit :: A1 -> Int -> A1

testBit :: A1 -> Int -> Bool

bitSizeMaybe :: A1 -> Maybe Int

bitSize :: A1 -> Int

isSigned :: A1 -> Bool

shiftL :: A1 -> Int -> A1

unsafeShiftL :: A1 -> Int -> A1

shiftR :: A1 -> Int -> A1

unsafeShiftR :: A1 -> Int -> A1

rotateL :: A1 -> Int -> A1

rotateR :: A1 -> Int -> A1

popCount :: A1 -> Int

Binary A1

Methods

put :: A1 -> Put

get :: Get A1

putList :: [A1] -> Put

newtype A2

Constructors

A2 Word16

Instances

Bounded A2

Methods

minBound :: A2

maxBound :: A2

Enum A2

Methods

succ :: A2 -> A2

pred :: A2 -> A2

toEnum :: Int -> A2

fromEnum :: A2 -> Int

enumFrom :: A2 -> [A2]

enumFromThen :: A2 -> A2 -> [A2]

enumFromTo :: A2 -> A2 -> [A2]

enumFromThenTo :: A2 -> A2 -> A2 -> [A2]

Eq A2

Methods

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

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

Integral A2

Methods

quot :: A2 -> A2 -> A2

rem :: A2 -> A2 -> A2

div :: A2 -> A2 -> A2

mod :: A2 -> A2 -> A2

quotRem :: A2 -> A2 -> (A2, A2)

divMod :: A2 -> A2 -> (A2, A2)

toInteger :: A2 -> Integer

Num A2

Methods

(+) :: A2 -> A2 -> A2

(-) :: A2 -> A2 -> A2

(*) :: A2 -> A2 -> A2

negate :: A2 -> A2

abs :: A2 -> A2

signum :: A2 -> A2

fromInteger :: Integer -> A2

Ord A2

Methods

compare :: A2 -> A2 -> Ordering

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

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

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

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

max :: A2 -> A2 -> A2

min :: A2 -> A2 -> A2

Real A2

Methods

toRational :: A2 -> Rational

Show A2

Methods

showsPrec :: Int -> A2 -> ShowS

show :: A2 -> String

showList :: [A2] -> ShowS

Storable A2

Methods

sizeOf :: A2 -> Int

alignment :: A2 -> Int

peekElemOff :: Ptr A2 -> Int -> IO A2

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

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

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

peek :: Ptr A2 -> IO A2

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

Bits A2

Methods

(.&.) :: A2 -> A2 -> A2

(.|.) :: A2 -> A2 -> A2

xor :: A2 -> A2 -> A2

complement :: A2 -> A2

shift :: A2 -> Int -> A2

rotate :: A2 -> Int -> A2

zeroBits :: A2

bit :: Int -> A2

setBit :: A2 -> Int -> A2

clearBit :: A2 -> Int -> A2

complementBit :: A2 -> Int -> A2

testBit :: A2 -> Int -> Bool

bitSizeMaybe :: A2 -> Maybe Int

bitSize :: A2 -> Int

isSigned :: A2 -> Bool

shiftL :: A2 -> Int -> A2

unsafeShiftL :: A2 -> Int -> A2

shiftR :: A2 -> Int -> A2

unsafeShiftR :: A2 -> Int -> A2

rotateL :: A2 -> Int -> A2

rotateR :: A2 -> Int -> A2

popCount :: A2 -> Int

Binary A2

Methods

put :: A2 -> Put

get :: Get A2

putList :: [A2] -> Put

newtype A3

Constructors

A3 Word32

Instances

Bounded A3

Methods

minBound :: A3

maxBound :: A3

Enum A3

Methods

succ :: A3 -> A3

pred :: A3 -> A3

toEnum :: Int -> A3

fromEnum :: A3 -> Int

enumFrom :: A3 -> [A3]

enumFromThen :: A3 -> A3 -> [A3]

enumFromTo :: A3 -> A3 -> [A3]

enumFromThenTo :: A3 -> A3 -> A3 -> [A3]

Eq A3

Methods

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

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

Integral A3

Methods

quot :: A3 -> A3 -> A3

rem :: A3 -> A3 -> A3

div :: A3 -> A3 -> A3

mod :: A3 -> A3 -> A3

quotRem :: A3 -> A3 -> (A3, A3)

divMod :: A3 -> A3 -> (A3, A3)

toInteger :: A3 -> Integer

Num A3

Methods

(+) :: A3 -> A3 -> A3

(-) :: A3 -> A3 -> A3

(*) :: A3 -> A3 -> A3

negate :: A3 -> A3

abs :: A3 -> A3

signum :: A3 -> A3

fromInteger :: Integer -> A3

Ord A3

Methods

compare :: A3 -> A3 -> Ordering

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

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

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

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

max :: A3 -> A3 -> A3

min :: A3 -> A3 -> A3

Real A3

Methods

toRational :: A3 -> Rational

Show A3

Methods

showsPrec :: Int -> A3 -> ShowS

show :: A3 -> String

showList :: [A3] -> ShowS

Storable A3

Methods

sizeOf :: A3 -> Int

alignment :: A3 -> Int

peekElemOff :: Ptr A3 -> Int -> IO A3

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

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

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

peek :: Ptr A3 -> IO A3

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

Bits A3

Methods

(.&.) :: A3 -> A3 -> A3

(.|.) :: A3 -> A3 -> A3

xor :: A3 -> A3 -> A3

complement :: A3 -> A3

shift :: A3 -> Int -> A3

rotate :: A3 -> Int -> A3

zeroBits :: A3

bit :: Int -> A3

setBit :: A3 -> Int -> A3

clearBit :: A3 -> Int -> A3

complementBit :: A3 -> Int -> A3

testBit :: A3 -> Int -> Bool

bitSizeMaybe :: A3 -> Maybe Int

bitSize :: A3 -> Int

isSigned :: A3 -> Bool

shiftL :: A3 -> Int -> A3

unsafeShiftL :: A3 -> Int -> A3

shiftR :: A3 -> Int -> A3

unsafeShiftR :: A3 -> Int -> A3

rotateL :: A3 -> Int -> A3

rotateR :: A3 -> Int -> A3

popCount :: A3 -> Int

Binary A3

Methods

put :: A3 -> Put

get :: Get A3

putList :: [A3] -> Put

newtype A4

Constructors

A4 Word32

Instances

Bounded A4

Methods

minBound :: A4

maxBound :: A4

Enum A4

Methods

succ :: A4 -> A4

pred :: A4 -> A4

toEnum :: Int -> A4

fromEnum :: A4 -> Int

enumFrom :: A4 -> [A4]

enumFromThen :: A4 -> A4 -> [A4]

enumFromTo :: A4 -> A4 -> [A4]

enumFromThenTo :: A4 -> A4 -> A4 -> [A4]

Eq A4

Methods

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

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

Integral A4

Methods

quot :: A4 -> A4 -> A4

rem :: A4 -> A4 -> A4

div :: A4 -> A4 -> A4

mod :: A4 -> A4 -> A4

quotRem :: A4 -> A4 -> (A4, A4)

divMod :: A4 -> A4 -> (A4, A4)

toInteger :: A4 -> Integer

Num A4

Methods

(+) :: A4 -> A4 -> A4

(-) :: A4 -> A4 -> A4

(*) :: A4 -> A4 -> A4

negate :: A4 -> A4

abs :: A4 -> A4

signum :: A4 -> A4

fromInteger :: Integer -> A4

Ord A4

Methods

compare :: A4 -> A4 -> Ordering

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

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

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

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

max :: A4 -> A4 -> A4

min :: A4 -> A4 -> A4

Real A4

Methods

toRational :: A4 -> Rational

Show A4

Methods

showsPrec :: Int -> A4 -> ShowS

show :: A4 -> String

showList :: [A4] -> ShowS

Storable A4

Methods

sizeOf :: A4 -> Int

alignment :: A4 -> Int

peekElemOff :: Ptr A4 -> Int -> IO A4

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

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

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

peek :: Ptr A4 -> IO A4

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

Bits A4

Methods

(.&.) :: A4 -> A4 -> A4

(.|.) :: A4 -> A4 -> A4

xor :: A4 -> A4 -> A4

complement :: A4 -> A4

shift :: A4 -> Int -> A4

rotate :: A4 -> Int -> A4

zeroBits :: A4

bit :: Int -> A4

setBit :: A4 -> Int -> A4

clearBit :: A4 -> Int -> A4

complementBit :: A4 -> Int -> A4

testBit :: A4 -> Int -> Bool

bitSizeMaybe :: A4 -> Maybe Int

bitSize :: A4 -> Int

isSigned :: A4 -> Bool

shiftL :: A4 -> Int -> A4

unsafeShiftL :: A4 -> Int -> A4

shiftR :: A4 -> Int -> A4

unsafeShiftR :: A4 -> Int -> A4

rotateL :: A4 -> Int -> A4

rotateR :: A4 -> Int -> A4

popCount :: A4 -> Int

Binary A4

Methods

put :: A4 -> Put

get :: Get A4

putList :: [A4] -> Put

newtype A6

Constructors

A6 Word64

Instances

Bounded A6

Methods

minBound :: A6

maxBound :: A6

Enum A6

Methods

succ :: A6 -> A6

pred :: A6 -> A6

toEnum :: Int -> A6

fromEnum :: A6 -> Int

enumFrom :: A6 -> [A6]

enumFromThen :: A6 -> A6 -> [A6]

enumFromTo :: A6 -> A6 -> [A6]

enumFromThenTo :: A6 -> A6 -> A6 -> [A6]

Eq A6

Methods

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

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

Integral A6

Methods

quot :: A6 -> A6 -> A6

rem :: A6 -> A6 -> A6

div :: A6 -> A6 -> A6

mod :: A6 -> A6 -> A6

quotRem :: A6 -> A6 -> (A6, A6)

divMod :: A6 -> A6 -> (A6, A6)

toInteger :: A6 -> Integer

Num A6

Methods

(+) :: A6 -> A6 -> A6

(-) :: A6 -> A6 -> A6

(*) :: A6 -> A6 -> A6

negate :: A6 -> A6

abs :: A6 -> A6

signum :: A6 -> A6

fromInteger :: Integer -> A6

Ord A6

Methods

compare :: A6 -> A6 -> Ordering

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

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

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

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

max :: A6 -> A6 -> A6

min :: A6 -> A6 -> A6

Real A6

Methods

toRational :: A6 -> Rational

Show A6

Methods

showsPrec :: Int -> A6 -> ShowS

show :: A6 -> String

showList :: [A6] -> ShowS

Storable A6

Methods

sizeOf :: A6 -> Int

alignment :: A6 -> Int

peekElemOff :: Ptr A6 -> Int -> IO A6

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

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

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

peek :: Ptr A6 -> IO A6

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

Bits A6

Methods

(.&.) :: A6 -> A6 -> A6

(.|.) :: A6 -> A6 -> A6

xor :: A6 -> A6 -> A6

complement :: A6 -> A6

shift :: A6 -> Int -> A6

rotate :: A6 -> Int -> A6

zeroBits :: A6

bit :: Int -> A6

setBit :: A6 -> Int -> A6

clearBit :: A6 -> Int -> A6

complementBit :: A6 -> Int -> A6

testBit :: A6 -> Int -> Bool

bitSizeMaybe :: A6 -> Maybe Int

bitSize :: A6 -> Int

isSigned :: A6 -> Bool

shiftL :: A6 -> Int -> A6

unsafeShiftL :: A6 -> Int -> A6

shiftR :: A6 -> Int -> A6

unsafeShiftR :: A6 -> Int -> A6

rotateL :: A6 -> Int -> A6

rotateR :: A6 -> Int -> A6

popCount :: A6 -> Int

Binary A6

Methods

put :: A6 -> Put

get :: Get A6

putList :: [A6] -> Put

newtype A8

Constructors

A8 Word64

Instances

Bounded A8

Methods

minBound :: A8

maxBound :: A8

Enum A8

Methods

succ :: A8 -> A8

pred :: A8 -> A8

toEnum :: Int -> A8

fromEnum :: A8 -> Int

enumFrom :: A8 -> [A8]

enumFromThen :: A8 -> A8 -> [A8]

enumFromTo :: A8 -> A8 -> [A8]

enumFromThenTo :: A8 -> A8 -> A8 -> [A8]

Eq A8

Methods

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

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

Integral A8

Methods

quot :: A8 -> A8 -> A8

rem :: A8 -> A8 -> A8

div :: A8 -> A8 -> A8

mod :: A8 -> A8 -> A8

quotRem :: A8 -> A8 -> (A8, A8)

divMod :: A8 -> A8 -> (A8, A8)

toInteger :: A8 -> Integer

Num A8

Methods

(+) :: A8 -> A8 -> A8

(-) :: A8 -> A8 -> A8

(*) :: A8 -> A8 -> A8

negate :: A8 -> A8

abs :: A8 -> A8

signum :: A8 -> A8

fromInteger :: Integer -> A8

Ord A8

Methods

compare :: A8 -> A8 -> Ordering

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

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

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

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

max :: A8 -> A8 -> A8

min :: A8 -> A8 -> A8

Real A8

Methods

toRational :: A8 -> Rational

Show A8

Methods

showsPrec :: Int -> A8 -> ShowS

show :: A8 -> String

showList :: [A8] -> ShowS

Storable A8

Methods

sizeOf :: A8 -> Int

alignment :: A8 -> Int

peekElemOff :: Ptr A8 -> Int -> IO A8

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

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

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

peek :: Ptr A8 -> IO A8

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

Bits A8

Methods

(.&.) :: A8 -> A8 -> A8

(.|.) :: A8 -> A8 -> A8

xor :: A8 -> A8 -> A8

complement :: A8 -> A8

shift :: A8 -> Int -> A8

rotate :: A8 -> Int -> A8

zeroBits :: A8

bit :: Int -> A8

setBit :: A8 -> Int -> A8

clearBit :: A8 -> Int -> A8

complementBit :: A8 -> Int -> A8

testBit :: A8 -> Int -> Bool

bitSizeMaybe :: A8 -> Maybe Int

bitSize :: A8 -> Int

isSigned :: A8 -> Bool

shiftL :: A8 -> Int -> A8

unsafeShiftL :: A8 -> Int -> A8

shiftR :: A8 -> Int -> A8

unsafeShiftR :: A8 -> Int -> A8

rotateL :: A8 -> Int -> A8

rotateR :: A8 -> Int -> A8

popCount :: A8 -> Int

Binary A8

Methods

put :: A8 -> Put

get :: Get A8

putList :: [A8] -> Put

newtype A12

Constructors

A12 Integer

Instances

Bounded A12

Methods

minBound :: A12

maxBound :: A12

Enum A12

Methods

succ :: A12 -> A12

pred :: A12 -> A12

toEnum :: Int -> A12

fromEnum :: A12 -> Int

enumFrom :: A12 -> [A12]

enumFromThen :: A12 -> A12 -> [A12]

enumFromTo :: A12 -> A12 -> [A12]

enumFromThenTo :: A12 -> A12 -> A12 -> [A12]

Eq A12

Methods

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

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

Integral A12

Methods

quot :: A12 -> A12 -> A12

rem :: A12 -> A12 -> A12

div :: A12 -> A12 -> A12

mod :: A12 -> A12 -> A12

quotRem :: A12 -> A12 -> (A12, A12)

divMod :: A12 -> A12 -> (A12, A12)

toInteger :: A12 -> Integer

Num A12

Methods

(+) :: A12 -> A12 -> A12

(-) :: A12 -> A12 -> A12

(*) :: A12 -> A12 -> A12

negate :: A12 -> A12

abs :: A12 -> A12

signum :: A12 -> A12

fromInteger :: Integer -> A12

Ord A12

Methods

compare :: A12 -> A12 -> Ordering

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

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

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

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

max :: A12 -> A12 -> A12

min :: A12 -> A12 -> A12

Real A12

Methods

toRational :: A12 -> Rational

Show A12

Methods

showsPrec :: Int -> A12 -> ShowS

show :: A12 -> String

showList :: [A12] -> ShowS

Storable A12

Methods

sizeOf :: A12 -> Int

alignment :: A12 -> Int

peekElemOff :: Ptr A12 -> Int -> IO A12

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

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

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

peek :: Ptr A12 -> IO A12

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

Bits A12

Methods

(.&.) :: A12 -> A12 -> A12

(.|.) :: A12 -> A12 -> A12

xor :: A12 -> A12 -> A12

complement :: A12 -> A12

shift :: A12 -> Int -> A12

rotate :: A12 -> Int -> A12

zeroBits :: A12

bit :: Int -> A12

setBit :: A12 -> Int -> A12

clearBit :: A12 -> Int -> A12

complementBit :: A12 -> Int -> A12

testBit :: A12 -> Int -> Bool

bitSizeMaybe :: A12 -> Maybe Int

bitSize :: A12 -> Int

isSigned :: A12 -> Bool

shiftL :: A12 -> Int -> A12

unsafeShiftL :: A12 -> Int -> A12

shiftR :: A12 -> Int -> A12

unsafeShiftR :: A12 -> Int -> A12

rotateL :: A12 -> Int -> A12

rotateR :: A12 -> Int -> A12

popCount :: A12 -> Int

Binary A12

Methods

put :: A12 -> Put

get :: Get A12

putList :: [A12] -> Put

type PStringLen = ByteString

getList :: Binary a => Get [a]

putList :: Binary a => [a] -> Put

encodeList :: Binary a => [a] -> ByteString

decodeList :: Binary a => ByteString -> [a]

encodeListFile :: Binary a => FilePath -> [a] -> IO ()

decodeListFile :: Binary a => FilePath -> IO [a]

module Data.Binary

module Data.ByteString.Internal

Orphan instances

(Storable a, Storable b) => Storable (a, b)

Methods

sizeOf :: (a, b) -> Int

alignment :: (a, b) -> Int

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

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

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

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

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

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