License | BSD-style |
---|---|
Maintainer | Vincent Hanquez <vincent@snarc.org> |
Stability | experimental |
Portability | portable |
Safe Haskell | None |
Language | Haskell2010 |
Different collections (list, vector, string, ..) unified under 1 API. an API to rules them all, and in the darkness bind them.
- class Eq ty => PrimType ty where
- class (Functor m, Applicative m, Monad m) => PrimMonad m where
- class ByteSwap a
- newtype LE a = LE {
- unLE :: a
- toLE :: ByteSwap a => a -> LE a
- fromLE :: ByteSwap a => LE a -> a
- newtype BE a = BE {
- unBE :: a
- toBE :: ByteSwap a => a -> BE a
- fromBE :: ByteSwap a => BE a -> a
- class IntegralUpsize a b where
- class IntegralDownsize a b where
- class IntegralCast a b where
Documentation
class Eq ty => PrimType ty where #
Represent the accessor for types that can be stored in the UArray and MUArray.
Types need to be a instance of storable and have fixed sized.
primSizeInBytes, primBaUIndex, primMbaURead, primMbaUWrite, primAddrIndex, primAddrRead, primAddrWrite
primSizeInBytes :: Proxy ty -> Size8 #
get the size in bytes of a ty element
primBaUIndex :: ByteArray# -> Offset ty -> ty #
return the element stored at a specific index
primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset ty -> prim ty #
Read an element at an index in a mutable array
primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset ty -> ty -> prim () #
Write an element to a specific cell in a mutable array.
primAddrIndex :: Addr# -> Offset ty -> ty #
Read from Address, without a state. the value read should be considered a constant for all pratical purpose, otherwise bad thing will happens.
primAddrRead :: PrimMonad prim => Addr# -> Offset ty -> prim ty #
Read a value from Addr in a specific primitive monad
primAddrWrite :: PrimMonad prim => Addr# -> Offset ty -> ty -> prim () #
Write a value to Addr in a specific primitive monad
PrimType Char # | |
PrimType Double # | |
PrimType Float # | |
PrimType Int # | |
PrimType Int8 # | |
PrimType Int16 # | |
PrimType Int32 # | |
PrimType Int64 # | |
PrimType Word # | |
PrimType Word8 # | |
PrimType Word16 # | |
PrimType Word32 # | |
PrimType Word64 # | |
PrimType CChar # | |
PrimType CUChar # | |
PrimType a => PrimType (BE a) # | |
PrimType a => PrimType (LE a) # | |
class (Functor m, Applicative m, Monad m) => PrimMonad m where #
Primitive monad that can handle mutation.
For example: IO and ST.
type of state token associated with the PrimMonad m
type of variable associated with the PrimMonad m
primitive :: (State# (PrimState m) -> (#State# (PrimState m), a#)) -> m a #
Unwrap the State# token to pass to a function a primitive function that returns an unboxed state and a value.
primThrow :: Exception e => e -> m a #
Throw Exception in the primitive monad
unPrimMonad :: m a -> State# (PrimState m) -> (#State# (PrimState m), a#) #
Run a Prim monad from a dedicated state#
primVarNew :: a -> m (PrimVar m a) #
Build a new variable in the Prim Monad
primVarRead :: PrimVar m a -> m a #
Read the variable in the Prim Monad
primVarWrite :: PrimVar m a -> a -> m () #
Write the variable in the Prim Monad
endianess
Class of types that can be byte-swapped.
e.g. Word16, Word32, Word64
byteSwap
Little Endian value
Big Endian value
Integral convertion
class IntegralUpsize a b where #
Upsize an integral value
The destination type b
size need to be greater or equal
than the size type of a
integralUpsize :: a -> b #
class IntegralDownsize a b where #
Downsize an integral value
integralDownsize :: a -> b #
integralDownsize :: a ~ b => a -> b #
integralDownsizeCheck :: a -> Maybe b #
class IntegralCast a b where #
Cast an integral value to another value that have the same representional size
integralCast :: a -> b #
integralCast :: a ~ b => a -> b #