dahdit-0.8.0: Binary parsing and serialization with integrated size
Safe HaskellSafe-Inferred
LanguageHaskell2010

Dahdit.Nums

Description

Internally, all numbers are represented in little-endian format (since that is what the host endianness is on any arch we'd be using). Prim instances for big endian variants actually do the conversion at read/write time.

Documentation

newtype Word16LE Source #

Constructors

Word16LE 

Fields

Instances

Instances details
Bits Word16LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

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

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

xor :: Word16LE -> Word16LE -> Word16LE #

complement :: Word16LE -> Word16LE #

shift :: Word16LE -> Int -> Word16LE #

rotate :: Word16LE -> Int -> Word16LE #

zeroBits :: Word16LE #

bit :: Int -> Word16LE #

setBit :: Word16LE -> Int -> Word16LE #

clearBit :: Word16LE -> Int -> Word16LE #

complementBit :: Word16LE -> Int -> Word16LE #

testBit :: Word16LE -> Int -> Bool #

bitSizeMaybe :: Word16LE -> Maybe Int #

bitSize :: Word16LE -> Int #

isSigned :: Word16LE -> Bool #

shiftL :: Word16LE -> Int -> Word16LE #

unsafeShiftL :: Word16LE -> Int -> Word16LE #

shiftR :: Word16LE -> Int -> Word16LE #

unsafeShiftR :: Word16LE -> Int -> Word16LE #

rotateL :: Word16LE -> Int -> Word16LE #

rotateR :: Word16LE -> Int -> Word16LE #

popCount :: Word16LE -> Int #

FiniteBits Word16LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

finiteBitSize :: Word16LE -> Int #

countLeadingZeros :: Word16LE -> Int #

countTrailingZeros :: Word16LE -> Int #

Bounded Word16LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

minBound :: Word16LE #

maxBound :: Word16LE #

Enum Word16LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

succ :: Word16LE -> Word16LE #

pred :: Word16LE -> Word16LE #

toEnum :: Int -> Word16LE #

fromEnum :: Word16LE -> Int #

enumFrom :: Word16LE -> [Word16LE] #

enumFromThen :: Word16LE -> Word16LE -> [Word16LE] #

enumFromTo :: Word16LE -> Word16LE -> [Word16LE] #

enumFromThenTo :: Word16LE -> Word16LE -> Word16LE -> [Word16LE] #

Num Word16LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

(+) :: Word16LE -> Word16LE -> Word16LE #

(-) :: Word16LE -> Word16LE -> Word16LE #

(*) :: Word16LE -> Word16LE -> Word16LE #

negate :: Word16LE -> Word16LE #

abs :: Word16LE -> Word16LE #

signum :: Word16LE -> Word16LE #

fromInteger :: Integer -> Word16LE #

Integral Word16LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

quot :: Word16LE -> Word16LE -> Word16LE #

rem :: Word16LE -> Word16LE -> Word16LE #

div :: Word16LE -> Word16LE -> Word16LE #

mod :: Word16LE -> Word16LE -> Word16LE #

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

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

toInteger :: Word16LE -> Integer #

Real Word16LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

toRational :: Word16LE -> Rational #

Show Word16LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

showsPrec :: Int -> Word16LE -> ShowS #

show :: Word16LE -> String #

showList :: [Word16LE] -> ShowS #

Binary Word16LE Source # 
Instance details

Defined in Dahdit.Binary

Methods

byteSize :: Word16LE -> ByteCount Source #

get :: Get Word16LE Source #

put :: Word16LE -> Put Source #

StaticByteSized Word16LE Source # 
Instance details

Defined in Dahdit.Sizes

Associated Types

type StaticSize Word16LE :: Nat Source #

Methods

staticByteSize :: Proxy Word16LE -> ByteCount Source #

Default Word16LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

def :: Word16LE #

Eq Word16LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

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

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

Ord Word16LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

compare :: Word16LE -> Word16LE -> Ordering #

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

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

(>) :: Word16LE -> Word16LE -> Bool #

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

max :: Word16LE -> Word16LE -> Word16LE #

min :: Word16LE -> Word16LE -> Word16LE #

Prim Word16LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

sizeOfType# :: Proxy Word16LE -> Int# #

sizeOf# :: Word16LE -> Int# #

alignmentOfType# :: Proxy Word16LE -> Int# #

alignment# :: Word16LE -> Int# #

indexByteArray# :: ByteArray# -> Int# -> Word16LE #

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word16LE #) #

writeByteArray# :: MutableByteArray# s -> Int# -> Word16LE -> State# s -> State# s #

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word16LE -> State# s -> State# s #

indexOffAddr# :: Addr# -> Int# -> Word16LE #

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Word16LE #) #

writeOffAddr# :: Addr# -> Int# -> Word16LE -> State# s -> State# s #

setOffAddr# :: Addr# -> Int# -> Int# -> Word16LE -> State# s -> State# s #

PrimUnaligned Word16LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

indexUnalignedByteArray# :: ByteArray# -> Int# -> Word16LE #

readUnalignedByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word16LE #) #

writeUnalignedByteArray# :: MutableByteArray# s -> Int# -> Word16LE -> State# s -> State# s #

type StaticSize Word16LE Source # 
Instance details

Defined in Dahdit.Sizes

type StaticSize Word16LE = 2

newtype Int16LE Source #

Constructors

Int16LE 

Fields

Instances

Instances details
Bits Int16LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

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

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

xor :: Int16LE -> Int16LE -> Int16LE #

complement :: Int16LE -> Int16LE #

shift :: Int16LE -> Int -> Int16LE #

rotate :: Int16LE -> Int -> Int16LE #

zeroBits :: Int16LE #

bit :: Int -> Int16LE #

setBit :: Int16LE -> Int -> Int16LE #

clearBit :: Int16LE -> Int -> Int16LE #

complementBit :: Int16LE -> Int -> Int16LE #

testBit :: Int16LE -> Int -> Bool #

bitSizeMaybe :: Int16LE -> Maybe Int #

bitSize :: Int16LE -> Int #

isSigned :: Int16LE -> Bool #

shiftL :: Int16LE -> Int -> Int16LE #

unsafeShiftL :: Int16LE -> Int -> Int16LE #

shiftR :: Int16LE -> Int -> Int16LE #

unsafeShiftR :: Int16LE -> Int -> Int16LE #

rotateL :: Int16LE -> Int -> Int16LE #

rotateR :: Int16LE -> Int -> Int16LE #

popCount :: Int16LE -> Int #

FiniteBits Int16LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

finiteBitSize :: Int16LE -> Int #

countLeadingZeros :: Int16LE -> Int #

countTrailingZeros :: Int16LE -> Int #

Bounded Int16LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

minBound :: Int16LE #

maxBound :: Int16LE #

Enum Int16LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

succ :: Int16LE -> Int16LE #

pred :: Int16LE -> Int16LE #

toEnum :: Int -> Int16LE #

fromEnum :: Int16LE -> Int #

enumFrom :: Int16LE -> [Int16LE] #

enumFromThen :: Int16LE -> Int16LE -> [Int16LE] #

enumFromTo :: Int16LE -> Int16LE -> [Int16LE] #

enumFromThenTo :: Int16LE -> Int16LE -> Int16LE -> [Int16LE] #

Num Int16LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

(+) :: Int16LE -> Int16LE -> Int16LE #

(-) :: Int16LE -> Int16LE -> Int16LE #

(*) :: Int16LE -> Int16LE -> Int16LE #

negate :: Int16LE -> Int16LE #

abs :: Int16LE -> Int16LE #

signum :: Int16LE -> Int16LE #

fromInteger :: Integer -> Int16LE #

Integral Int16LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

quot :: Int16LE -> Int16LE -> Int16LE #

rem :: Int16LE -> Int16LE -> Int16LE #

div :: Int16LE -> Int16LE -> Int16LE #

mod :: Int16LE -> Int16LE -> Int16LE #

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

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

toInteger :: Int16LE -> Integer #

Real Int16LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

toRational :: Int16LE -> Rational #

Show Int16LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

showsPrec :: Int -> Int16LE -> ShowS #

show :: Int16LE -> String #

showList :: [Int16LE] -> ShowS #

Binary Int16LE Source # 
Instance details

Defined in Dahdit.Binary

Methods

byteSize :: Int16LE -> ByteCount Source #

get :: Get Int16LE Source #

put :: Int16LE -> Put Source #

StaticByteSized Int16LE Source # 
Instance details

Defined in Dahdit.Sizes

Associated Types

type StaticSize Int16LE :: Nat Source #

Methods

staticByteSize :: Proxy Int16LE -> ByteCount Source #

Default Int16LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

def :: Int16LE #

Eq Int16LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

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

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

Ord Int16LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

compare :: Int16LE -> Int16LE -> Ordering #

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

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

(>) :: Int16LE -> Int16LE -> Bool #

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

max :: Int16LE -> Int16LE -> Int16LE #

min :: Int16LE -> Int16LE -> Int16LE #

Prim Int16LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

sizeOfType# :: Proxy Int16LE -> Int# #

sizeOf# :: Int16LE -> Int# #

alignmentOfType# :: Proxy Int16LE -> Int# #

alignment# :: Int16LE -> Int# #

indexByteArray# :: ByteArray# -> Int# -> Int16LE #

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int16LE #) #

writeByteArray# :: MutableByteArray# s -> Int# -> Int16LE -> State# s -> State# s #

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int16LE -> State# s -> State# s #

indexOffAddr# :: Addr# -> Int# -> Int16LE #

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Int16LE #) #

writeOffAddr# :: Addr# -> Int# -> Int16LE -> State# s -> State# s #

setOffAddr# :: Addr# -> Int# -> Int# -> Int16LE -> State# s -> State# s #

PrimUnaligned Int16LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

indexUnalignedByteArray# :: ByteArray# -> Int# -> Int16LE #

readUnalignedByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int16LE #) #

writeUnalignedByteArray# :: MutableByteArray# s -> Int# -> Int16LE -> State# s -> State# s #

type StaticSize Int16LE Source # 
Instance details

Defined in Dahdit.Sizes

type StaticSize Int16LE = 2

newtype Word24LE Source #

Constructors

Word24LE 

Fields

Instances

Instances details
Bits Word24LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

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

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

xor :: Word24LE -> Word24LE -> Word24LE #

complement :: Word24LE -> Word24LE #

shift :: Word24LE -> Int -> Word24LE #

rotate :: Word24LE -> Int -> Word24LE #

zeroBits :: Word24LE #

bit :: Int -> Word24LE #

setBit :: Word24LE -> Int -> Word24LE #

clearBit :: Word24LE -> Int -> Word24LE #

complementBit :: Word24LE -> Int -> Word24LE #

testBit :: Word24LE -> Int -> Bool #

bitSizeMaybe :: Word24LE -> Maybe Int #

bitSize :: Word24LE -> Int #

isSigned :: Word24LE -> Bool #

shiftL :: Word24LE -> Int -> Word24LE #

unsafeShiftL :: Word24LE -> Int -> Word24LE #

shiftR :: Word24LE -> Int -> Word24LE #

unsafeShiftR :: Word24LE -> Int -> Word24LE #

rotateL :: Word24LE -> Int -> Word24LE #

rotateR :: Word24LE -> Int -> Word24LE #

popCount :: Word24LE -> Int #

FiniteBits Word24LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

finiteBitSize :: Word24LE -> Int #

countLeadingZeros :: Word24LE -> Int #

countTrailingZeros :: Word24LE -> Int #

Bounded Word24LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

minBound :: Word24LE #

maxBound :: Word24LE #

Enum Word24LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

succ :: Word24LE -> Word24LE #

pred :: Word24LE -> Word24LE #

toEnum :: Int -> Word24LE #

fromEnum :: Word24LE -> Int #

enumFrom :: Word24LE -> [Word24LE] #

enumFromThen :: Word24LE -> Word24LE -> [Word24LE] #

enumFromTo :: Word24LE -> Word24LE -> [Word24LE] #

enumFromThenTo :: Word24LE -> Word24LE -> Word24LE -> [Word24LE] #

Num Word24LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

(+) :: Word24LE -> Word24LE -> Word24LE #

(-) :: Word24LE -> Word24LE -> Word24LE #

(*) :: Word24LE -> Word24LE -> Word24LE #

negate :: Word24LE -> Word24LE #

abs :: Word24LE -> Word24LE #

signum :: Word24LE -> Word24LE #

fromInteger :: Integer -> Word24LE #

Integral Word24LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

quot :: Word24LE -> Word24LE -> Word24LE #

rem :: Word24LE -> Word24LE -> Word24LE #

div :: Word24LE -> Word24LE -> Word24LE #

mod :: Word24LE -> Word24LE -> Word24LE #

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

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

toInteger :: Word24LE -> Integer #

Real Word24LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

toRational :: Word24LE -> Rational #

Show Word24LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

showsPrec :: Int -> Word24LE -> ShowS #

show :: Word24LE -> String #

showList :: [Word24LE] -> ShowS #

Binary Word24LE Source # 
Instance details

Defined in Dahdit.Binary

Methods

byteSize :: Word24LE -> ByteCount Source #

get :: Get Word24LE Source #

put :: Word24LE -> Put Source #

StaticByteSized Word24LE Source # 
Instance details

Defined in Dahdit.Sizes

Associated Types

type StaticSize Word24LE :: Nat Source #

Methods

staticByteSize :: Proxy Word24LE -> ByteCount Source #

Default Word24LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

def :: Word24LE #

Eq Word24LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

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

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

Ord Word24LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

compare :: Word24LE -> Word24LE -> Ordering #

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

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

(>) :: Word24LE -> Word24LE -> Bool #

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

max :: Word24LE -> Word24LE -> Word24LE #

min :: Word24LE -> Word24LE -> Word24LE #

Prim Word24LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

sizeOfType# :: Proxy Word24LE -> Int# #

sizeOf# :: Word24LE -> Int# #

alignmentOfType# :: Proxy Word24LE -> Int# #

alignment# :: Word24LE -> Int# #

indexByteArray# :: ByteArray# -> Int# -> Word24LE #

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word24LE #) #

writeByteArray# :: MutableByteArray# s -> Int# -> Word24LE -> State# s -> State# s #

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word24LE -> State# s -> State# s #

indexOffAddr# :: Addr# -> Int# -> Word24LE #

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Word24LE #) #

writeOffAddr# :: Addr# -> Int# -> Word24LE -> State# s -> State# s #

setOffAddr# :: Addr# -> Int# -> Int# -> Word24LE -> State# s -> State# s #

PrimUnaligned Word24LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

indexUnalignedByteArray# :: ByteArray# -> Int# -> Word24LE #

readUnalignedByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word24LE #) #

writeUnalignedByteArray# :: MutableByteArray# s -> Int# -> Word24LE -> State# s -> State# s #

type StaticSize Word24LE Source # 
Instance details

Defined in Dahdit.Sizes

type StaticSize Word24LE = 3

newtype Int24LE Source #

Constructors

Int24LE 

Fields

Instances

Instances details
Bits Int24LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

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

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

xor :: Int24LE -> Int24LE -> Int24LE #

complement :: Int24LE -> Int24LE #

shift :: Int24LE -> Int -> Int24LE #

rotate :: Int24LE -> Int -> Int24LE #

zeroBits :: Int24LE #

bit :: Int -> Int24LE #

setBit :: Int24LE -> Int -> Int24LE #

clearBit :: Int24LE -> Int -> Int24LE #

complementBit :: Int24LE -> Int -> Int24LE #

testBit :: Int24LE -> Int -> Bool #

bitSizeMaybe :: Int24LE -> Maybe Int #

bitSize :: Int24LE -> Int #

isSigned :: Int24LE -> Bool #

shiftL :: Int24LE -> Int -> Int24LE #

unsafeShiftL :: Int24LE -> Int -> Int24LE #

shiftR :: Int24LE -> Int -> Int24LE #

unsafeShiftR :: Int24LE -> Int -> Int24LE #

rotateL :: Int24LE -> Int -> Int24LE #

rotateR :: Int24LE -> Int -> Int24LE #

popCount :: Int24LE -> Int #

FiniteBits Int24LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

finiteBitSize :: Int24LE -> Int #

countLeadingZeros :: Int24LE -> Int #

countTrailingZeros :: Int24LE -> Int #

Bounded Int24LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

minBound :: Int24LE #

maxBound :: Int24LE #

Enum Int24LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

succ :: Int24LE -> Int24LE #

pred :: Int24LE -> Int24LE #

toEnum :: Int -> Int24LE #

fromEnum :: Int24LE -> Int #

enumFrom :: Int24LE -> [Int24LE] #

enumFromThen :: Int24LE -> Int24LE -> [Int24LE] #

enumFromTo :: Int24LE -> Int24LE -> [Int24LE] #

enumFromThenTo :: Int24LE -> Int24LE -> Int24LE -> [Int24LE] #

Num Int24LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

(+) :: Int24LE -> Int24LE -> Int24LE #

(-) :: Int24LE -> Int24LE -> Int24LE #

(*) :: Int24LE -> Int24LE -> Int24LE #

negate :: Int24LE -> Int24LE #

abs :: Int24LE -> Int24LE #

signum :: Int24LE -> Int24LE #

fromInteger :: Integer -> Int24LE #

Integral Int24LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

quot :: Int24LE -> Int24LE -> Int24LE #

rem :: Int24LE -> Int24LE -> Int24LE #

div :: Int24LE -> Int24LE -> Int24LE #

mod :: Int24LE -> Int24LE -> Int24LE #

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

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

toInteger :: Int24LE -> Integer #

Real Int24LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

toRational :: Int24LE -> Rational #

Show Int24LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

showsPrec :: Int -> Int24LE -> ShowS #

show :: Int24LE -> String #

showList :: [Int24LE] -> ShowS #

Binary Int24LE Source # 
Instance details

Defined in Dahdit.Binary

Methods

byteSize :: Int24LE -> ByteCount Source #

get :: Get Int24LE Source #

put :: Int24LE -> Put Source #

StaticByteSized Int24LE Source # 
Instance details

Defined in Dahdit.Sizes

Associated Types

type StaticSize Int24LE :: Nat Source #

Methods

staticByteSize :: Proxy Int24LE -> ByteCount Source #

Default Int24LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

def :: Int24LE #

Eq Int24LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

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

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

Ord Int24LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

compare :: Int24LE -> Int24LE -> Ordering #

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

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

(>) :: Int24LE -> Int24LE -> Bool #

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

max :: Int24LE -> Int24LE -> Int24LE #

min :: Int24LE -> Int24LE -> Int24LE #

Prim Int24LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

sizeOfType# :: Proxy Int24LE -> Int# #

sizeOf# :: Int24LE -> Int# #

alignmentOfType# :: Proxy Int24LE -> Int# #

alignment# :: Int24LE -> Int# #

indexByteArray# :: ByteArray# -> Int# -> Int24LE #

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int24LE #) #

writeByteArray# :: MutableByteArray# s -> Int# -> Int24LE -> State# s -> State# s #

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int24LE -> State# s -> State# s #

indexOffAddr# :: Addr# -> Int# -> Int24LE #

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Int24LE #) #

writeOffAddr# :: Addr# -> Int# -> Int24LE -> State# s -> State# s #

setOffAddr# :: Addr# -> Int# -> Int# -> Int24LE -> State# s -> State# s #

PrimUnaligned Int24LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

indexUnalignedByteArray# :: ByteArray# -> Int# -> Int24LE #

readUnalignedByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int24LE #) #

writeUnalignedByteArray# :: MutableByteArray# s -> Int# -> Int24LE -> State# s -> State# s #

type StaticSize Int24LE Source # 
Instance details

Defined in Dahdit.Sizes

type StaticSize Int24LE = 3

newtype Word32LE Source #

Constructors

Word32LE 

Fields

Instances

Instances details
Bits Word32LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

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

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

xor :: Word32LE -> Word32LE -> Word32LE #

complement :: Word32LE -> Word32LE #

shift :: Word32LE -> Int -> Word32LE #

rotate :: Word32LE -> Int -> Word32LE #

zeroBits :: Word32LE #

bit :: Int -> Word32LE #

setBit :: Word32LE -> Int -> Word32LE #

clearBit :: Word32LE -> Int -> Word32LE #

complementBit :: Word32LE -> Int -> Word32LE #

testBit :: Word32LE -> Int -> Bool #

bitSizeMaybe :: Word32LE -> Maybe Int #

bitSize :: Word32LE -> Int #

isSigned :: Word32LE -> Bool #

shiftL :: Word32LE -> Int -> Word32LE #

unsafeShiftL :: Word32LE -> Int -> Word32LE #

shiftR :: Word32LE -> Int -> Word32LE #

unsafeShiftR :: Word32LE -> Int -> Word32LE #

rotateL :: Word32LE -> Int -> Word32LE #

rotateR :: Word32LE -> Int -> Word32LE #

popCount :: Word32LE -> Int #

FiniteBits Word32LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

finiteBitSize :: Word32LE -> Int #

countLeadingZeros :: Word32LE -> Int #

countTrailingZeros :: Word32LE -> Int #

Bounded Word32LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

minBound :: Word32LE #

maxBound :: Word32LE #

Enum Word32LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

succ :: Word32LE -> Word32LE #

pred :: Word32LE -> Word32LE #

toEnum :: Int -> Word32LE #

fromEnum :: Word32LE -> Int #

enumFrom :: Word32LE -> [Word32LE] #

enumFromThen :: Word32LE -> Word32LE -> [Word32LE] #

enumFromTo :: Word32LE -> Word32LE -> [Word32LE] #

enumFromThenTo :: Word32LE -> Word32LE -> Word32LE -> [Word32LE] #

Num Word32LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

(+) :: Word32LE -> Word32LE -> Word32LE #

(-) :: Word32LE -> Word32LE -> Word32LE #

(*) :: Word32LE -> Word32LE -> Word32LE #

negate :: Word32LE -> Word32LE #

abs :: Word32LE -> Word32LE #

signum :: Word32LE -> Word32LE #

fromInteger :: Integer -> Word32LE #

Integral Word32LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

quot :: Word32LE -> Word32LE -> Word32LE #

rem :: Word32LE -> Word32LE -> Word32LE #

div :: Word32LE -> Word32LE -> Word32LE #

mod :: Word32LE -> Word32LE -> Word32LE #

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

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

toInteger :: Word32LE -> Integer #

Real Word32LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

toRational :: Word32LE -> Rational #

Show Word32LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

showsPrec :: Int -> Word32LE -> ShowS #

show :: Word32LE -> String #

showList :: [Word32LE] -> ShowS #

Binary Word32LE Source # 
Instance details

Defined in Dahdit.Binary

Methods

byteSize :: Word32LE -> ByteCount Source #

get :: Get Word32LE Source #

put :: Word32LE -> Put Source #

StaticByteSized Word32LE Source # 
Instance details

Defined in Dahdit.Sizes

Associated Types

type StaticSize Word32LE :: Nat Source #

Methods

staticByteSize :: Proxy Word32LE -> ByteCount Source #

Default Word32LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

def :: Word32LE #

Eq Word32LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

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

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

Ord Word32LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

compare :: Word32LE -> Word32LE -> Ordering #

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

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

(>) :: Word32LE -> Word32LE -> Bool #

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

max :: Word32LE -> Word32LE -> Word32LE #

min :: Word32LE -> Word32LE -> Word32LE #

Prim Word32LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

sizeOfType# :: Proxy Word32LE -> Int# #

sizeOf# :: Word32LE -> Int# #

alignmentOfType# :: Proxy Word32LE -> Int# #

alignment# :: Word32LE -> Int# #

indexByteArray# :: ByteArray# -> Int# -> Word32LE #

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word32LE #) #

writeByteArray# :: MutableByteArray# s -> Int# -> Word32LE -> State# s -> State# s #

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word32LE -> State# s -> State# s #

indexOffAddr# :: Addr# -> Int# -> Word32LE #

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Word32LE #) #

writeOffAddr# :: Addr# -> Int# -> Word32LE -> State# s -> State# s #

setOffAddr# :: Addr# -> Int# -> Int# -> Word32LE -> State# s -> State# s #

PrimUnaligned Word32LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

indexUnalignedByteArray# :: ByteArray# -> Int# -> Word32LE #

readUnalignedByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word32LE #) #

writeUnalignedByteArray# :: MutableByteArray# s -> Int# -> Word32LE -> State# s -> State# s #

type StaticSize Word32LE Source # 
Instance details

Defined in Dahdit.Sizes

type StaticSize Word32LE = 4

newtype Int32LE Source #

Constructors

Int32LE 

Fields

Instances

Instances details
Bits Int32LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

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

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

xor :: Int32LE -> Int32LE -> Int32LE #

complement :: Int32LE -> Int32LE #

shift :: Int32LE -> Int -> Int32LE #

rotate :: Int32LE -> Int -> Int32LE #

zeroBits :: Int32LE #

bit :: Int -> Int32LE #

setBit :: Int32LE -> Int -> Int32LE #

clearBit :: Int32LE -> Int -> Int32LE #

complementBit :: Int32LE -> Int -> Int32LE #

testBit :: Int32LE -> Int -> Bool #

bitSizeMaybe :: Int32LE -> Maybe Int #

bitSize :: Int32LE -> Int #

isSigned :: Int32LE -> Bool #

shiftL :: Int32LE -> Int -> Int32LE #

unsafeShiftL :: Int32LE -> Int -> Int32LE #

shiftR :: Int32LE -> Int -> Int32LE #

unsafeShiftR :: Int32LE -> Int -> Int32LE #

rotateL :: Int32LE -> Int -> Int32LE #

rotateR :: Int32LE -> Int -> Int32LE #

popCount :: Int32LE -> Int #

FiniteBits Int32LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

finiteBitSize :: Int32LE -> Int #

countLeadingZeros :: Int32LE -> Int #

countTrailingZeros :: Int32LE -> Int #

Bounded Int32LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

minBound :: Int32LE #

maxBound :: Int32LE #

Enum Int32LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

succ :: Int32LE -> Int32LE #

pred :: Int32LE -> Int32LE #

toEnum :: Int -> Int32LE #

fromEnum :: Int32LE -> Int #

enumFrom :: Int32LE -> [Int32LE] #

enumFromThen :: Int32LE -> Int32LE -> [Int32LE] #

enumFromTo :: Int32LE -> Int32LE -> [Int32LE] #

enumFromThenTo :: Int32LE -> Int32LE -> Int32LE -> [Int32LE] #

Num Int32LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

(+) :: Int32LE -> Int32LE -> Int32LE #

(-) :: Int32LE -> Int32LE -> Int32LE #

(*) :: Int32LE -> Int32LE -> Int32LE #

negate :: Int32LE -> Int32LE #

abs :: Int32LE -> Int32LE #

signum :: Int32LE -> Int32LE #

fromInteger :: Integer -> Int32LE #

Integral Int32LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

quot :: Int32LE -> Int32LE -> Int32LE #

rem :: Int32LE -> Int32LE -> Int32LE #

div :: Int32LE -> Int32LE -> Int32LE #

mod :: Int32LE -> Int32LE -> Int32LE #

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

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

toInteger :: Int32LE -> Integer #

Real Int32LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

toRational :: Int32LE -> Rational #

Show Int32LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

showsPrec :: Int -> Int32LE -> ShowS #

show :: Int32LE -> String #

showList :: [Int32LE] -> ShowS #

Binary Int32LE Source # 
Instance details

Defined in Dahdit.Binary

Methods

byteSize :: Int32LE -> ByteCount Source #

get :: Get Int32LE Source #

put :: Int32LE -> Put Source #

StaticByteSized Int32LE Source # 
Instance details

Defined in Dahdit.Sizes

Associated Types

type StaticSize Int32LE :: Nat Source #

Methods

staticByteSize :: Proxy Int32LE -> ByteCount Source #

Default Int32LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

def :: Int32LE #

Eq Int32LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

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

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

Ord Int32LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

compare :: Int32LE -> Int32LE -> Ordering #

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

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

(>) :: Int32LE -> Int32LE -> Bool #

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

max :: Int32LE -> Int32LE -> Int32LE #

min :: Int32LE -> Int32LE -> Int32LE #

Prim Int32LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

sizeOfType# :: Proxy Int32LE -> Int# #

sizeOf# :: Int32LE -> Int# #

alignmentOfType# :: Proxy Int32LE -> Int# #

alignment# :: Int32LE -> Int# #

indexByteArray# :: ByteArray# -> Int# -> Int32LE #

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int32LE #) #

writeByteArray# :: MutableByteArray# s -> Int# -> Int32LE -> State# s -> State# s #

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int32LE -> State# s -> State# s #

indexOffAddr# :: Addr# -> Int# -> Int32LE #

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Int32LE #) #

writeOffAddr# :: Addr# -> Int# -> Int32LE -> State# s -> State# s #

setOffAddr# :: Addr# -> Int# -> Int# -> Int32LE -> State# s -> State# s #

PrimUnaligned Int32LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

indexUnalignedByteArray# :: ByteArray# -> Int# -> Int32LE #

readUnalignedByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int32LE #) #

writeUnalignedByteArray# :: MutableByteArray# s -> Int# -> Int32LE -> State# s -> State# s #

type StaticSize Int32LE Source # 
Instance details

Defined in Dahdit.Sizes

type StaticSize Int32LE = 4

newtype Word64LE Source #

Constructors

Word64LE 

Fields

Instances

Instances details
Bits Word64LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

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

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

xor :: Word64LE -> Word64LE -> Word64LE #

complement :: Word64LE -> Word64LE #

shift :: Word64LE -> Int -> Word64LE #

rotate :: Word64LE -> Int -> Word64LE #

zeroBits :: Word64LE #

bit :: Int -> Word64LE #

setBit :: Word64LE -> Int -> Word64LE #

clearBit :: Word64LE -> Int -> Word64LE #

complementBit :: Word64LE -> Int -> Word64LE #

testBit :: Word64LE -> Int -> Bool #

bitSizeMaybe :: Word64LE -> Maybe Int #

bitSize :: Word64LE -> Int #

isSigned :: Word64LE -> Bool #

shiftL :: Word64LE -> Int -> Word64LE #

unsafeShiftL :: Word64LE -> Int -> Word64LE #

shiftR :: Word64LE -> Int -> Word64LE #

unsafeShiftR :: Word64LE -> Int -> Word64LE #

rotateL :: Word64LE -> Int -> Word64LE #

rotateR :: Word64LE -> Int -> Word64LE #

popCount :: Word64LE -> Int #

FiniteBits Word64LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

finiteBitSize :: Word64LE -> Int #

countLeadingZeros :: Word64LE -> Int #

countTrailingZeros :: Word64LE -> Int #

Bounded Word64LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

minBound :: Word64LE #

maxBound :: Word64LE #

Enum Word64LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

succ :: Word64LE -> Word64LE #

pred :: Word64LE -> Word64LE #

toEnum :: Int -> Word64LE #

fromEnum :: Word64LE -> Int #

enumFrom :: Word64LE -> [Word64LE] #

enumFromThen :: Word64LE -> Word64LE -> [Word64LE] #

enumFromTo :: Word64LE -> Word64LE -> [Word64LE] #

enumFromThenTo :: Word64LE -> Word64LE -> Word64LE -> [Word64LE] #

Num Word64LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

(+) :: Word64LE -> Word64LE -> Word64LE #

(-) :: Word64LE -> Word64LE -> Word64LE #

(*) :: Word64LE -> Word64LE -> Word64LE #

negate :: Word64LE -> Word64LE #

abs :: Word64LE -> Word64LE #

signum :: Word64LE -> Word64LE #

fromInteger :: Integer -> Word64LE #

Integral Word64LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

quot :: Word64LE -> Word64LE -> Word64LE #

rem :: Word64LE -> Word64LE -> Word64LE #

div :: Word64LE -> Word64LE -> Word64LE #

mod :: Word64LE -> Word64LE -> Word64LE #

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

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

toInteger :: Word64LE -> Integer #

Real Word64LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

toRational :: Word64LE -> Rational #

Show Word64LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

showsPrec :: Int -> Word64LE -> ShowS #

show :: Word64LE -> String #

showList :: [Word64LE] -> ShowS #

Binary Word64LE Source # 
Instance details

Defined in Dahdit.Binary

Methods

byteSize :: Word64LE -> ByteCount Source #

get :: Get Word64LE Source #

put :: Word64LE -> Put Source #

StaticByteSized Word64LE Source # 
Instance details

Defined in Dahdit.Sizes

Associated Types

type StaticSize Word64LE :: Nat Source #

Methods

staticByteSize :: Proxy Word64LE -> ByteCount Source #

Default Word64LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

def :: Word64LE #

Eq Word64LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

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

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

Ord Word64LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

compare :: Word64LE -> Word64LE -> Ordering #

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

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

(>) :: Word64LE -> Word64LE -> Bool #

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

max :: Word64LE -> Word64LE -> Word64LE #

min :: Word64LE -> Word64LE -> Word64LE #

Prim Word64LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

sizeOfType# :: Proxy Word64LE -> Int# #

sizeOf# :: Word64LE -> Int# #

alignmentOfType# :: Proxy Word64LE -> Int# #

alignment# :: Word64LE -> Int# #

indexByteArray# :: ByteArray# -> Int# -> Word64LE #

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word64LE #) #

writeByteArray# :: MutableByteArray# s -> Int# -> Word64LE -> State# s -> State# s #

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word64LE -> State# s -> State# s #

indexOffAddr# :: Addr# -> Int# -> Word64LE #

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Word64LE #) #

writeOffAddr# :: Addr# -> Int# -> Word64LE -> State# s -> State# s #

setOffAddr# :: Addr# -> Int# -> Int# -> Word64LE -> State# s -> State# s #

PrimUnaligned Word64LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

indexUnalignedByteArray# :: ByteArray# -> Int# -> Word64LE #

readUnalignedByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word64LE #) #

writeUnalignedByteArray# :: MutableByteArray# s -> Int# -> Word64LE -> State# s -> State# s #

type StaticSize Word64LE Source # 
Instance details

Defined in Dahdit.Sizes

type StaticSize Word64LE = 8

newtype Int64LE Source #

Constructors

Int64LE 

Fields

Instances

Instances details
Bits Int64LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

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

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

xor :: Int64LE -> Int64LE -> Int64LE #

complement :: Int64LE -> Int64LE #

shift :: Int64LE -> Int -> Int64LE #

rotate :: Int64LE -> Int -> Int64LE #

zeroBits :: Int64LE #

bit :: Int -> Int64LE #

setBit :: Int64LE -> Int -> Int64LE #

clearBit :: Int64LE -> Int -> Int64LE #

complementBit :: Int64LE -> Int -> Int64LE #

testBit :: Int64LE -> Int -> Bool #

bitSizeMaybe :: Int64LE -> Maybe Int #

bitSize :: Int64LE -> Int #

isSigned :: Int64LE -> Bool #

shiftL :: Int64LE -> Int -> Int64LE #

unsafeShiftL :: Int64LE -> Int -> Int64LE #

shiftR :: Int64LE -> Int -> Int64LE #

unsafeShiftR :: Int64LE -> Int -> Int64LE #

rotateL :: Int64LE -> Int -> Int64LE #

rotateR :: Int64LE -> Int -> Int64LE #

popCount :: Int64LE -> Int #

FiniteBits Int64LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

finiteBitSize :: Int64LE -> Int #

countLeadingZeros :: Int64LE -> Int #

countTrailingZeros :: Int64LE -> Int #

Bounded Int64LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

minBound :: Int64LE #

maxBound :: Int64LE #

Enum Int64LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

succ :: Int64LE -> Int64LE #

pred :: Int64LE -> Int64LE #

toEnum :: Int -> Int64LE #

fromEnum :: Int64LE -> Int #

enumFrom :: Int64LE -> [Int64LE] #

enumFromThen :: Int64LE -> Int64LE -> [Int64LE] #

enumFromTo :: Int64LE -> Int64LE -> [Int64LE] #

enumFromThenTo :: Int64LE -> Int64LE -> Int64LE -> [Int64LE] #

Num Int64LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

(+) :: Int64LE -> Int64LE -> Int64LE #

(-) :: Int64LE -> Int64LE -> Int64LE #

(*) :: Int64LE -> Int64LE -> Int64LE #

negate :: Int64LE -> Int64LE #

abs :: Int64LE -> Int64LE #

signum :: Int64LE -> Int64LE #

fromInteger :: Integer -> Int64LE #

Integral Int64LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

quot :: Int64LE -> Int64LE -> Int64LE #

rem :: Int64LE -> Int64LE -> Int64LE #

div :: Int64LE -> Int64LE -> Int64LE #

mod :: Int64LE -> Int64LE -> Int64LE #

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

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

toInteger :: Int64LE -> Integer #

Real Int64LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

toRational :: Int64LE -> Rational #

Show Int64LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

showsPrec :: Int -> Int64LE -> ShowS #

show :: Int64LE -> String #

showList :: [Int64LE] -> ShowS #

Binary Int64LE Source # 
Instance details

Defined in Dahdit.Binary

Methods

byteSize :: Int64LE -> ByteCount Source #

get :: Get Int64LE Source #

put :: Int64LE -> Put Source #

StaticByteSized Int64LE Source # 
Instance details

Defined in Dahdit.Sizes

Associated Types

type StaticSize Int64LE :: Nat Source #

Methods

staticByteSize :: Proxy Int64LE -> ByteCount Source #

Default Int64LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

def :: Int64LE #

Eq Int64LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

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

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

Ord Int64LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

compare :: Int64LE -> Int64LE -> Ordering #

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

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

(>) :: Int64LE -> Int64LE -> Bool #

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

max :: Int64LE -> Int64LE -> Int64LE #

min :: Int64LE -> Int64LE -> Int64LE #

Prim Int64LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

sizeOfType# :: Proxy Int64LE -> Int# #

sizeOf# :: Int64LE -> Int# #

alignmentOfType# :: Proxy Int64LE -> Int# #

alignment# :: Int64LE -> Int# #

indexByteArray# :: ByteArray# -> Int# -> Int64LE #

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int64LE #) #

writeByteArray# :: MutableByteArray# s -> Int# -> Int64LE -> State# s -> State# s #

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int64LE -> State# s -> State# s #

indexOffAddr# :: Addr# -> Int# -> Int64LE #

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Int64LE #) #

writeOffAddr# :: Addr# -> Int# -> Int64LE -> State# s -> State# s #

setOffAddr# :: Addr# -> Int# -> Int# -> Int64LE -> State# s -> State# s #

PrimUnaligned Int64LE Source # 
Instance details

Defined in Dahdit.Nums

Methods

indexUnalignedByteArray# :: ByteArray# -> Int# -> Int64LE #

readUnalignedByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int64LE #) #

writeUnalignedByteArray# :: MutableByteArray# s -> Int# -> Int64LE -> State# s -> State# s #

type StaticSize Int64LE Source # 
Instance details

Defined in Dahdit.Sizes

type StaticSize Int64LE = 8

newtype FloatLE Source #

Constructors

FloatLE 

Fields

Instances

Instances details
Floating FloatLE Source # 
Instance details

Defined in Dahdit.Nums

Methods

pi :: FloatLE #

exp :: FloatLE -> FloatLE #

log :: FloatLE -> FloatLE #

sqrt :: FloatLE -> FloatLE #

(**) :: FloatLE -> FloatLE -> FloatLE #

logBase :: FloatLE -> FloatLE -> FloatLE #

sin :: FloatLE -> FloatLE #

cos :: FloatLE -> FloatLE #

tan :: FloatLE -> FloatLE #

asin :: FloatLE -> FloatLE #

acos :: FloatLE -> FloatLE #

atan :: FloatLE -> FloatLE #

sinh :: FloatLE -> FloatLE #

cosh :: FloatLE -> FloatLE #

tanh :: FloatLE -> FloatLE #

asinh :: FloatLE -> FloatLE #

acosh :: FloatLE -> FloatLE #

atanh :: FloatLE -> FloatLE #

log1p :: FloatLE -> FloatLE #

expm1 :: FloatLE -> FloatLE #

log1pexp :: FloatLE -> FloatLE #

log1mexp :: FloatLE -> FloatLE #

Num FloatLE Source # 
Instance details

Defined in Dahdit.Nums

Methods

(+) :: FloatLE -> FloatLE -> FloatLE #

(-) :: FloatLE -> FloatLE -> FloatLE #

(*) :: FloatLE -> FloatLE -> FloatLE #

negate :: FloatLE -> FloatLE #

abs :: FloatLE -> FloatLE #

signum :: FloatLE -> FloatLE #

fromInteger :: Integer -> FloatLE #

Fractional FloatLE Source # 
Instance details

Defined in Dahdit.Nums

Methods

(/) :: FloatLE -> FloatLE -> FloatLE #

recip :: FloatLE -> FloatLE #

fromRational :: Rational -> FloatLE #

Real FloatLE Source # 
Instance details

Defined in Dahdit.Nums

Methods

toRational :: FloatLE -> Rational #

RealFrac FloatLE Source # 
Instance details

Defined in Dahdit.Nums

Methods

properFraction :: Integral b => FloatLE -> (b, FloatLE) #

truncate :: Integral b => FloatLE -> b #

round :: Integral b => FloatLE -> b #

ceiling :: Integral b => FloatLE -> b #

floor :: Integral b => FloatLE -> b #

Show FloatLE Source # 
Instance details

Defined in Dahdit.Nums

Methods

showsPrec :: Int -> FloatLE -> ShowS #

show :: FloatLE -> String #

showList :: [FloatLE] -> ShowS #

Binary FloatLE Source # 
Instance details

Defined in Dahdit.Binary

Methods

byteSize :: FloatLE -> ByteCount Source #

get :: Get FloatLE Source #

put :: FloatLE -> Put Source #

StaticByteSized FloatLE Source # 
Instance details

Defined in Dahdit.Sizes

Associated Types

type StaticSize FloatLE :: Nat Source #

Methods

staticByteSize :: Proxy FloatLE -> ByteCount Source #

Default FloatLE Source # 
Instance details

Defined in Dahdit.Nums

Methods

def :: FloatLE #

Eq FloatLE Source # 
Instance details

Defined in Dahdit.Nums

Methods

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

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

Ord FloatLE Source # 
Instance details

Defined in Dahdit.Nums

Methods

compare :: FloatLE -> FloatLE -> Ordering #

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

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

(>) :: FloatLE -> FloatLE -> Bool #

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

max :: FloatLE -> FloatLE -> FloatLE #

min :: FloatLE -> FloatLE -> FloatLE #

Prim FloatLE Source # 
Instance details

Defined in Dahdit.Nums

Methods

sizeOfType# :: Proxy FloatLE -> Int# #

sizeOf# :: FloatLE -> Int# #

alignmentOfType# :: Proxy FloatLE -> Int# #

alignment# :: FloatLE -> Int# #

indexByteArray# :: ByteArray# -> Int# -> FloatLE #

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, FloatLE #) #

writeByteArray# :: MutableByteArray# s -> Int# -> FloatLE -> State# s -> State# s #

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> FloatLE -> State# s -> State# s #

indexOffAddr# :: Addr# -> Int# -> FloatLE #

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, FloatLE #) #

writeOffAddr# :: Addr# -> Int# -> FloatLE -> State# s -> State# s #

setOffAddr# :: Addr# -> Int# -> Int# -> FloatLE -> State# s -> State# s #

PrimUnaligned FloatLE Source # 
Instance details

Defined in Dahdit.Nums

Methods

indexUnalignedByteArray# :: ByteArray# -> Int# -> FloatLE #

readUnalignedByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, FloatLE #) #

writeUnalignedByteArray# :: MutableByteArray# s -> Int# -> FloatLE -> State# s -> State# s #

type StaticSize FloatLE Source # 
Instance details

Defined in Dahdit.Sizes

type StaticSize FloatLE = 4

newtype DoubleLE Source #

Constructors

DoubleLE 

Fields

Instances

Instances details
Floating DoubleLE Source # 
Instance details

Defined in Dahdit.Nums

Methods

pi :: DoubleLE #

exp :: DoubleLE -> DoubleLE #

log :: DoubleLE -> DoubleLE #

sqrt :: DoubleLE -> DoubleLE #

(**) :: DoubleLE -> DoubleLE -> DoubleLE #

logBase :: DoubleLE -> DoubleLE -> DoubleLE #

sin :: DoubleLE -> DoubleLE #

cos :: DoubleLE -> DoubleLE #

tan :: DoubleLE -> DoubleLE #

asin :: DoubleLE -> DoubleLE #

acos :: DoubleLE -> DoubleLE #

atan :: DoubleLE -> DoubleLE #

sinh :: DoubleLE -> DoubleLE #

cosh :: DoubleLE -> DoubleLE #

tanh :: DoubleLE -> DoubleLE #

asinh :: DoubleLE -> DoubleLE #

acosh :: DoubleLE -> DoubleLE #

atanh :: DoubleLE -> DoubleLE #

log1p :: DoubleLE -> DoubleLE #

expm1 :: DoubleLE -> DoubleLE #

log1pexp :: DoubleLE -> DoubleLE #

log1mexp :: DoubleLE -> DoubleLE #

Num DoubleLE Source # 
Instance details

Defined in Dahdit.Nums

Methods

(+) :: DoubleLE -> DoubleLE -> DoubleLE #

(-) :: DoubleLE -> DoubleLE -> DoubleLE #

(*) :: DoubleLE -> DoubleLE -> DoubleLE #

negate :: DoubleLE -> DoubleLE #

abs :: DoubleLE -> DoubleLE #

signum :: DoubleLE -> DoubleLE #

fromInteger :: Integer -> DoubleLE #

Fractional DoubleLE Source # 
Instance details

Defined in Dahdit.Nums

Methods

(/) :: DoubleLE -> DoubleLE -> DoubleLE #

recip :: DoubleLE -> DoubleLE #

fromRational :: Rational -> DoubleLE #

Real DoubleLE Source # 
Instance details

Defined in Dahdit.Nums

Methods

toRational :: DoubleLE -> Rational #

RealFrac DoubleLE Source # 
Instance details

Defined in Dahdit.Nums

Methods

properFraction :: Integral b => DoubleLE -> (b, DoubleLE) #

truncate :: Integral b => DoubleLE -> b #

round :: Integral b => DoubleLE -> b #

ceiling :: Integral b => DoubleLE -> b #

floor :: Integral b => DoubleLE -> b #

Show DoubleLE Source # 
Instance details

Defined in Dahdit.Nums

Methods

showsPrec :: Int -> DoubleLE -> ShowS #

show :: DoubleLE -> String #

showList :: [DoubleLE] -> ShowS #

Binary DoubleLE Source # 
Instance details

Defined in Dahdit.Binary

Methods

byteSize :: DoubleLE -> ByteCount Source #

get :: Get DoubleLE Source #

put :: DoubleLE -> Put Source #

StaticByteSized DoubleLE Source # 
Instance details

Defined in Dahdit.Sizes

Associated Types

type StaticSize DoubleLE :: Nat Source #

Methods

staticByteSize :: Proxy DoubleLE -> ByteCount Source #

Default DoubleLE Source # 
Instance details

Defined in Dahdit.Nums

Methods

def :: DoubleLE #

Eq DoubleLE Source # 
Instance details

Defined in Dahdit.Nums

Methods

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

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

Ord DoubleLE Source # 
Instance details

Defined in Dahdit.Nums

Methods

compare :: DoubleLE -> DoubleLE -> Ordering #

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

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

(>) :: DoubleLE -> DoubleLE -> Bool #

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

max :: DoubleLE -> DoubleLE -> DoubleLE #

min :: DoubleLE -> DoubleLE -> DoubleLE #

Prim DoubleLE Source # 
Instance details

Defined in Dahdit.Nums

Methods

sizeOfType# :: Proxy DoubleLE -> Int# #

sizeOf# :: DoubleLE -> Int# #

alignmentOfType# :: Proxy DoubleLE -> Int# #

alignment# :: DoubleLE -> Int# #

indexByteArray# :: ByteArray# -> Int# -> DoubleLE #

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, DoubleLE #) #

writeByteArray# :: MutableByteArray# s -> Int# -> DoubleLE -> State# s -> State# s #

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> DoubleLE -> State# s -> State# s #

indexOffAddr# :: Addr# -> Int# -> DoubleLE #

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, DoubleLE #) #

writeOffAddr# :: Addr# -> Int# -> DoubleLE -> State# s -> State# s #

setOffAddr# :: Addr# -> Int# -> Int# -> DoubleLE -> State# s -> State# s #

PrimUnaligned DoubleLE Source # 
Instance details

Defined in Dahdit.Nums

Methods

indexUnalignedByteArray# :: ByteArray# -> Int# -> DoubleLE #

readUnalignedByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, DoubleLE #) #

writeUnalignedByteArray# :: MutableByteArray# s -> Int# -> DoubleLE -> State# s -> State# s #

type StaticSize DoubleLE Source # 
Instance details

Defined in Dahdit.Sizes

type StaticSize DoubleLE = 8

newtype Word16BE Source #

Constructors

Word16BE 

Fields

Instances

Instances details
Bits Word16BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

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

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

xor :: Word16BE -> Word16BE -> Word16BE #

complement :: Word16BE -> Word16BE #

shift :: Word16BE -> Int -> Word16BE #

rotate :: Word16BE -> Int -> Word16BE #

zeroBits :: Word16BE #

bit :: Int -> Word16BE #

setBit :: Word16BE -> Int -> Word16BE #

clearBit :: Word16BE -> Int -> Word16BE #

complementBit :: Word16BE -> Int -> Word16BE #

testBit :: Word16BE -> Int -> Bool #

bitSizeMaybe :: Word16BE -> Maybe Int #

bitSize :: Word16BE -> Int #

isSigned :: Word16BE -> Bool #

shiftL :: Word16BE -> Int -> Word16BE #

unsafeShiftL :: Word16BE -> Int -> Word16BE #

shiftR :: Word16BE -> Int -> Word16BE #

unsafeShiftR :: Word16BE -> Int -> Word16BE #

rotateL :: Word16BE -> Int -> Word16BE #

rotateR :: Word16BE -> Int -> Word16BE #

popCount :: Word16BE -> Int #

FiniteBits Word16BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

finiteBitSize :: Word16BE -> Int #

countLeadingZeros :: Word16BE -> Int #

countTrailingZeros :: Word16BE -> Int #

Bounded Word16BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

minBound :: Word16BE #

maxBound :: Word16BE #

Enum Word16BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

succ :: Word16BE -> Word16BE #

pred :: Word16BE -> Word16BE #

toEnum :: Int -> Word16BE #

fromEnum :: Word16BE -> Int #

enumFrom :: Word16BE -> [Word16BE] #

enumFromThen :: Word16BE -> Word16BE -> [Word16BE] #

enumFromTo :: Word16BE -> Word16BE -> [Word16BE] #

enumFromThenTo :: Word16BE -> Word16BE -> Word16BE -> [Word16BE] #

Num Word16BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

(+) :: Word16BE -> Word16BE -> Word16BE #

(-) :: Word16BE -> Word16BE -> Word16BE #

(*) :: Word16BE -> Word16BE -> Word16BE #

negate :: Word16BE -> Word16BE #

abs :: Word16BE -> Word16BE #

signum :: Word16BE -> Word16BE #

fromInteger :: Integer -> Word16BE #

Integral Word16BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

quot :: Word16BE -> Word16BE -> Word16BE #

rem :: Word16BE -> Word16BE -> Word16BE #

div :: Word16BE -> Word16BE -> Word16BE #

mod :: Word16BE -> Word16BE -> Word16BE #

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

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

toInteger :: Word16BE -> Integer #

Real Word16BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

toRational :: Word16BE -> Rational #

Show Word16BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

showsPrec :: Int -> Word16BE -> ShowS #

show :: Word16BE -> String #

showList :: [Word16BE] -> ShowS #

Binary Word16BE Source # 
Instance details

Defined in Dahdit.Binary

Methods

byteSize :: Word16BE -> ByteCount Source #

get :: Get Word16BE Source #

put :: Word16BE -> Put Source #

StaticByteSized Word16BE Source # 
Instance details

Defined in Dahdit.Sizes

Associated Types

type StaticSize Word16BE :: Nat Source #

Methods

staticByteSize :: Proxy Word16BE -> ByteCount Source #

Default Word16BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

def :: Word16BE #

Eq Word16BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

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

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

Ord Word16BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

compare :: Word16BE -> Word16BE -> Ordering #

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

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

(>) :: Word16BE -> Word16BE -> Bool #

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

max :: Word16BE -> Word16BE -> Word16BE #

min :: Word16BE -> Word16BE -> Word16BE #

Prim Word16BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

sizeOfType# :: Proxy Word16BE -> Int# #

sizeOf# :: Word16BE -> Int# #

alignmentOfType# :: Proxy Word16BE -> Int# #

alignment# :: Word16BE -> Int# #

indexByteArray# :: ByteArray# -> Int# -> Word16BE #

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word16BE #) #

writeByteArray# :: MutableByteArray# s -> Int# -> Word16BE -> State# s -> State# s #

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word16BE -> State# s -> State# s #

indexOffAddr# :: Addr# -> Int# -> Word16BE #

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Word16BE #) #

writeOffAddr# :: Addr# -> Int# -> Word16BE -> State# s -> State# s #

setOffAddr# :: Addr# -> Int# -> Int# -> Word16BE -> State# s -> State# s #

PrimUnaligned Word16BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

indexUnalignedByteArray# :: ByteArray# -> Int# -> Word16BE #

readUnalignedByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word16BE #) #

writeUnalignedByteArray# :: MutableByteArray# s -> Int# -> Word16BE -> State# s -> State# s #

type StaticSize Word16BE Source # 
Instance details

Defined in Dahdit.Sizes

type StaticSize Word16BE = 2

newtype Int16BE Source #

Constructors

Int16BE 

Fields

Instances

Instances details
Bits Int16BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

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

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

xor :: Int16BE -> Int16BE -> Int16BE #

complement :: Int16BE -> Int16BE #

shift :: Int16BE -> Int -> Int16BE #

rotate :: Int16BE -> Int -> Int16BE #

zeroBits :: Int16BE #

bit :: Int -> Int16BE #

setBit :: Int16BE -> Int -> Int16BE #

clearBit :: Int16BE -> Int -> Int16BE #

complementBit :: Int16BE -> Int -> Int16BE #

testBit :: Int16BE -> Int -> Bool #

bitSizeMaybe :: Int16BE -> Maybe Int #

bitSize :: Int16BE -> Int #

isSigned :: Int16BE -> Bool #

shiftL :: Int16BE -> Int -> Int16BE #

unsafeShiftL :: Int16BE -> Int -> Int16BE #

shiftR :: Int16BE -> Int -> Int16BE #

unsafeShiftR :: Int16BE -> Int -> Int16BE #

rotateL :: Int16BE -> Int -> Int16BE #

rotateR :: Int16BE -> Int -> Int16BE #

popCount :: Int16BE -> Int #

FiniteBits Int16BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

finiteBitSize :: Int16BE -> Int #

countLeadingZeros :: Int16BE -> Int #

countTrailingZeros :: Int16BE -> Int #

Bounded Int16BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

minBound :: Int16BE #

maxBound :: Int16BE #

Enum Int16BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

succ :: Int16BE -> Int16BE #

pred :: Int16BE -> Int16BE #

toEnum :: Int -> Int16BE #

fromEnum :: Int16BE -> Int #

enumFrom :: Int16BE -> [Int16BE] #

enumFromThen :: Int16BE -> Int16BE -> [Int16BE] #

enumFromTo :: Int16BE -> Int16BE -> [Int16BE] #

enumFromThenTo :: Int16BE -> Int16BE -> Int16BE -> [Int16BE] #

Num Int16BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

(+) :: Int16BE -> Int16BE -> Int16BE #

(-) :: Int16BE -> Int16BE -> Int16BE #

(*) :: Int16BE -> Int16BE -> Int16BE #

negate :: Int16BE -> Int16BE #

abs :: Int16BE -> Int16BE #

signum :: Int16BE -> Int16BE #

fromInteger :: Integer -> Int16BE #

Integral Int16BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

quot :: Int16BE -> Int16BE -> Int16BE #

rem :: Int16BE -> Int16BE -> Int16BE #

div :: Int16BE -> Int16BE -> Int16BE #

mod :: Int16BE -> Int16BE -> Int16BE #

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

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

toInteger :: Int16BE -> Integer #

Real Int16BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

toRational :: Int16BE -> Rational #

Show Int16BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

showsPrec :: Int -> Int16BE -> ShowS #

show :: Int16BE -> String #

showList :: [Int16BE] -> ShowS #

Binary Int16BE Source # 
Instance details

Defined in Dahdit.Binary

Methods

byteSize :: Int16BE -> ByteCount Source #

get :: Get Int16BE Source #

put :: Int16BE -> Put Source #

StaticByteSized Int16BE Source # 
Instance details

Defined in Dahdit.Sizes

Associated Types

type StaticSize Int16BE :: Nat Source #

Methods

staticByteSize :: Proxy Int16BE -> ByteCount Source #

Default Int16BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

def :: Int16BE #

Eq Int16BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

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

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

Ord Int16BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

compare :: Int16BE -> Int16BE -> Ordering #

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

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

(>) :: Int16BE -> Int16BE -> Bool #

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

max :: Int16BE -> Int16BE -> Int16BE #

min :: Int16BE -> Int16BE -> Int16BE #

Prim Int16BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

sizeOfType# :: Proxy Int16BE -> Int# #

sizeOf# :: Int16BE -> Int# #

alignmentOfType# :: Proxy Int16BE -> Int# #

alignment# :: Int16BE -> Int# #

indexByteArray# :: ByteArray# -> Int# -> Int16BE #

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int16BE #) #

writeByteArray# :: MutableByteArray# s -> Int# -> Int16BE -> State# s -> State# s #

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int16BE -> State# s -> State# s #

indexOffAddr# :: Addr# -> Int# -> Int16BE #

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Int16BE #) #

writeOffAddr# :: Addr# -> Int# -> Int16BE -> State# s -> State# s #

setOffAddr# :: Addr# -> Int# -> Int# -> Int16BE -> State# s -> State# s #

PrimUnaligned Int16BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

indexUnalignedByteArray# :: ByteArray# -> Int# -> Int16BE #

readUnalignedByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int16BE #) #

writeUnalignedByteArray# :: MutableByteArray# s -> Int# -> Int16BE -> State# s -> State# s #

type StaticSize Int16BE Source # 
Instance details

Defined in Dahdit.Sizes

type StaticSize Int16BE = 2

newtype Word24BE Source #

Constructors

Word24BE 

Fields

Instances

Instances details
Bits Word24BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

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

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

xor :: Word24BE -> Word24BE -> Word24BE #

complement :: Word24BE -> Word24BE #

shift :: Word24BE -> Int -> Word24BE #

rotate :: Word24BE -> Int -> Word24BE #

zeroBits :: Word24BE #

bit :: Int -> Word24BE #

setBit :: Word24BE -> Int -> Word24BE #

clearBit :: Word24BE -> Int -> Word24BE #

complementBit :: Word24BE -> Int -> Word24BE #

testBit :: Word24BE -> Int -> Bool #

bitSizeMaybe :: Word24BE -> Maybe Int #

bitSize :: Word24BE -> Int #

isSigned :: Word24BE -> Bool #

shiftL :: Word24BE -> Int -> Word24BE #

unsafeShiftL :: Word24BE -> Int -> Word24BE #

shiftR :: Word24BE -> Int -> Word24BE #

unsafeShiftR :: Word24BE -> Int -> Word24BE #

rotateL :: Word24BE -> Int -> Word24BE #

rotateR :: Word24BE -> Int -> Word24BE #

popCount :: Word24BE -> Int #

FiniteBits Word24BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

finiteBitSize :: Word24BE -> Int #

countLeadingZeros :: Word24BE -> Int #

countTrailingZeros :: Word24BE -> Int #

Bounded Word24BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

minBound :: Word24BE #

maxBound :: Word24BE #

Enum Word24BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

succ :: Word24BE -> Word24BE #

pred :: Word24BE -> Word24BE #

toEnum :: Int -> Word24BE #

fromEnum :: Word24BE -> Int #

enumFrom :: Word24BE -> [Word24BE] #

enumFromThen :: Word24BE -> Word24BE -> [Word24BE] #

enumFromTo :: Word24BE -> Word24BE -> [Word24BE] #

enumFromThenTo :: Word24BE -> Word24BE -> Word24BE -> [Word24BE] #

Num Word24BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

(+) :: Word24BE -> Word24BE -> Word24BE #

(-) :: Word24BE -> Word24BE -> Word24BE #

(*) :: Word24BE -> Word24BE -> Word24BE #

negate :: Word24BE -> Word24BE #

abs :: Word24BE -> Word24BE #

signum :: Word24BE -> Word24BE #

fromInteger :: Integer -> Word24BE #

Integral Word24BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

quot :: Word24BE -> Word24BE -> Word24BE #

rem :: Word24BE -> Word24BE -> Word24BE #

div :: Word24BE -> Word24BE -> Word24BE #

mod :: Word24BE -> Word24BE -> Word24BE #

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

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

toInteger :: Word24BE -> Integer #

Real Word24BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

toRational :: Word24BE -> Rational #

Show Word24BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

showsPrec :: Int -> Word24BE -> ShowS #

show :: Word24BE -> String #

showList :: [Word24BE] -> ShowS #

Binary Word24BE Source # 
Instance details

Defined in Dahdit.Binary

Methods

byteSize :: Word24BE -> ByteCount Source #

get :: Get Word24BE Source #

put :: Word24BE -> Put Source #

StaticByteSized Word24BE Source # 
Instance details

Defined in Dahdit.Sizes

Associated Types

type StaticSize Word24BE :: Nat Source #

Methods

staticByteSize :: Proxy Word24BE -> ByteCount Source #

Default Word24BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

def :: Word24BE #

Eq Word24BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

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

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

Ord Word24BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

compare :: Word24BE -> Word24BE -> Ordering #

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

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

(>) :: Word24BE -> Word24BE -> Bool #

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

max :: Word24BE -> Word24BE -> Word24BE #

min :: Word24BE -> Word24BE -> Word24BE #

Prim Word24BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

sizeOfType# :: Proxy Word24BE -> Int# #

sizeOf# :: Word24BE -> Int# #

alignmentOfType# :: Proxy Word24BE -> Int# #

alignment# :: Word24BE -> Int# #

indexByteArray# :: ByteArray# -> Int# -> Word24BE #

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word24BE #) #

writeByteArray# :: MutableByteArray# s -> Int# -> Word24BE -> State# s -> State# s #

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word24BE -> State# s -> State# s #

indexOffAddr# :: Addr# -> Int# -> Word24BE #

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Word24BE #) #

writeOffAddr# :: Addr# -> Int# -> Word24BE -> State# s -> State# s #

setOffAddr# :: Addr# -> Int# -> Int# -> Word24BE -> State# s -> State# s #

PrimUnaligned Word24BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

indexUnalignedByteArray# :: ByteArray# -> Int# -> Word24BE #

readUnalignedByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word24BE #) #

writeUnalignedByteArray# :: MutableByteArray# s -> Int# -> Word24BE -> State# s -> State# s #

type StaticSize Word24BE Source # 
Instance details

Defined in Dahdit.Sizes

type StaticSize Word24BE = 3

newtype Int24BE Source #

Constructors

Int24BE 

Fields

Instances

Instances details
Bits Int24BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

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

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

xor :: Int24BE -> Int24BE -> Int24BE #

complement :: Int24BE -> Int24BE #

shift :: Int24BE -> Int -> Int24BE #

rotate :: Int24BE -> Int -> Int24BE #

zeroBits :: Int24BE #

bit :: Int -> Int24BE #

setBit :: Int24BE -> Int -> Int24BE #

clearBit :: Int24BE -> Int -> Int24BE #

complementBit :: Int24BE -> Int -> Int24BE #

testBit :: Int24BE -> Int -> Bool #

bitSizeMaybe :: Int24BE -> Maybe Int #

bitSize :: Int24BE -> Int #

isSigned :: Int24BE -> Bool #

shiftL :: Int24BE -> Int -> Int24BE #

unsafeShiftL :: Int24BE -> Int -> Int24BE #

shiftR :: Int24BE -> Int -> Int24BE #

unsafeShiftR :: Int24BE -> Int -> Int24BE #

rotateL :: Int24BE -> Int -> Int24BE #

rotateR :: Int24BE -> Int -> Int24BE #

popCount :: Int24BE -> Int #

FiniteBits Int24BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

finiteBitSize :: Int24BE -> Int #

countLeadingZeros :: Int24BE -> Int #

countTrailingZeros :: Int24BE -> Int #

Bounded Int24BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

minBound :: Int24BE #

maxBound :: Int24BE #

Enum Int24BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

succ :: Int24BE -> Int24BE #

pred :: Int24BE -> Int24BE #

toEnum :: Int -> Int24BE #

fromEnum :: Int24BE -> Int #

enumFrom :: Int24BE -> [Int24BE] #

enumFromThen :: Int24BE -> Int24BE -> [Int24BE] #

enumFromTo :: Int24BE -> Int24BE -> [Int24BE] #

enumFromThenTo :: Int24BE -> Int24BE -> Int24BE -> [Int24BE] #

Num Int24BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

(+) :: Int24BE -> Int24BE -> Int24BE #

(-) :: Int24BE -> Int24BE -> Int24BE #

(*) :: Int24BE -> Int24BE -> Int24BE #

negate :: Int24BE -> Int24BE #

abs :: Int24BE -> Int24BE #

signum :: Int24BE -> Int24BE #

fromInteger :: Integer -> Int24BE #

Integral Int24BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

quot :: Int24BE -> Int24BE -> Int24BE #

rem :: Int24BE -> Int24BE -> Int24BE #

div :: Int24BE -> Int24BE -> Int24BE #

mod :: Int24BE -> Int24BE -> Int24BE #

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

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

toInteger :: Int24BE -> Integer #

Real Int24BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

toRational :: Int24BE -> Rational #

Show Int24BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

showsPrec :: Int -> Int24BE -> ShowS #

show :: Int24BE -> String #

showList :: [Int24BE] -> ShowS #

Binary Int24BE Source # 
Instance details

Defined in Dahdit.Binary

Methods

byteSize :: Int24BE -> ByteCount Source #

get :: Get Int24BE Source #

put :: Int24BE -> Put Source #

StaticByteSized Int24BE Source # 
Instance details

Defined in Dahdit.Sizes

Associated Types

type StaticSize Int24BE :: Nat Source #

Methods

staticByteSize :: Proxy Int24BE -> ByteCount Source #

Default Int24BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

def :: Int24BE #

Eq Int24BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

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

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

Ord Int24BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

compare :: Int24BE -> Int24BE -> Ordering #

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

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

(>) :: Int24BE -> Int24BE -> Bool #

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

max :: Int24BE -> Int24BE -> Int24BE #

min :: Int24BE -> Int24BE -> Int24BE #

Prim Int24BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

sizeOfType# :: Proxy Int24BE -> Int# #

sizeOf# :: Int24BE -> Int# #

alignmentOfType# :: Proxy Int24BE -> Int# #

alignment# :: Int24BE -> Int# #

indexByteArray# :: ByteArray# -> Int# -> Int24BE #

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int24BE #) #

writeByteArray# :: MutableByteArray# s -> Int# -> Int24BE -> State# s -> State# s #

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int24BE -> State# s -> State# s #

indexOffAddr# :: Addr# -> Int# -> Int24BE #

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Int24BE #) #

writeOffAddr# :: Addr# -> Int# -> Int24BE -> State# s -> State# s #

setOffAddr# :: Addr# -> Int# -> Int# -> Int24BE -> State# s -> State# s #

PrimUnaligned Int24BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

indexUnalignedByteArray# :: ByteArray# -> Int# -> Int24BE #

readUnalignedByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int24BE #) #

writeUnalignedByteArray# :: MutableByteArray# s -> Int# -> Int24BE -> State# s -> State# s #

type StaticSize Int24BE Source # 
Instance details

Defined in Dahdit.Sizes

type StaticSize Int24BE = 3

newtype Word32BE Source #

Constructors

Word32BE 

Fields

Instances

Instances details
Bits Word32BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

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

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

xor :: Word32BE -> Word32BE -> Word32BE #

complement :: Word32BE -> Word32BE #

shift :: Word32BE -> Int -> Word32BE #

rotate :: Word32BE -> Int -> Word32BE #

zeroBits :: Word32BE #

bit :: Int -> Word32BE #

setBit :: Word32BE -> Int -> Word32BE #

clearBit :: Word32BE -> Int -> Word32BE #

complementBit :: Word32BE -> Int -> Word32BE #

testBit :: Word32BE -> Int -> Bool #

bitSizeMaybe :: Word32BE -> Maybe Int #

bitSize :: Word32BE -> Int #

isSigned :: Word32BE -> Bool #

shiftL :: Word32BE -> Int -> Word32BE #

unsafeShiftL :: Word32BE -> Int -> Word32BE #

shiftR :: Word32BE -> Int -> Word32BE #

unsafeShiftR :: Word32BE -> Int -> Word32BE #

rotateL :: Word32BE -> Int -> Word32BE #

rotateR :: Word32BE -> Int -> Word32BE #

popCount :: Word32BE -> Int #

FiniteBits Word32BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

finiteBitSize :: Word32BE -> Int #

countLeadingZeros :: Word32BE -> Int #

countTrailingZeros :: Word32BE -> Int #

Bounded Word32BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

minBound :: Word32BE #

maxBound :: Word32BE #

Enum Word32BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

succ :: Word32BE -> Word32BE #

pred :: Word32BE -> Word32BE #

toEnum :: Int -> Word32BE #

fromEnum :: Word32BE -> Int #

enumFrom :: Word32BE -> [Word32BE] #

enumFromThen :: Word32BE -> Word32BE -> [Word32BE] #

enumFromTo :: Word32BE -> Word32BE -> [Word32BE] #

enumFromThenTo :: Word32BE -> Word32BE -> Word32BE -> [Word32BE] #

Num Word32BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

(+) :: Word32BE -> Word32BE -> Word32BE #

(-) :: Word32BE -> Word32BE -> Word32BE #

(*) :: Word32BE -> Word32BE -> Word32BE #

negate :: Word32BE -> Word32BE #

abs :: Word32BE -> Word32BE #

signum :: Word32BE -> Word32BE #

fromInteger :: Integer -> Word32BE #

Integral Word32BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

quot :: Word32BE -> Word32BE -> Word32BE #

rem :: Word32BE -> Word32BE -> Word32BE #

div :: Word32BE -> Word32BE -> Word32BE #

mod :: Word32BE -> Word32BE -> Word32BE #

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

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

toInteger :: Word32BE -> Integer #

Real Word32BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

toRational :: Word32BE -> Rational #

Show Word32BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

showsPrec :: Int -> Word32BE -> ShowS #

show :: Word32BE -> String #

showList :: [Word32BE] -> ShowS #

Binary Word32BE Source # 
Instance details

Defined in Dahdit.Binary

Methods

byteSize :: Word32BE -> ByteCount Source #

get :: Get Word32BE Source #

put :: Word32BE -> Put Source #

StaticByteSized Word32BE Source # 
Instance details

Defined in Dahdit.Sizes

Associated Types

type StaticSize Word32BE :: Nat Source #

Methods

staticByteSize :: Proxy Word32BE -> ByteCount Source #

Default Word32BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

def :: Word32BE #

Eq Word32BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

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

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

Ord Word32BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

compare :: Word32BE -> Word32BE -> Ordering #

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

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

(>) :: Word32BE -> Word32BE -> Bool #

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

max :: Word32BE -> Word32BE -> Word32BE #

min :: Word32BE -> Word32BE -> Word32BE #

Prim Word32BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

sizeOfType# :: Proxy Word32BE -> Int# #

sizeOf# :: Word32BE -> Int# #

alignmentOfType# :: Proxy Word32BE -> Int# #

alignment# :: Word32BE -> Int# #

indexByteArray# :: ByteArray# -> Int# -> Word32BE #

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word32BE #) #

writeByteArray# :: MutableByteArray# s -> Int# -> Word32BE -> State# s -> State# s #

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word32BE -> State# s -> State# s #

indexOffAddr# :: Addr# -> Int# -> Word32BE #

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Word32BE #) #

writeOffAddr# :: Addr# -> Int# -> Word32BE -> State# s -> State# s #

setOffAddr# :: Addr# -> Int# -> Int# -> Word32BE -> State# s -> State# s #

PrimUnaligned Word32BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

indexUnalignedByteArray# :: ByteArray# -> Int# -> Word32BE #

readUnalignedByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word32BE #) #

writeUnalignedByteArray# :: MutableByteArray# s -> Int# -> Word32BE -> State# s -> State# s #

type StaticSize Word32BE Source # 
Instance details

Defined in Dahdit.Sizes

type StaticSize Word32BE = 4

newtype Int32BE Source #

Constructors

Int32BE 

Fields

Instances

Instances details
Bits Int32BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

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

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

xor :: Int32BE -> Int32BE -> Int32BE #

complement :: Int32BE -> Int32BE #

shift :: Int32BE -> Int -> Int32BE #

rotate :: Int32BE -> Int -> Int32BE #

zeroBits :: Int32BE #

bit :: Int -> Int32BE #

setBit :: Int32BE -> Int -> Int32BE #

clearBit :: Int32BE -> Int -> Int32BE #

complementBit :: Int32BE -> Int -> Int32BE #

testBit :: Int32BE -> Int -> Bool #

bitSizeMaybe :: Int32BE -> Maybe Int #

bitSize :: Int32BE -> Int #

isSigned :: Int32BE -> Bool #

shiftL :: Int32BE -> Int -> Int32BE #

unsafeShiftL :: Int32BE -> Int -> Int32BE #

shiftR :: Int32BE -> Int -> Int32BE #

unsafeShiftR :: Int32BE -> Int -> Int32BE #

rotateL :: Int32BE -> Int -> Int32BE #

rotateR :: Int32BE -> Int -> Int32BE #

popCount :: Int32BE -> Int #

FiniteBits Int32BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

finiteBitSize :: Int32BE -> Int #

countLeadingZeros :: Int32BE -> Int #

countTrailingZeros :: Int32BE -> Int #

Bounded Int32BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

minBound :: Int32BE #

maxBound :: Int32BE #

Enum Int32BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

succ :: Int32BE -> Int32BE #

pred :: Int32BE -> Int32BE #

toEnum :: Int -> Int32BE #

fromEnum :: Int32BE -> Int #

enumFrom :: Int32BE -> [Int32BE] #

enumFromThen :: Int32BE -> Int32BE -> [Int32BE] #

enumFromTo :: Int32BE -> Int32BE -> [Int32BE] #

enumFromThenTo :: Int32BE -> Int32BE -> Int32BE -> [Int32BE] #

Num Int32BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

(+) :: Int32BE -> Int32BE -> Int32BE #

(-) :: Int32BE -> Int32BE -> Int32BE #

(*) :: Int32BE -> Int32BE -> Int32BE #

negate :: Int32BE -> Int32BE #

abs :: Int32BE -> Int32BE #

signum :: Int32BE -> Int32BE #

fromInteger :: Integer -> Int32BE #

Integral Int32BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

quot :: Int32BE -> Int32BE -> Int32BE #

rem :: Int32BE -> Int32BE -> Int32BE #

div :: Int32BE -> Int32BE -> Int32BE #

mod :: Int32BE -> Int32BE -> Int32BE #

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

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

toInteger :: Int32BE -> Integer #

Real Int32BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

toRational :: Int32BE -> Rational #

Show Int32BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

showsPrec :: Int -> Int32BE -> ShowS #

show :: Int32BE -> String #

showList :: [Int32BE] -> ShowS #

Binary Int32BE Source # 
Instance details

Defined in Dahdit.Binary

Methods

byteSize :: Int32BE -> ByteCount Source #

get :: Get Int32BE Source #

put :: Int32BE -> Put Source #

StaticByteSized Int32BE Source # 
Instance details

Defined in Dahdit.Sizes

Associated Types

type StaticSize Int32BE :: Nat Source #

Methods

staticByteSize :: Proxy Int32BE -> ByteCount Source #

Default Int32BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

def :: Int32BE #

Eq Int32BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

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

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

Ord Int32BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

compare :: Int32BE -> Int32BE -> Ordering #

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

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

(>) :: Int32BE -> Int32BE -> Bool #

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

max :: Int32BE -> Int32BE -> Int32BE #

min :: Int32BE -> Int32BE -> Int32BE #

Prim Int32BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

sizeOfType# :: Proxy Int32BE -> Int# #

sizeOf# :: Int32BE -> Int# #

alignmentOfType# :: Proxy Int32BE -> Int# #

alignment# :: Int32BE -> Int# #

indexByteArray# :: ByteArray# -> Int# -> Int32BE #

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int32BE #) #

writeByteArray# :: MutableByteArray# s -> Int# -> Int32BE -> State# s -> State# s #

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int32BE -> State# s -> State# s #

indexOffAddr# :: Addr# -> Int# -> Int32BE #

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Int32BE #) #

writeOffAddr# :: Addr# -> Int# -> Int32BE -> State# s -> State# s #

setOffAddr# :: Addr# -> Int# -> Int# -> Int32BE -> State# s -> State# s #

PrimUnaligned Int32BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

indexUnalignedByteArray# :: ByteArray# -> Int# -> Int32BE #

readUnalignedByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int32BE #) #

writeUnalignedByteArray# :: MutableByteArray# s -> Int# -> Int32BE -> State# s -> State# s #

type StaticSize Int32BE Source # 
Instance details

Defined in Dahdit.Sizes

type StaticSize Int32BE = 4

newtype Word64BE Source #

Constructors

Word64BE 

Fields

Instances

Instances details
Bits Word64BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

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

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

xor :: Word64BE -> Word64BE -> Word64BE #

complement :: Word64BE -> Word64BE #

shift :: Word64BE -> Int -> Word64BE #

rotate :: Word64BE -> Int -> Word64BE #

zeroBits :: Word64BE #

bit :: Int -> Word64BE #

setBit :: Word64BE -> Int -> Word64BE #

clearBit :: Word64BE -> Int -> Word64BE #

complementBit :: Word64BE -> Int -> Word64BE #

testBit :: Word64BE -> Int -> Bool #

bitSizeMaybe :: Word64BE -> Maybe Int #

bitSize :: Word64BE -> Int #

isSigned :: Word64BE -> Bool #

shiftL :: Word64BE -> Int -> Word64BE #

unsafeShiftL :: Word64BE -> Int -> Word64BE #

shiftR :: Word64BE -> Int -> Word64BE #

unsafeShiftR :: Word64BE -> Int -> Word64BE #

rotateL :: Word64BE -> Int -> Word64BE #

rotateR :: Word64BE -> Int -> Word64BE #

popCount :: Word64BE -> Int #

FiniteBits Word64BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

finiteBitSize :: Word64BE -> Int #

countLeadingZeros :: Word64BE -> Int #

countTrailingZeros :: Word64BE -> Int #

Bounded Word64BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

minBound :: Word64BE #

maxBound :: Word64BE #

Enum Word64BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

succ :: Word64BE -> Word64BE #

pred :: Word64BE -> Word64BE #

toEnum :: Int -> Word64BE #

fromEnum :: Word64BE -> Int #

enumFrom :: Word64BE -> [Word64BE] #

enumFromThen :: Word64BE -> Word64BE -> [Word64BE] #

enumFromTo :: Word64BE -> Word64BE -> [Word64BE] #

enumFromThenTo :: Word64BE -> Word64BE -> Word64BE -> [Word64BE] #

Num Word64BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

(+) :: Word64BE -> Word64BE -> Word64BE #

(-) :: Word64BE -> Word64BE -> Word64BE #

(*) :: Word64BE -> Word64BE -> Word64BE #

negate :: Word64BE -> Word64BE #

abs :: Word64BE -> Word64BE #

signum :: Word64BE -> Word64BE #

fromInteger :: Integer -> Word64BE #

Integral Word64BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

quot :: Word64BE -> Word64BE -> Word64BE #

rem :: Word64BE -> Word64BE -> Word64BE #

div :: Word64BE -> Word64BE -> Word64BE #

mod :: Word64BE -> Word64BE -> Word64BE #

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

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

toInteger :: Word64BE -> Integer #

Real Word64BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

toRational :: Word64BE -> Rational #

Show Word64BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

showsPrec :: Int -> Word64BE -> ShowS #

show :: Word64BE -> String #

showList :: [Word64BE] -> ShowS #

Binary Word64BE Source # 
Instance details

Defined in Dahdit.Binary

Methods

byteSize :: Word64BE -> ByteCount Source #

get :: Get Word64BE Source #

put :: Word64BE -> Put Source #

StaticByteSized Word64BE Source # 
Instance details

Defined in Dahdit.Sizes

Associated Types

type StaticSize Word64BE :: Nat Source #

Methods

staticByteSize :: Proxy Word64BE -> ByteCount Source #

Default Word64BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

def :: Word64BE #

Eq Word64BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

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

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

Ord Word64BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

compare :: Word64BE -> Word64BE -> Ordering #

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

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

(>) :: Word64BE -> Word64BE -> Bool #

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

max :: Word64BE -> Word64BE -> Word64BE #

min :: Word64BE -> Word64BE -> Word64BE #

Prim Word64BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

sizeOfType# :: Proxy Word64BE -> Int# #

sizeOf# :: Word64BE -> Int# #

alignmentOfType# :: Proxy Word64BE -> Int# #

alignment# :: Word64BE -> Int# #

indexByteArray# :: ByteArray# -> Int# -> Word64BE #

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word64BE #) #

writeByteArray# :: MutableByteArray# s -> Int# -> Word64BE -> State# s -> State# s #

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word64BE -> State# s -> State# s #

indexOffAddr# :: Addr# -> Int# -> Word64BE #

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Word64BE #) #

writeOffAddr# :: Addr# -> Int# -> Word64BE -> State# s -> State# s #

setOffAddr# :: Addr# -> Int# -> Int# -> Word64BE -> State# s -> State# s #

PrimUnaligned Word64BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

indexUnalignedByteArray# :: ByteArray# -> Int# -> Word64BE #

readUnalignedByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Word64BE #) #

writeUnalignedByteArray# :: MutableByteArray# s -> Int# -> Word64BE -> State# s -> State# s #

type StaticSize Word64BE Source # 
Instance details

Defined in Dahdit.Sizes

type StaticSize Word64BE = 8

newtype Int64BE Source #

Constructors

Int64BE 

Fields

Instances

Instances details
Bits Int64BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

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

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

xor :: Int64BE -> Int64BE -> Int64BE #

complement :: Int64BE -> Int64BE #

shift :: Int64BE -> Int -> Int64BE #

rotate :: Int64BE -> Int -> Int64BE #

zeroBits :: Int64BE #

bit :: Int -> Int64BE #

setBit :: Int64BE -> Int -> Int64BE #

clearBit :: Int64BE -> Int -> Int64BE #

complementBit :: Int64BE -> Int -> Int64BE #

testBit :: Int64BE -> Int -> Bool #

bitSizeMaybe :: Int64BE -> Maybe Int #

bitSize :: Int64BE -> Int #

isSigned :: Int64BE -> Bool #

shiftL :: Int64BE -> Int -> Int64BE #

unsafeShiftL :: Int64BE -> Int -> Int64BE #

shiftR :: Int64BE -> Int -> Int64BE #

unsafeShiftR :: Int64BE -> Int -> Int64BE #

rotateL :: Int64BE -> Int -> Int64BE #

rotateR :: Int64BE -> Int -> Int64BE #

popCount :: Int64BE -> Int #

FiniteBits Int64BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

finiteBitSize :: Int64BE -> Int #

countLeadingZeros :: Int64BE -> Int #

countTrailingZeros :: Int64BE -> Int #

Bounded Int64BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

minBound :: Int64BE #

maxBound :: Int64BE #

Enum Int64BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

succ :: Int64BE -> Int64BE #

pred :: Int64BE -> Int64BE #

toEnum :: Int -> Int64BE #

fromEnum :: Int64BE -> Int #

enumFrom :: Int64BE -> [Int64BE] #

enumFromThen :: Int64BE -> Int64BE -> [Int64BE] #

enumFromTo :: Int64BE -> Int64BE -> [Int64BE] #

enumFromThenTo :: Int64BE -> Int64BE -> Int64BE -> [Int64BE] #

Num Int64BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

(+) :: Int64BE -> Int64BE -> Int64BE #

(-) :: Int64BE -> Int64BE -> Int64BE #

(*) :: Int64BE -> Int64BE -> Int64BE #

negate :: Int64BE -> Int64BE #

abs :: Int64BE -> Int64BE #

signum :: Int64BE -> Int64BE #

fromInteger :: Integer -> Int64BE #

Integral Int64BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

quot :: Int64BE -> Int64BE -> Int64BE #

rem :: Int64BE -> Int64BE -> Int64BE #

div :: Int64BE -> Int64BE -> Int64BE #

mod :: Int64BE -> Int64BE -> Int64BE #

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

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

toInteger :: Int64BE -> Integer #

Real Int64BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

toRational :: Int64BE -> Rational #

Show Int64BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

showsPrec :: Int -> Int64BE -> ShowS #

show :: Int64BE -> String #

showList :: [Int64BE] -> ShowS #

Binary Int64BE Source # 
Instance details

Defined in Dahdit.Binary

Methods

byteSize :: Int64BE -> ByteCount Source #

get :: Get Int64BE Source #

put :: Int64BE -> Put Source #

StaticByteSized Int64BE Source # 
Instance details

Defined in Dahdit.Sizes

Associated Types

type StaticSize Int64BE :: Nat Source #

Methods

staticByteSize :: Proxy Int64BE -> ByteCount Source #

Default Int64BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

def :: Int64BE #

Eq Int64BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

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

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

Ord Int64BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

compare :: Int64BE -> Int64BE -> Ordering #

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

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

(>) :: Int64BE -> Int64BE -> Bool #

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

max :: Int64BE -> Int64BE -> Int64BE #

min :: Int64BE -> Int64BE -> Int64BE #

Prim Int64BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

sizeOfType# :: Proxy Int64BE -> Int# #

sizeOf# :: Int64BE -> Int# #

alignmentOfType# :: Proxy Int64BE -> Int# #

alignment# :: Int64BE -> Int# #

indexByteArray# :: ByteArray# -> Int# -> Int64BE #

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int64BE #) #

writeByteArray# :: MutableByteArray# s -> Int# -> Int64BE -> State# s -> State# s #

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int64BE -> State# s -> State# s #

indexOffAddr# :: Addr# -> Int# -> Int64BE #

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Int64BE #) #

writeOffAddr# :: Addr# -> Int# -> Int64BE -> State# s -> State# s #

setOffAddr# :: Addr# -> Int# -> Int# -> Int64BE -> State# s -> State# s #

PrimUnaligned Int64BE Source # 
Instance details

Defined in Dahdit.Nums

Methods

indexUnalignedByteArray# :: ByteArray# -> Int# -> Int64BE #

readUnalignedByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int64BE #) #

writeUnalignedByteArray# :: MutableByteArray# s -> Int# -> Int64BE -> State# s -> State# s #

type StaticSize Int64BE Source # 
Instance details

Defined in Dahdit.Sizes

type StaticSize Int64BE = 8

newtype FloatBE Source #

Constructors

FloatBE 

Fields

Instances

Instances details
Floating FloatBE Source # 
Instance details

Defined in Dahdit.Nums

Methods

pi :: FloatBE #

exp :: FloatBE -> FloatBE #

log :: FloatBE -> FloatBE #

sqrt :: FloatBE -> FloatBE #

(**) :: FloatBE -> FloatBE -> FloatBE #

logBase :: FloatBE -> FloatBE -> FloatBE #

sin :: FloatBE -> FloatBE #

cos :: FloatBE -> FloatBE #

tan :: FloatBE -> FloatBE #

asin :: FloatBE -> FloatBE #

acos :: FloatBE -> FloatBE #

atan :: FloatBE -> FloatBE #

sinh :: FloatBE -> FloatBE #

cosh :: FloatBE -> FloatBE #

tanh :: FloatBE -> FloatBE #

asinh :: FloatBE -> FloatBE #

acosh :: FloatBE -> FloatBE #

atanh :: FloatBE -> FloatBE #

log1p :: FloatBE -> FloatBE #

expm1 :: FloatBE -> FloatBE #

log1pexp :: FloatBE -> FloatBE #

log1mexp :: FloatBE -> FloatBE #

Num FloatBE Source # 
Instance details

Defined in Dahdit.Nums

Methods

(+) :: FloatBE -> FloatBE -> FloatBE #

(-) :: FloatBE -> FloatBE -> FloatBE #

(*) :: FloatBE -> FloatBE -> FloatBE #

negate :: FloatBE -> FloatBE #

abs :: FloatBE -> FloatBE #

signum :: FloatBE -> FloatBE #

fromInteger :: Integer -> FloatBE #

Fractional FloatBE Source # 
Instance details

Defined in Dahdit.Nums

Methods

(/) :: FloatBE -> FloatBE -> FloatBE #

recip :: FloatBE -> FloatBE #

fromRational :: Rational -> FloatBE #

Real FloatBE Source # 
Instance details

Defined in Dahdit.Nums

Methods

toRational :: FloatBE -> Rational #

RealFrac FloatBE Source # 
Instance details

Defined in Dahdit.Nums

Methods

properFraction :: Integral b => FloatBE -> (b, FloatBE) #

truncate :: Integral b => FloatBE -> b #

round :: Integral b => FloatBE -> b #

ceiling :: Integral b => FloatBE -> b #

floor :: Integral b => FloatBE -> b #

Show FloatBE Source # 
Instance details

Defined in Dahdit.Nums

Methods

showsPrec :: Int -> FloatBE -> ShowS #

show :: FloatBE -> String #

showList :: [FloatBE] -> ShowS #

Binary FloatBE Source # 
Instance details

Defined in Dahdit.Binary

Methods

byteSize :: FloatBE -> ByteCount Source #

get :: Get FloatBE Source #

put :: FloatBE -> Put Source #

StaticByteSized FloatBE Source # 
Instance details

Defined in Dahdit.Sizes

Associated Types

type StaticSize FloatBE :: Nat Source #

Methods

staticByteSize :: Proxy FloatBE -> ByteCount Source #

Default FloatBE Source # 
Instance details

Defined in Dahdit.Nums

Methods

def :: FloatBE #

Eq FloatBE Source # 
Instance details

Defined in Dahdit.Nums

Methods

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

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

Ord FloatBE Source # 
Instance details

Defined in Dahdit.Nums

Methods

compare :: FloatBE -> FloatBE -> Ordering #

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

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

(>) :: FloatBE -> FloatBE -> Bool #

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

max :: FloatBE -> FloatBE -> FloatBE #

min :: FloatBE -> FloatBE -> FloatBE #

Prim FloatBE Source # 
Instance details

Defined in Dahdit.Nums

Methods

sizeOfType# :: Proxy FloatBE -> Int# #

sizeOf# :: FloatBE -> Int# #

alignmentOfType# :: Proxy FloatBE -> Int# #

alignment# :: FloatBE -> Int# #

indexByteArray# :: ByteArray# -> Int# -> FloatBE #

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, FloatBE #) #

writeByteArray# :: MutableByteArray# s -> Int# -> FloatBE -> State# s -> State# s #

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> FloatBE -> State# s -> State# s #

indexOffAddr# :: Addr# -> Int# -> FloatBE #

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, FloatBE #) #

writeOffAddr# :: Addr# -> Int# -> FloatBE -> State# s -> State# s #

setOffAddr# :: Addr# -> Int# -> Int# -> FloatBE -> State# s -> State# s #

PrimUnaligned FloatBE Source # 
Instance details

Defined in Dahdit.Nums

Methods

indexUnalignedByteArray# :: ByteArray# -> Int# -> FloatBE #

readUnalignedByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, FloatBE #) #

writeUnalignedByteArray# :: MutableByteArray# s -> Int# -> FloatBE -> State# s -> State# s #

type StaticSize FloatBE Source # 
Instance details

Defined in Dahdit.Sizes

type StaticSize FloatBE = 4

newtype DoubleBE Source #

Constructors

DoubleBE 

Fields

Instances

Instances details
Floating DoubleBE Source # 
Instance details

Defined in Dahdit.Nums

Methods

pi :: DoubleBE #

exp :: DoubleBE -> DoubleBE #

log :: DoubleBE -> DoubleBE #

sqrt :: DoubleBE -> DoubleBE #

(**) :: DoubleBE -> DoubleBE -> DoubleBE #

logBase :: DoubleBE -> DoubleBE -> DoubleBE #

sin :: DoubleBE -> DoubleBE #

cos :: DoubleBE -> DoubleBE #

tan :: DoubleBE -> DoubleBE #

asin :: DoubleBE -> DoubleBE #

acos :: DoubleBE -> DoubleBE #

atan :: DoubleBE -> DoubleBE #

sinh :: DoubleBE -> DoubleBE #

cosh :: DoubleBE -> DoubleBE #

tanh :: DoubleBE -> DoubleBE #

asinh :: DoubleBE -> DoubleBE #

acosh :: DoubleBE -> DoubleBE #

atanh :: DoubleBE -> DoubleBE #

log1p :: DoubleBE -> DoubleBE #

expm1 :: DoubleBE -> DoubleBE #

log1pexp :: DoubleBE -> DoubleBE #

log1mexp :: DoubleBE -> DoubleBE #

Num DoubleBE Source # 
Instance details

Defined in Dahdit.Nums

Methods

(+) :: DoubleBE -> DoubleBE -> DoubleBE #

(-) :: DoubleBE -> DoubleBE -> DoubleBE #

(*) :: DoubleBE -> DoubleBE -> DoubleBE #

negate :: DoubleBE -> DoubleBE #

abs :: DoubleBE -> DoubleBE #

signum :: DoubleBE -> DoubleBE #

fromInteger :: Integer -> DoubleBE #

Fractional DoubleBE Source # 
Instance details

Defined in Dahdit.Nums

Methods

(/) :: DoubleBE -> DoubleBE -> DoubleBE #

recip :: DoubleBE -> DoubleBE #

fromRational :: Rational -> DoubleBE #

Real DoubleBE Source # 
Instance details

Defined in Dahdit.Nums

Methods

toRational :: DoubleBE -> Rational #

RealFrac DoubleBE Source # 
Instance details

Defined in Dahdit.Nums

Methods

properFraction :: Integral b => DoubleBE -> (b, DoubleBE) #

truncate :: Integral b => DoubleBE -> b #

round :: Integral b => DoubleBE -> b #

ceiling :: Integral b => DoubleBE -> b #

floor :: Integral b => DoubleBE -> b #

Show DoubleBE Source # 
Instance details

Defined in Dahdit.Nums

Methods

showsPrec :: Int -> DoubleBE -> ShowS #

show :: DoubleBE -> String #

showList :: [DoubleBE] -> ShowS #

Binary DoubleBE Source # 
Instance details

Defined in Dahdit.Binary

Methods

byteSize :: DoubleBE -> ByteCount Source #

get :: Get DoubleBE Source #

put :: DoubleBE -> Put Source #

StaticByteSized DoubleBE Source # 
Instance details

Defined in Dahdit.Sizes

Associated Types

type StaticSize DoubleBE :: Nat Source #

Methods

staticByteSize :: Proxy DoubleBE -> ByteCount Source #

Default DoubleBE Source # 
Instance details

Defined in Dahdit.Nums

Methods

def :: DoubleBE #

Eq DoubleBE Source # 
Instance details

Defined in Dahdit.Nums

Methods

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

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

Ord DoubleBE Source # 
Instance details

Defined in Dahdit.Nums

Methods

compare :: DoubleBE -> DoubleBE -> Ordering #

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

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

(>) :: DoubleBE -> DoubleBE -> Bool #

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

max :: DoubleBE -> DoubleBE -> DoubleBE #

min :: DoubleBE -> DoubleBE -> DoubleBE #

Prim DoubleBE Source # 
Instance details

Defined in Dahdit.Nums

Methods

sizeOfType# :: Proxy DoubleBE -> Int# #

sizeOf# :: DoubleBE -> Int# #

alignmentOfType# :: Proxy DoubleBE -> Int# #

alignment# :: DoubleBE -> Int# #

indexByteArray# :: ByteArray# -> Int# -> DoubleBE #

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, DoubleBE #) #

writeByteArray# :: MutableByteArray# s -> Int# -> DoubleBE -> State# s -> State# s #

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> DoubleBE -> State# s -> State# s #

indexOffAddr# :: Addr# -> Int# -> DoubleBE #

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, DoubleBE #) #

writeOffAddr# :: Addr# -> Int# -> DoubleBE -> State# s -> State# s #

setOffAddr# :: Addr# -> Int# -> Int# -> DoubleBE -> State# s -> State# s #

PrimUnaligned DoubleBE Source # 
Instance details

Defined in Dahdit.Nums

Methods

indexUnalignedByteArray# :: ByteArray# -> Int# -> DoubleBE #

readUnalignedByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, DoubleBE #) #

writeUnalignedByteArray# :: MutableByteArray# s -> Int# -> DoubleBE -> State# s -> State# s #

type StaticSize DoubleBE Source # 
Instance details

Defined in Dahdit.Sizes

type StaticSize DoubleBE = 8