Streamly.Internal.Data.Unboxed

Documentation

class Unbox a where

A type implementing the Unbox interface supplies operations for reading and writing the type from and to a mutable byte array (an unboxed representation of the type) in memory. The read operation peekByteIndex deserializes the boxed type from the mutable byte array. The write operation pokeByteIndex serializes the boxed type to the mutable byte array.

Instances can be derived via Generic. Note that the data type must be non-recursive. Here is an example, for deriving an instance of this type class.

>>> import GHC.Generics (Generic)
>>> :{
data Object = Object
    { _int0 :: Int
    , _int1 :: Int
    } deriving Generic
:}

WARNING! Generic deriving hangs for recursive data types.

>>> import Streamly.Data.Array (Unbox(..))
>>> instance Unbox Object

If you want to write the instance manually:

>>> :{
instance Unbox Object where
    sizeOf _ = 16
    peekByteIndex i arr = do
        x0 <- peekByteIndex i arr
        x1 <- peekByteIndex (i + 8) arr
        return $ Object x0 x1
    pokeByteIndex i arr (Object x0 x1) = do
        pokeByteIndex i arr x0
        pokeByteIndex (i + 8) arr x1
:}

Minimal complete definition

Nothing

Methods

sizeOf :: Proxy a -> Int

Get the size. Size cannot be zero.

default sizeOf :: SizeOfRep (Rep a) => Proxy a -> Int

peekByteIndex :: Int -> MutableByteArray -> IO a

Read an element of type "a" from a MutableByteArray given the byte index.

IMPORTANT: The implementation of this interface may not check the bounds of the array, the caller must not assume that.

default peekByteIndex :: (Generic a, PeekRep (Rep a)) => Int -> MutableByteArray -> IO a

pokeByteIndex :: Int -> MutableByteArray -> a -> IO ()

Write an element of type "a" to a MutableByteArray given the byte index.

IMPORTANT: The implementation of this interface may not check the bounds of the array, the caller must not assume that.

default pokeByteIndex :: (Generic a, PokeRep (Rep a)) => Int -> MutableByteArray -> a -> IO ()

Instances

Unbox IntPtr

Defined in Streamly.Internal.Data.Unboxed

Methods

sizeOf :: Proxy IntPtr -> Int

peekByteIndex :: Int -> MutableByteArray -> IO IntPtr

pokeByteIndex :: Int -> MutableByteArray -> IntPtr -> IO ()

Unbox WordPtr

Defined in Streamly.Internal.Data.Unboxed

Methods

sizeOf :: Proxy WordPtr -> Int

peekByteIndex :: Int -> MutableByteArray -> IO WordPtr

pokeByteIndex :: Int -> MutableByteArray -> WordPtr -> IO ()

Unbox Fingerprint

Defined in Streamly.Internal.Data.Unboxed

Methods

sizeOf :: Proxy Fingerprint -> Int

peekByteIndex :: Int -> MutableByteArray -> IO Fingerprint

pokeByteIndex :: Int -> MutableByteArray -> Fingerprint -> IO ()

Unbox Int16

Defined in Streamly.Internal.Data.Unboxed

Methods

sizeOf :: Proxy Int16 -> Int

peekByteIndex :: Int -> MutableByteArray -> IO Int16

pokeByteIndex :: Int -> MutableByteArray -> Int16 -> IO ()

Unbox Int32

Defined in Streamly.Internal.Data.Unboxed

Methods

sizeOf :: Proxy Int32 -> Int

peekByteIndex :: Int -> MutableByteArray -> IO Int32

pokeByteIndex :: Int -> MutableByteArray -> Int32 -> IO ()

Unbox Int64

Defined in Streamly.Internal.Data.Unboxed

Methods

sizeOf :: Proxy Int64 -> Int

peekByteIndex :: Int -> MutableByteArray -> IO Int64

pokeByteIndex :: Int -> MutableByteArray -> Int64 -> IO ()

Unbox Int8

Defined in Streamly.Internal.Data.Unboxed

Methods

sizeOf :: Proxy Int8 -> Int

peekByteIndex :: Int -> MutableByteArray -> IO Int8

pokeByteIndex :: Int -> MutableByteArray -> Int8 -> IO ()

Unbox IoSubSystem

Defined in Streamly.Internal.Data.Unboxed

Methods

sizeOf :: Proxy IoSubSystem -> Int

peekByteIndex :: Int -> MutableByteArray -> IO IoSubSystem

pokeByteIndex :: Int -> MutableByteArray -> IoSubSystem -> IO ()

