Numeric.PrimBytes

Documentation

class PrimTagged a => PrimBytes a where

Facilities to convert to and from raw byte array.

Methods

getBytes :: a -> ByteArray#

Store content of a data type in a primitive byte array Should be used together with byteOffset function.

fromBytes

Arguments

:: Int#

offset in bytes

-> ByteArray#

-> a

Load content of a data type from a primitive byte array

readBytes

Arguments

:: MutableByteArray# s

source array

-> Int#

byte offset of the source array

-> State# s

-> (#State# s, a#)

Read data from a mutable byte array given an offset in bytes

writeBytes

Arguments

:: MutableByteArray# s

destination array

-> Int#

byte offset of the destination array

-> a

data to write into array

-> State# s

-> State# s

Write data into a mutable byte array at a given position (offset in bytes)

readAddr :: Addr# -> State# s -> (#State# s, a#)

Read data from a specified address

writeAddr :: a -> Addr# -> State# s -> State# s

Write data to a specified address

byteSize :: a -> Int#

Size of a data type in bytes

byteAlign :: a -> Int#

Alignment of a data type in bytes. byteOffset should be multiple of this value.

byteOffset :: a -> Int#

Offset of the data in a byte array used to store the data, measured in bytes. Should be used together with getBytes function. Unless in case of special data types represented by ByteArrays, it is equal to zero.

indexArray :: ByteArray# -> Int# -> a

Index array given an element offset.

indexArray arr i = fromBytes ( i *# byteSize t) arr

readArray :: MutableByteArray# s -> Int# -> State# s -> (#State# s, a#)

Read a mutable array given an element offset.

readArray arr i = readBytes arr ( i *# byteSize t)

writeArray :: MutableByteArray# s -> Int# -> a -> State# s -> State# s

Write a mutable array given an element offset.

writeArray arr i = writeBytes arr ( i *# byteSize t)

getBytes :: (Generic a, GPrimBytes (Rep a)) => a -> ByteArray#

Store content of a data type in a primitive byte array Should be used together with byteOffset function.

fromBytes

Arguments

:: (Generic a, GPrimBytes (Rep a))

=> Int#

offset in bytes

-> ByteArray#

-> a

Load content of a data type from a primitive byte array

readBytes

Arguments

:: (Generic a, GPrimBytes (Rep a))

=> MutableByteArray# s

source array

-> Int#

byte offset of the source array

-> State# s

-> (#State# s, a#)

Read data from a mutable byte array given an offset in bytes

writeBytes

Arguments

:: (Generic a, GPrimBytes (Rep a))

=> MutableByteArray# s

destination array

-> Int#

byte offset of the destination array

-> a

data to write into array

-> State# s

-> State# s

Write data into a mutable byte array at a given position (offset in bytes)

readAddr :: (Generic a, GPrimBytes (Rep a)) => Addr# -> State# s -> (#State# s, a#)

Read data from a specified address

writeAddr :: (Generic a, GPrimBytes (Rep a)) => a -> Addr# -> State# s -> State# s

Write data to a specified address

byteSize :: (Generic a, GPrimBytes (Rep a)) => a -> Int#

Size of a data type in bytes

byteAlign :: (Generic a, GPrimBytes (Rep a)) => a -> Int#

Alignment of a data type in bytes. byteOffset should be multiple of this value.

byteOffset :: (Generic a, GPrimBytes (Rep a)) => a -> Int#

Offset of the data in a byte array used to store the data, measured in bytes. Should be used together with getBytes function. Unless in case of special data types represented by ByteArrays, it is equal to zero.

Instances

PrimBytes Double

Methods

getBytes :: Double -> ByteArray#

fromBytes :: Int# -> ByteArray# -> Double

readBytes :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Double#)

writeBytes :: MutableByteArray# s -> Int# -> Double -> State# s -> State# s

readAddr :: Addr# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Double#)

writeAddr :: Double -> Addr# -> State# s -> State# s

byteSize :: Double -> Int#

byteAlign :: Double -> Int#

byteOffset :: Double -> Int#

indexArray :: ByteArray# -> Int# -> Double

readArray :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Double#)

writeArray :: MutableByteArray# s -> Int# -> Double -> State# s -> State# s

PrimBytes Float

Methods

getBytes :: Float -> ByteArray#

fromBytes :: Int# -> ByteArray# -> Float

readBytes :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Float#)

writeBytes :: MutableByteArray# s -> Int# -> Float -> State# s -> State# s

readAddr :: Addr# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Float#)

writeAddr :: Float -> Addr# -> State# s -> State# s

byteSize :: Float -> Int#

byteAlign :: Float -> Int#

byteOffset :: Float -> Int#

indexArray :: ByteArray# -> Int# -> Float

readArray :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Float#)

writeArray :: MutableByteArray# s -> Int# -> Float -> State# s -> State# s

PrimBytes Int

Methods

getBytes :: Int -> ByteArray#

fromBytes :: Int# -> ByteArray# -> Int

readBytes :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Int#)

writeBytes :: MutableByteArray# s -> Int# -> Int -> State# s -> State# s

readAddr :: Addr# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Int#)

writeAddr :: Int -> Addr# -> State# s -> State# s

byteSize :: Int -> Int#

byteAlign :: Int -> Int#

byteOffset :: Int -> Int#

indexArray :: ByteArray# -> Int# -> Int

readArray :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Int#)

writeArray :: MutableByteArray# s -> Int# -> Int -> State# s -> State# s

PrimBytes Int8

Methods

getBytes :: Int8 -> ByteArray#

fromBytes :: Int# -> ByteArray# -> Int8

readBytes :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Int8#)

writeBytes :: MutableByteArray# s -> Int# -> Int8 -> State# s -> State# s

readAddr :: Addr# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Int8#)

writeAddr :: Int8 -> Addr# -> State# s -> State# s

byteSize :: Int8 -> Int#

byteAlign :: Int8 -> Int#

byteOffset :: Int8 -> Int#

indexArray :: ByteArray# -> Int# -> Int8

readArray :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Int8#)

writeArray :: MutableByteArray# s -> Int# -> Int8 -> State# s -> State# s

PrimBytes Int16

Methods

getBytes :: Int16 -> ByteArray#

fromBytes :: Int# -> ByteArray# -> Int16

readBytes :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Int16#)

writeBytes :: MutableByteArray# s -> Int# -> Int16 -> State# s -> State# s

readAddr :: Addr# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Int16#)

writeAddr :: Int16 -> Addr# -> State# s -> State# s

byteSize :: Int16 -> Int#

byteAlign :: Int16 -> Int#

byteOffset :: Int16 -> Int#

indexArray :: ByteArray# -> Int# -> Int16

readArray :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Int16#)

writeArray :: MutableByteArray# s -> Int# -> Int16 -> State# s -> State# s

PrimBytes Int32

Methods

getBytes :: Int32 -> ByteArray#

fromBytes :: Int# -> ByteArray# -> Int32

readBytes :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Int32#)

writeBytes :: MutableByteArray# s -> Int# -> Int32 -> State# s -> State# s

readAddr :: Addr# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Int32#)

writeAddr :: Int32 -> Addr# -> State# s -> State# s

byteSize :: Int32 -> Int#

byteAlign :: Int32 -> Int#

byteOffset :: Int32 -> Int#

indexArray :: ByteArray# -> Int# -> Int32

readArray :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Int32#)

writeArray :: MutableByteArray# s -> Int# -> Int32 -> State# s -> State# s

PrimBytes Int64

Methods

getBytes :: Int64 -> ByteArray#

fromBytes :: Int# -> ByteArray# -> Int64

readBytes :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Int64#)

writeBytes :: MutableByteArray# s -> Int# -> Int64 -> State# s -> State# s

readAddr :: Addr# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Int64#)

writeAddr :: Int64 -> Addr# -> State# s -> State# s

byteSize :: Int64 -> Int#

byteAlign :: Int64 -> Int#

byteOffset :: Int64 -> Int#

indexArray :: ByteArray# -> Int# -> Int64

readArray :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Int64#)

writeArray :: MutableByteArray# s -> Int# -> Int64 -> State# s -> State# s

PrimBytes Word

Methods

getBytes :: Word -> ByteArray#

fromBytes :: Int# -> ByteArray# -> Word

readBytes :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Word#)

writeBytes :: MutableByteArray# s -> Int# -> Word -> State# s -> State# s

readAddr :: Addr# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Word#)

writeAddr :: Word -> Addr# -> State# s -> State# s

byteSize :: Word -> Int#

byteAlign :: Word -> Int#

byteOffset :: Word -> Int#

indexArray :: ByteArray# -> Int# -> Word

readArray :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Word#)

writeArray :: MutableByteArray# s -> Int# -> Word -> State# s -> State# s

PrimBytes Word8

Methods

getBytes :: Word8 -> ByteArray#

fromBytes :: Int# -> ByteArray# -> Word8

readBytes :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Word8#)

writeBytes :: MutableByteArray# s -> Int# -> Word8 -> State# s -> State# s

readAddr :: Addr# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Word8#)

writeAddr :: Word8 -> Addr# -> State# s -> State# s

byteSize :: Word8 -> Int#

byteAlign :: Word8 -> Int#

byteOffset :: Word8 -> Int#

indexArray :: ByteArray# -> Int# -> Word8

readArray :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Word8#)

writeArray :: MutableByteArray# s -> Int# -> Word8 -> State# s -> State# s

PrimBytes Word16

Methods

getBytes :: Word16 -> ByteArray#

fromBytes :: Int# -> ByteArray# -> Word16

readBytes :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Word16#)

writeBytes :: MutableByteArray# s -> Int# -> Word16 -> State# s -> State# s

readAddr :: Addr# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Word16#)

writeAddr :: Word16 -> Addr# -> State# s -> State# s

byteSize :: Word16 -> Int#

byteAlign :: Word16 -> Int#

byteOffset :: Word16 -> Int#

indexArray :: ByteArray# -> Int# -> Word16

readArray :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Word16#)

writeArray :: MutableByteArray# s -> Int# -> Word16 -> State# s -> State# s

PrimBytes Word32

Methods

getBytes :: Word32 -> ByteArray#

fromBytes :: Int# -> ByteArray# -> Word32

readBytes :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Word32#)

writeBytes :: MutableByteArray# s -> Int# -> Word32 -> State# s -> State# s

readAddr :: Addr# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Word32#)

writeAddr :: Word32 -> Addr# -> State# s -> State# s

byteSize :: Word32 -> Int#

byteAlign :: Word32 -> Int#

byteOffset :: Word32 -> Int#

indexArray :: ByteArray# -> Int# -> Word32

readArray :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Word32#)

writeArray :: MutableByteArray# s -> Int# -> Word32 -> State# s -> State# s

PrimBytes Word64

Methods

getBytes :: Word64 -> ByteArray#

fromBytes :: Int# -> ByteArray# -> Word64

readBytes :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Word64#)

writeBytes :: MutableByteArray# s -> Int# -> Word64 -> State# s -> State# s

readAddr :: Addr# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Word64#)

writeAddr :: Word64 -> Addr# -> State# s -> State# s

byteSize :: Word64 -> Int#

byteAlign :: Word64 -> Int#

byteOffset :: Word64 -> Int#

indexArray :: ByteArray# -> Int# -> Word64

readArray :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Word64#)

writeArray :: MutableByteArray# s -> Int# -> Word64 -> State# s -> State# s

PrimBytes FloatX4

Methods

getBytes :: FloatX4 -> ByteArray#

fromBytes :: Int# -> ByteArray# -> FloatX4

readBytes :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, FloatX4#)

writeBytes :: MutableByteArray# s -> Int# -> FloatX4 -> State# s -> State# s

readAddr :: Addr# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, FloatX4#)

writeAddr :: FloatX4 -> Addr# -> State# s -> State# s

byteSize :: FloatX4 -> Int#

byteAlign :: FloatX4 -> Int#

byteOffset :: FloatX4 -> Int#

indexArray :: ByteArray# -> Int# -> FloatX4

readArray :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, FloatX4#)

writeArray :: MutableByteArray# s -> Int# -> FloatX4 -> State# s -> State# s

PrimBytes FloatX3

Methods

getBytes :: FloatX3 -> ByteArray#

fromBytes :: Int# -> ByteArray# -> FloatX3

readBytes :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, FloatX3#)

writeBytes :: MutableByteArray# s -> Int# -> FloatX3 -> State# s -> State# s

readAddr :: Addr# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, FloatX3#)

writeAddr :: FloatX3 -> Addr# -> State# s -> State# s

byteSize :: FloatX3 -> Int#

byteAlign :: FloatX3 -> Int#

byteOffset :: FloatX3 -> Int#

indexArray :: ByteArray# -> Int# -> FloatX3

readArray :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, FloatX3#)

writeArray :: MutableByteArray# s -> Int# -> FloatX3 -> State# s -> State# s

PrimBytes FloatX2

Methods

getBytes :: FloatX2 -> ByteArray#

fromBytes :: Int# -> ByteArray# -> FloatX2

readBytes :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, FloatX2#)

writeBytes :: MutableByteArray# s -> Int# -> FloatX2 -> State# s -> State# s

readAddr :: Addr# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, FloatX2#)

writeAddr :: FloatX2 -> Addr# -> State# s -> State# s

byteSize :: FloatX2 -> Int#

byteAlign :: FloatX2 -> Int#

byteOffset :: FloatX2 -> Int#

indexArray :: ByteArray# -> Int# -> FloatX2

readArray :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, FloatX2#)

writeArray :: MutableByteArray# s -> Int# -> FloatX2 -> State# s -> State# s

PrimBytes DoubleX4

Methods

getBytes :: DoubleX4 -> ByteArray#

fromBytes :: Int# -> ByteArray# -> DoubleX4

readBytes :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, DoubleX4#)

writeBytes :: MutableByteArray# s -> Int# -> DoubleX4 -> State# s -> State# s

readAddr :: Addr# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, DoubleX4#)

writeAddr :: DoubleX4 -> Addr# -> State# s -> State# s

byteSize :: DoubleX4 -> Int#

byteAlign :: DoubleX4 -> Int#

byteOffset :: DoubleX4 -> Int#

indexArray :: ByteArray# -> Int# -> DoubleX4

readArray :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, DoubleX4#)

writeArray :: MutableByteArray# s -> Int# -> DoubleX4 -> State# s -> State# s

PrimBytes DoubleX3

Methods

getBytes :: DoubleX3 -> ByteArray#

fromBytes :: Int# -> ByteArray# -> DoubleX3

readBytes :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, DoubleX3#)

writeBytes :: MutableByteArray# s -> Int# -> DoubleX3 -> State# s -> State# s

readAddr :: Addr# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, DoubleX3#)

writeAddr :: DoubleX3 -> Addr# -> State# s -> State# s

byteSize :: DoubleX3 -> Int#

byteAlign :: DoubleX3 -> Int#

byteOffset :: DoubleX3 -> Int#

indexArray :: ByteArray# -> Int# -> DoubleX3

readArray :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, DoubleX3#)

writeArray :: MutableByteArray# s -> Int# -> DoubleX3 -> State# s -> State# s

PrimBytes DoubleX2

Methods

getBytes :: DoubleX2 -> ByteArray#

fromBytes :: Int# -> ByteArray# -> DoubleX2

readBytes :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, DoubleX2#)

writeBytes :: MutableByteArray# s -> Int# -> DoubleX2 -> State# s -> State# s

readAddr :: Addr# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, DoubleX2#)

writeAddr :: DoubleX2 -> Addr# -> State# s -> State# s

byteSize :: DoubleX2 -> Int#

byteAlign :: DoubleX2 -> Int#

byteOffset :: DoubleX2 -> Int#

indexArray :: ByteArray# -> Int# -> DoubleX2

readArray :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, DoubleX2#)

writeArray :: MutableByteArray# s -> Int# -> DoubleX2 -> State# s -> State# s

PrimBytes a => PrimBytes [a]

Methods

getBytes :: [a] -> ByteArray#

fromBytes :: Int# -> ByteArray# -> [a]

readBytes :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, [a]#)

writeBytes :: MutableByteArray# s -> Int# -> [a] -> State# s -> State# s

readAddr :: Addr# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, [a]#)

writeAddr :: [a] -> Addr# -> State# s -> State# s

byteSize :: [a] -> Int#

byteAlign :: [a] -> Int#

byteOffset :: [a] -> Int#

indexArray :: ByteArray# -> Int# -> [a]

readArray :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, [a]#)

writeArray :: MutableByteArray# s -> Int# -> [a] -> State# s -> State# s

PrimBytes a => PrimBytes (Maybe a)

Methods

getBytes :: Maybe a -> ByteArray#

fromBytes :: Int# -> ByteArray# -> Maybe a

readBytes :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Maybe a#)

writeBytes :: MutableByteArray# s -> Int# -> Maybe a -> State# s -> State# s

readAddr :: Addr# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Maybe a#)

writeAddr :: Maybe a -> Addr# -> State# s -> State# s

byteSize :: Maybe a -> Int#

byteAlign :: Maybe a -> Int#

byteOffset :: Maybe a -> Int#

indexArray :: ByteArray# -> Int# -> Maybe a

readArray :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Maybe a#)

writeArray :: MutableByteArray# s -> Int# -> Maybe a -> State# s -> State# s

PrimBytes (Ptr a)

Methods

getBytes :: Ptr a -> ByteArray#

fromBytes :: Int# -> ByteArray# -> Ptr a

readBytes :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Ptr a#)

writeBytes :: MutableByteArray# s -> Int# -> Ptr a -> State# s -> State# s

readAddr :: Addr# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Ptr a#)

writeAddr :: Ptr a -> Addr# -> State# s -> State# s

byteSize :: Ptr a -> Int#

byteAlign :: Ptr a -> Int#

byteOffset :: Ptr a -> Int#

indexArray :: ByteArray# -> Int# -> Ptr a

readArray :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Ptr a#)

writeArray :: MutableByteArray# s -> Int# -> Ptr a -> State# s -> State# s

(RepresentableList * xs, All * PrimBytes xs) => PrimBytes (Tuple xs)

Methods

getBytes :: Tuple xs -> ByteArray#

fromBytes :: Int# -> ByteArray# -> Tuple xs

readBytes :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Tuple xs#)

writeBytes :: MutableByteArray# s -> Int# -> Tuple xs -> State# s -> State# s

readAddr :: Addr# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Tuple xs#)

writeAddr :: Tuple xs -> Addr# -> State# s -> State# s

byteSize :: Tuple xs -> Int#

byteAlign :: Tuple xs -> Int#

byteOffset :: Tuple xs -> Int#

indexArray :: ByteArray# -> Int# -> Tuple xs

readArray :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Tuple xs#)

writeArray :: MutableByteArray# s -> Int# -> Tuple xs -> State# s -> State# s

(RepresentableList * xs, All * PrimBytes xs) => PrimBytes (Tuple xs)

Methods

getBytes :: Tuple xs -> ByteArray#

fromBytes :: Int# -> ByteArray# -> Tuple xs

readBytes :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Tuple xs#)

writeBytes :: MutableByteArray# s -> Int# -> Tuple xs -> State# s -> State# s

readAddr :: Addr# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Tuple xs#)

writeAddr :: Tuple xs -> Addr# -> State# s -> State# s

byteSize :: Tuple xs -> Int#

byteAlign :: Tuple xs -> Int#

byteOffset :: Tuple xs -> Int#

indexArray :: ByteArray# -> Int# -> Tuple xs

readArray :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Tuple xs#)

writeArray :: MutableByteArray# s -> Int# -> Tuple xs -> State# s -> State# s

PrimBytes t => PrimBytes (ScalarBase t)

Methods

getBytes :: ScalarBase t -> ByteArray#

fromBytes :: Int# -> ByteArray# -> ScalarBase t

readBytes :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, ScalarBase t#)

writeBytes :: MutableByteArray# s -> Int# -> ScalarBase t -> State# s -> State# s

readAddr :: Addr# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, ScalarBase t#)

writeAddr :: ScalarBase t -> Addr# -> State# s -> State# s

byteSize :: ScalarBase t -> Int#

byteAlign :: ScalarBase t -> Int#

byteOffset :: ScalarBase t -> Int#

indexArray :: ByteArray# -> Int# -> ScalarBase t

readArray :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, ScalarBase t#)

writeArray :: MutableByteArray# s -> Int# -> ScalarBase t -> State# s -> State# s

(PrimBytes a, PrimBytes b) => PrimBytes (Either a b)

Methods

getBytes :: Either a b -> ByteArray#

fromBytes :: Int# -> ByteArray# -> Either a b

readBytes :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Either a b#)

writeBytes :: MutableByteArray# s -> Int# -> Either a b -> State# s -> State# s

readAddr :: Addr# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Either a b#)

writeAddr :: Either a b -> Addr# -> State# s -> State# s

byteSize :: Either a b -> Int#

byteAlign :: Either a b -> Int#

byteOffset :: Either a b -> Int#

indexArray :: ByteArray# -> Int# -> Either a b

readArray :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Either a b#)

writeArray :: MutableByteArray# s -> Int# -> Either a b -> State# s -> State# s

PrimBytes (Idx * x)

Methods

getBytes :: Idx * x -> ByteArray#

fromBytes :: Int# -> ByteArray# -> Idx * x

readBytes :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Idx * x#)

writeBytes :: MutableByteArray# s -> Int# -> Idx * x -> State# s -> State# s

readAddr :: Addr# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Idx * x#)

writeAddr :: Idx * x -> Addr# -> State# s -> State# s

byteSize :: Idx * x -> Int#

byteAlign :: Idx * x -> Int#

byteOffset :: Idx * x -> Int#

indexArray :: ByteArray# -> Int# -> Idx * x

readArray :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Idx * x#)

writeArray :: MutableByteArray# s -> Int# -> Idx * x -> State# s -> State# s

RepresentableList * xs => PrimBytes (Idxs * xs)

Methods

getBytes :: Idxs * xs -> ByteArray#

fromBytes :: Int# -> ByteArray# -> Idxs * xs

readBytes :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Idxs * xs#)

writeBytes :: MutableByteArray# s -> Int# -> Idxs * xs -> State# s -> State# s

readAddr :: Addr# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Idxs * xs#)

writeAddr :: Idxs * xs -> Addr# -> State# s -> State# s

byteSize :: Idxs * xs -> Int#

byteAlign :: Idxs * xs -> Int#

byteOffset :: Idxs * xs -> Int#

indexArray :: ByteArray# -> Int# -> Idxs * xs

readArray :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Idxs * xs#)

writeArray :: MutableByteArray# s -> Int# -> Idxs * xs -> State# s -> State# s

(PrimBytes t, Dimensions Nat ds) => PrimBytes (ArrayBase t ds)

Methods

getBytes :: ArrayBase t ds -> ByteArray#

fromBytes :: Int# -> ByteArray# -> ArrayBase t ds

readBytes :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, ArrayBase t ds#)

writeBytes :: MutableByteArray# s -> Int# -> ArrayBase t ds -> State# s -> State# s

readAddr :: Addr# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, ArrayBase t ds#)

writeAddr :: ArrayBase t ds -> Addr# -> State# s -> State# s

byteSize :: ArrayBase t ds -> Int#

byteAlign :: ArrayBase t ds -> Int#

byteOffset :: ArrayBase t ds -> Int#

indexArray :: ByteArray# -> Int# -> ArrayBase t ds

readArray :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, ArrayBase t ds#)

writeArray :: MutableByteArray# s -> Int# -> ArrayBase t ds -> State# s -> State# s

data PrimTag a where

Constructors

PTagFloat :: PrimTag Float

PTagDouble :: PrimTag Double

PTagInt :: PrimTag Int

PTagInt8 :: PrimTag Int8

PTagInt16 :: PrimTag Int16

PTagInt32 :: PrimTag Int32

PTagInt64 :: PrimTag Int64

PTagWord :: PrimTag Word

PTagWord8 :: PrimTag Word8

PTagWord16 :: PrimTag Word16

PTagWord32 :: PrimTag Word32

PTagWord64 :: PrimTag Word64

PTagPtr :: PrimTag (Ptr a)

PTagOther :: PrimTag a

primTag :: PrimBytes a => a -> PrimTag a

This function allows to find out a type by comparing its tag. This is needed for array overloading, to infer array instances. For non-basic types it defaults to PTagOther