Unbox Word16

Defined in Streamly.Internal.Data.Unboxed

Methods

sizeOf :: Proxy Word16 -> Int

peekByteIndex :: Int -> MutableByteArray -> IO Word16

pokeByteIndex :: Int -> MutableByteArray -> Word16 -> IO ()

Unbox Word32

Defined in Streamly.Internal.Data.Unboxed

Methods

sizeOf :: Proxy Word32 -> Int

peekByteIndex :: Int -> MutableByteArray -> IO Word32

pokeByteIndex :: Int -> MutableByteArray -> Word32 -> IO ()

Unbox Word64

Defined in Streamly.Internal.Data.Unboxed

Methods

sizeOf :: Proxy Word64 -> Int

peekByteIndex :: Int -> MutableByteArray -> IO Word64

pokeByteIndex :: Int -> MutableByteArray -> Word64 -> IO ()

Unbox Word8

Defined in Streamly.Internal.Data.Unboxed

Methods

sizeOf :: Proxy Word8 -> Int

peekByteIndex :: Int -> MutableByteArray -> IO Word8

pokeByteIndex :: Int -> MutableByteArray -> Word8 -> IO ()

Unbox MicroSecond64

Defined in Streamly.Internal.Data.Time.Units

Methods

sizeOf :: Proxy MicroSecond64 -> Int

peekByteIndex :: Int -> MutableByteArray -> IO MicroSecond64

pokeByteIndex :: Int -> MutableByteArray -> MicroSecond64 -> IO ()

Unbox MilliSecond64

Defined in Streamly.Internal.Data.Time.Units

Methods

sizeOf :: Proxy MilliSecond64 -> Int

peekByteIndex :: Int -> MutableByteArray -> IO MilliSecond64

pokeByteIndex :: Int -> MutableByteArray -> MilliSecond64 -> IO ()

Unbox NanoSecond64

Defined in Streamly.Internal.Data.Time.Units

Methods

sizeOf :: Proxy NanoSecond64 -> Int

peekByteIndex :: Int -> MutableByteArray -> IO NanoSecond64

pokeByteIndex :: Int -> MutableByteArray -> NanoSecond64 -> IO ()

Unbox ()

Defined in Streamly.Internal.Data.Unboxed

Methods

sizeOf :: Proxy () -> Int

peekByteIndex :: Int -> MutableByteArray -> IO ()

pokeByteIndex :: Int -> MutableByteArray -> () -> IO ()

Unbox Bool

Defined in Streamly.Internal.Data.Unboxed

Methods

sizeOf :: Proxy Bool -> Int

peekByteIndex :: Int -> MutableByteArray -> IO Bool

pokeByteIndex :: Int -> MutableByteArray -> Bool -> IO ()

Unbox Char

Defined in Streamly.Internal.Data.Unboxed

Methods

sizeOf :: Proxy Char -> Int

peekByteIndex :: Int -> MutableByteArray -> IO Char

pokeByteIndex :: Int -> MutableByteArray -> Char -> IO ()

Unbox Double

Defined in Streamly.Internal.Data.Unboxed

Methods

sizeOf :: Proxy Double -> Int

peekByteIndex :: Int -> MutableByteArray -> IO Double

pokeByteIndex :: Int -> MutableByteArray -> Double -> IO ()

Unbox Float

Defined in Streamly.Internal.Data.Unboxed

Methods

sizeOf :: Proxy Float -> Int

peekByteIndex :: Int -> MutableByteArray -> IO Float

pokeByteIndex :: Int -> MutableByteArray -> Float -> IO ()

Unbox Int

Defined in Streamly.Internal.Data.Unboxed

Methods

sizeOf :: Proxy Int -> Int

peekByteIndex :: Int -> MutableByteArray -> IO Int

pokeByteIndex :: Int -> MutableByteArray -> Int -> IO ()

Unbox Word

Defined in Streamly.Internal.Data.Unboxed

Methods

sizeOf :: Proxy Word -> Int

peekByteIndex :: Int -> MutableByteArray -> IO Word

pokeByteIndex :: Int -> MutableByteArray -> Word -> IO ()

Unbox a => Unbox (Complex a)

Defined in Streamly.Internal.Data.Unboxed

Methods

sizeOf :: Proxy (Complex a) -> Int

peekByteIndex :: Int -> MutableByteArray -> IO (Complex a)

pokeByteIndex :: Int -> MutableByteArray -> Complex a -> IO ()

Unbox a => Unbox (Identity a)

Defined in Streamly.Internal.Data.Unboxed

Methods

sizeOf :: Proxy (Identity a) -> Int

peekByteIndex :: Int -> MutableByteArray -> IO (Identity a)

pokeByteIndex :: Int -> MutableByteArray -> Identity a -> IO ()

Unbox a => Unbox (Down a)

Defined in Streamly.Internal.Data.Unboxed

Methods

sizeOf :: Proxy (Down a) -> Int

peekByteIndex :: Int -> MutableByteArray -> IO (Down a)

pokeByteIndex :: Int -> MutableByteArray -> Down a -> IO ()

Unbox (FunPtr a)

Defined in Streamly.Internal.Data.Unboxed

Methods

sizeOf :: Proxy (FunPtr a) -> Int

peekByteIndex :: Int -> MutableByteArray -> IO (FunPtr a)

pokeByteIndex :: Int -> MutableByteArray -> FunPtr a -> IO ()

Unbox (Ptr a)

Defined in Streamly.Internal.Data.Unboxed

Methods

sizeOf :: Proxy (Ptr a) -> Int

peekByteIndex :: Int -> MutableByteArray -> IO (Ptr a)

pokeByteIndex :: Int -> MutableByteArray -> Ptr a -> IO ()

Unbox a => Unbox (Ratio a)

Defined in Streamly.Internal.Data.Unboxed

Methods

sizeOf :: Proxy (Ratio a) -> Int

peekByteIndex :: Int -> MutableByteArray -> IO (Ratio a)

pokeByteIndex :: Int -> MutableByteArray -> Ratio a -> IO ()

Unbox (StablePtr a)

Defined in Streamly.Internal.Data.Unboxed

Methods

sizeOf :: Proxy (StablePtr a) -> Int

peekByteIndex :: Int -> MutableByteArray -> IO (StablePtr a)

pokeByteIndex :: Int -> MutableByteArray -> StablePtr a -> IO ()

Unbox a => Unbox (Const a b)

Defined in Streamly.Internal.Data.Unboxed

Methods

sizeOf :: Proxy (Const a b) -> Int

peekByteIndex :: Int -> MutableByteArray -> IO (Const a b)

pokeByteIndex :: Int -> MutableByteArray -> Const a b -> IO ()

peekWith :: Unbox a => MutableByteArray -> Int -> IO a

pokeWith :: Unbox a => MutableByteArray -> Int -> a -> IO ()

data MutableByteArray

Constructors

MutableByteArray (MutableByteArray# RealWorld)

touch :: MutableByteArray -> IO ()

getMutableByteArray# :: MutableByteArray -> MutableByteArray# RealWorld

pin :: MutableByteArray -> IO MutableByteArray

unpin :: MutableByteArray -> IO MutableByteArray

newUnpinnedBytes :: Int -> IO MutableByteArray

newPinnedBytes :: Int -> IO MutableByteArray

newAlignedPinnedBytes :: Int -> Int -> IO MutableByteArray

nil :: MutableByteArray

Type Parser and Builder

data BoundedPtr

A location inside a mutable byte array with the bound of the array. Is it cheaper to just get the bound using the size of the array whenever needed?

Constructors

BoundedPtr MutableByteArray Int Int

newtype Peeker a

Chains peek functions that pass the current position to the next function

Constructors

Peeker (Builder BoundedPtr IO a)

Instances

Applicative Peeker

Defined in Streamly.Internal.Data.Unboxed

Methods

pure :: a -> Peeker a

(<*>) :: Peeker (a -> b) -> Peeker a -> Peeker b

liftA2 :: (a -> b -> c) -> Peeker a -> Peeker b -> Peeker c

(*>) :: Peeker a -> Peeker b -> Peeker b

(<*) :: Peeker a -> Peeker b -> Peeker a

Functor Peeker

Defined in Streamly.Internal.Data.Unboxed

Methods

fmap :: (a -> b) -> Peeker a -> Peeker b

(<$) :: a -> Peeker b -> Peeker a

Monad Peeker

Defined in Streamly.Internal.Data.Unboxed

Methods

(>>=) :: Peeker a -> (a -> Peeker b) -> Peeker b

(>>) :: Peeker a -> Peeker b -> Peeker b

return :: a -> Peeker a

read :: Unbox a => Peeker a

readUnsafe :: Unbox a => Peeker a

skipByte :: Peeker ()

runPeeker :: Peeker a -> BoundedPtr -> IO a

pokeBoundedPtrUnsafe :: forall a. Unbox a => a -> BoundedPtr -> IO BoundedPtr

pokeBoundedPtr :: forall a. Unbox a => a -> BoundedPtr -> IO BoundedPtr

Generic Unbox instances

genericSizeOf :: forall a. SizeOfRep (Rep a) => Proxy a -> Int

genericPeekByteIndex :: (Generic a, PeekRep (Rep a)) => MutableByteArray -> Int -> IO a

genericPokeByteIndex :: (Generic a, PokeRep (Rep a)) => MutableByteArray -> Int -> a -> IO ()

class PeekRep (f :: Type -> Type) where

Methods

peekRep :: Peeker (f x)

Instances

PeekRep (U1 :: Type -> Type)

Defined in Streamly.Internal.Data.Unboxed

Methods

peekRep :: Peeker (U1 x)

PeekRep (V1 :: Type -> Type)

Defined in Streamly.Internal.Data.Unboxed

Methods

peekRep :: Peeker (V1 x)

(PeekRep f, PeekRep g) => PeekRep (f :*: g)

Defined in Streamly.Internal.Data.Unboxed

Methods

peekRep :: Peeker ((f :*: g) x)

(MaxArity256 (SumArity (f :+: g)), PeekRepSum 0 (f :+: g)) => PeekRep (f :+: g)

Defined in Streamly.Internal.Data.Unboxed

Methods

peekRep :: Peeker ((f :+: g) x)

Unbox a => PeekRep (K1 i a :: Type -> Type)

Defined in Streamly.Internal.Data.Unboxed

Methods

peekRep :: Peeker (K1 i a x)

PeekRep f => PeekRep (M1 i c f)

Defined in Streamly.Internal.Data.Unboxed

Methods

peekRep :: Peeker (M1 i c f x)

class PokeRep (f :: Type -> Type) where

Methods

pokeRep :: f a -> BoundedPtr -> IO BoundedPtr

Instances

PokeRep (U1 :: Type -> Type)

Defined in Streamly.Internal.Data.Unboxed

Methods

pokeRep :: U1 a -> BoundedPtr -> IO BoundedPtr

PokeRep (V1 :: Type -> Type)

Defined in Streamly.Internal.Data.Unboxed

Methods

pokeRep :: V1 a -> BoundedPtr -> IO BoundedPtr

(PokeRep f, PokeRep g) => PokeRep (f :*: g)

Defined in Streamly.Internal.Data.Unboxed

Methods

pokeRep :: (f :*: g) a -> BoundedPtr -> IO BoundedPtr

(MaxArity256 (SumArity (f :+: g)), PokeRepSum 0 (f :+: g)) => PokeRep (f :+: g)

Defined in Streamly.Internal.Data.Unboxed

Methods

pokeRep :: (f :+: g) a -> BoundedPtr -> IO BoundedPtr

Unbox a => PokeRep (K1 i a :: Type -> Type)

Defined in Streamly.Internal.Data.Unboxed

Methods

pokeRep :: K1 i a a0 -> BoundedPtr -> IO BoundedPtr

PokeRep f => PokeRep (M1 i c f)

Defined in Streamly.Internal.Data.Unboxed

Methods

pokeRep :: M1 i c f a -> BoundedPtr -> IO BoundedPtr

class SizeOfRep (f :: Type -> Type) where

Implementation of sizeOf that works on the generic representation of an ADT.

Methods

sizeOfRep :: f x -> Int

Instances

SizeOfRep (U1 :: Type -> Type)

Defined in Streamly.Internal.Data.Unboxed

Methods

sizeOfRep :: U1 x -> Int

SizeOfRep (V1 :: Type -> Type)

Defined in Streamly.Internal.Data.Unboxed

Methods

sizeOfRep :: V1 x -> Int

(SizeOfRep f, SizeOfRep g) => SizeOfRep (f :*: g)

Defined in Streamly.Internal.Data.Unboxed

Methods

sizeOfRep :: (f :*: g) x -> Int

(MaxArity256 (SumArity (f :+: g)), SizeOfRepSum f, SizeOfRepSum g) => SizeOfRep (f :+: g)

Defined in Streamly.Internal.Data.Unboxed

Methods

sizeOfRep :: (f :+: g) x -> Int

Unbox a => SizeOfRep (K1 i a :: Type -> Type)

Defined in Streamly.Internal.Data.Unboxed

Methods

sizeOfRep :: K1 i a x -> Int

SizeOfRep f => SizeOfRep (M1 i c f)

Defined in Streamly.Internal.Data.Unboxed

Methods

sizeOfRep :: M1 i c f x -> Int