Data.Store.Internal

Internal API for the store package. The functions here which are not re-exported by Data.Store are less likely to have stable APIs.

This module also defines most of the included Store instances, for types from the base package and other commonly used packages (bytestring, containers, text, time, etc).

Encoding and decoding strict ByteStrings.

encode :: Store a => a -> ByteString

Serializes a value to a ByteString. In order to do this, it first allocates a ByteString of the correct size (based on size), and then uses poke to fill it.

Safety of this function depends on correctness of the Store instance. If size returns a. The good news is that this isn't an issue if you use well-tested manual instances (such as those from this package) combined with auomatic definition of instances.

decode :: Store a => ByteString -> Either PeekException a

Decodes a value from a ByteString. Returns an exception if there's an error while decoding, or if decoding undershoots / overshoots the end of the buffer.

decodeWith :: Peek a -> ByteString -> Either PeekException a

Decodes a value from a ByteString, potentially throwing exceptions, and taking a Peek to run. It is an exception to not consume all input.

decodeEx :: Store a => ByteString -> a

Decodes a value from a ByteString, potentially throwing exceptions. It is an exception to not consume all input.

decodeExWith :: Peek a -> ByteString -> a

Decodes a value from a ByteString, potentially throwing exceptions, and taking a Peek to run. It is an exception to not consume all input.

decodeExPortionWith :: Peek a -> ByteString -> (Offset, a)

Similar to decodeExWith, but it allows there to be more of the buffer remaining. The Offset of the buffer contents immediately after the decoded value is returned.

decodeIO :: Store a => ByteString -> IO a

Decodes a value from a ByteString, potentially throwing exceptions. It is an exception to not consume all input.

decodeIOWith :: Peek a -> ByteString -> IO a

Decodes a value from a ByteString, potentially throwing exceptions, and taking a Peek to run. It is an exception to not consume all input.

decodeIOPortionWith :: Peek a -> ByteString -> IO (Offset, a)

Similar to decodeExPortionWith, but runs in the IO monad.

Store class and related types.

class Store a where

The Store typeclass provides efficient serialization and deserialization to raw pointer addresses.

The peek and poke methods should be defined such that decodeEx (encode x) == x .

Methods

size :: Size a

Yields the Size of the buffer, in bytes, required to store the encoded representation of the type.

Note that the correctness of this function is crucial for the safety of poke, as it does not do any bounds checking. It is the responsibility of the invoker of poke (encode and similar functions) to ensure that there's enough space in the output buffer. If poke writes beyond, then arbitrary memory can be overwritten, causing undefined behavior and segmentation faults.

poke :: a -> Poke ()

Serializes a value to bytes. It is the responsibility of the caller to ensure that at least the number of bytes required by size are available. These details are handled by encode and similar utilities.

peek :: Peek a

Serialized a value from bytes, throwing exceptions if it encounters invalid data or runs out of input bytes.

size :: (Generic a, GStoreSize (Rep a)) => Size a

Yields the Size of the buffer, in bytes, required to store the encoded representation of the type.

Note that the correctness of this function is crucial for the safety of poke, as it does not do any bounds checking. It is the responsibility of the invoker of poke (encode and similar functions) to ensure that there's enough space in the output buffer. If poke writes beyond, then arbitrary memory can be overwritten, causing undefined behavior and segmentation faults.

poke :: (Generic a, GStorePoke (Rep a)) => a -> Poke ()

Serializes a value to bytes. It is the responsibility of the caller to ensure that at least the number of bytes required by size are available. These details are handled by encode and similar utilities.

peek :: (Generic a, GStorePeek (Rep a)) => Peek a

Serialized a value from bytes, throwing exceptions if it encounters invalid data or runs out of input bytes.

Instances

Store StoreVersion

Methods

size :: Size StoreVersion

poke :: StoreVersion -> Poke ()

peek :: Peek StoreVersion

Store TypeHash

Methods

size :: Size TypeHash

poke :: TypeHash -> Poke ()

peek :: Peek TypeHash

Store a => Store (WithVersion a)

Methods

size :: Size (WithVersion a)

poke :: WithVersion a -> Poke ()

peek :: Peek (WithVersion a)

(Store a, HasTypeHash a) => Store (Tagged a)

Methods

size :: Size (Tagged a)

poke :: Tagged a -> Poke ()

peek :: Peek (Tagged a)

KnownNat n => Store (StaticSize n ByteString)

Methods

size :: Size (StaticSize n ByteString)

poke :: StaticSize n ByteString -> Poke ()

peek :: Peek (StaticSize n ByteString)

data Poke a :: * -> *

Poke actions are useful for building sequential serializers.

They are actions which write values to bytes into memory specified by a Ptr base. The Applicative and Monad instances make it easy to write serializations, by keeping track of the Offset of the current byte. They allow you to chain Poke action such that subsequent Pokes write into subsequent portions of the output.

Instances

Monad Poke

Methods

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

(>>) :: Poke a -> Poke b -> Poke b

return :: a -> Poke a

fail :: String -> Poke a

Functor Poke

Methods

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

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

MonadFail Poke

Methods

fail :: String -> Poke a

Applicative Poke

Methods

pure :: a -> Poke a

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

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

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

MonadIO Poke

Methods

liftIO :: IO a -> Poke a

data Peek a :: * -> *

Peek actions are useful for building sequential deserializers.

They are actions which read from memory and construct values from it. The Applicative and Monad instances make it easy to chain these together to get more complicated deserializers. This machinery keeps track of the current Ptr and end-of-buffer Ptr.

Instances

Monad Peek

Methods

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

(>>) :: Peek a -> Peek b -> Peek b

return :: a -> Peek a

fail :: String -> Peek a

Functor Peek

Methods

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

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

MonadFail Peek

Methods

fail :: String -> Peek a

Applicative Peek

Methods

pure :: a -> Peek a

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

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

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

MonadIO Peek

Methods

liftIO :: IO a -> Peek a

PrimMonad Peek

Associated Types

type PrimState (Peek :: * -> *) :: *

Methods

primitive :: (State# (PrimState Peek) -> (#VoidRep, PtrRepLifted, State# (PrimState Peek), a#)) -> Peek a

type PrimState Peek

type PrimState Peek = RealWorld

runPeek :: Peek a -> forall byte. Ptr byte -> Ptr byte -> IO (Ptr byte, a)

Run the Peek action, with a Ptr to the end of the buffer where data is poked, and a Ptr to the current position. The result is the Ptr, along with a return value.

May throw a PeekException if the memory contains invalid values.

Exceptions thrown by Poke

data PokeException :: *

Exception thrown while running poke. Note that other types of exceptions could also be thrown. Invocations of fail in the Poke monad causes this exception to be thrown.

PokeExceptions are not expected to occur in ordinary circumstances, and usually indicate a programming error.

Constructors

PokeException

Fields

• pokeExByteIndex :: Offset
• pokeExMessage :: Text

Instances

Eq PokeException

Methods

(==) :: PokeException -> PokeException -> Bool

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

Show PokeException

Methods

showsPrec :: Int -> PokeException -> ShowS

show :: PokeException -> String

showList :: [PokeException] -> ShowS

Exception PokeException

Methods

toException :: PokeException -> SomeException

fromException :: SomeException -> Maybe PokeException

displayException :: PokeException -> String

pokeException :: Text -> Poke a

Throws a PokeException. These should be avoided when possible, they usually indicate a programming error.

Exceptions thrown by Peek

data PeekException :: *

Exception thrown while running peek. Note that other types of exceptions can also be thrown. Invocations of fail in the Poke monad causes this exception to be thrown.

PeekException is thrown when the data being decoded is invalid.

Constructors

PeekException

Fields

• peekExBytesFromEnd :: Offset
• peekExMessage :: Text

Instances

Eq PeekException

Methods

(==) :: PeekException -> PeekException -> Bool

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

Show PeekException

Methods

showsPrec :: Int -> PeekException -> ShowS

show :: PeekException -> String

showList :: [PeekException] -> ShowS

Exception PeekException

Methods

toException :: PeekException -> SomeException

fromException :: SomeException -> Maybe PeekException

displayException :: PeekException -> String

peekException :: Text -> Peek a

Throws a PeekException.

tooManyBytes :: Int -> Int -> String -> IO void

Throws a PeekException about an attempt to read too many bytes.

Size type

data Size a

Info about a type's serialized length. Either the length is known independently of the value, or the length depends on the value.

Constructors

VarSize (a -> Int)

ConstSize !Int

getSize :: Store a => a -> Int

Get the number of bytes needed to store the given value. See size.

getSizeWith :: Size a -> a -> Int

Given a Size value and a value of the type a, returns its Int size.

contramapSize :: (a -> b) -> Size b -> Size a

This allows for changing the type used as an input when the Size is VarSize.

combineSize :: forall a b c. (Store a, Store b) => (c -> a) -> (c -> b) -> Size c

Create an aggregate Size by providing functions to split the input into two pieces.

If both of the types are ConstSize, the result is ConstSize and the functions will not be used.

combineSizeWith :: forall a b c. (c -> a) -> (c -> b) -> Size a -> Size b -> Size c

Create an aggregate Size by providing functions to split the input into two pieces, as well as Size values to use to measure the results.

If both of the input Size values are ConstSize, the result is ConstSize and the functions will not be used.

addSize :: Int -> Size a -> Size a

Adds a constant amount to a Size value.

Store instances in terms of IsSequence

sizeSequence :: forall t. (IsSequence t, Store (Element t)) => Size t

Implement size for an IsSequence of Store instances.

Note that many monomorphic containers have more efficient implementations (for example, via memcpy).

pokeSequence :: (IsSequence t, Store (Element t)) => t -> Poke ()

Implement poke for an IsSequence of Store instances.

Note that many monomorphic containers have more efficient implementations (for example, via memcpy).

peekSequence :: (IsSequence t, Store (Element t), Index t ~ Int) => Peek t

Implement peek for an IsSequence of Store instances.

Note that many monomorphic containers have more efficient implementations (for example, via memcpy).

Store instances in terms of IsSet

sizeSet :: forall t. (IsSet t, Store (Element t)) => Size t

Implement size for an IsSet of Store instances.

pokeSet :: (IsSet t, Store (Element t)) => t -> Poke ()

Implement poke for an IsSequence of Store instances.

peekSet :: (IsSet t, Store (Element t)) => Peek t

Implement peek for an IsSequence of Store instances.

Store instances in terms of IsMap

sizeMap :: forall t. (Store (ContainerKey t), Store (MapValue t), IsMap t) => Size t

Implement size for an IsMap of where both ContainerKey and MapValue are Store instances.

pokeMap :: (Store (ContainerKey t), Store (MapValue t), IsMap t) => t -> Poke ()

Implement poke for an IsMap of where both ContainerKey and MapValue are Store instances.

peekMap :: (Store (ContainerKey t), Store (MapValue t), IsMap t) => Peek t

Implement peek for an IsMap of where both ContainerKey and MapValue are Store instances.

Store instances in terms of IArray

sizeArray :: (Ix i, IArray a e, Store i, Store e) => Size (a i e)

pokeArray :: (Ix i, IArray a e, Store i, Store e) => a i e -> Poke ()

peekArray :: (Ix i, IArray a e, Store i, Store e) => Peek (a i e)

Store instances in terms of Generic

class GStoreSize f

Minimal complete definition

gsize

Instances

GStoreSize V1

Methods

gsize :: Size (V1 a)

GStoreSize U1

Methods

gsize :: Size (U1 a)

Store a => GStoreSize (K1 i a)

Methods

gsize :: Size (K1 i a a)

((<=) (SumArity ((:+:) a b)) 255, GStoreSizeSum 0 ((:+:) a b)) => GStoreSize ((:+:) a b)

Methods

gsize :: Size ((a :+: b) a)

(GStoreSize a, GStoreSize b) => GStoreSize ((:*:) a b)

Methods

gsize :: Size ((a :*: b) a)

GStoreSize f => GStoreSize (M1 i c f)

Methods

gsize :: Size (M1 i c f a)

genericSize :: (Generic a, GStoreSize (Rep a)) => Size a

class GStorePoke f

Minimal complete definition

gpoke

Instances

GStorePoke V1

Methods

gpoke :: V1 a -> Poke ()

GStorePoke U1

Methods

gpoke :: U1 a -> Poke ()

Store a => GStorePoke (K1 i a)

Methods

gpoke :: K1 i a a -> Poke ()

((<=) (SumArity ((:+:) a b)) 255, GStorePokeSum 0 ((:+:) a b)) => GStorePoke ((:+:) a b)

Methods

gpoke :: (a :+: b) a -> Poke ()

(GStorePoke a, GStorePoke b) => GStorePoke ((:*:) a b)

Methods

gpoke :: (a :*: b) a -> Poke ()

GStorePoke f => GStorePoke (M1 i c f)

Methods

gpoke :: M1 i c f a -> Poke ()

genericPoke :: (Generic a, GStorePoke (Rep a)) => a -> Poke ()

class GStorePeek f

Minimal complete definition

gpeek

Instances

GStorePeek V1

Methods

gpeek :: Peek (V1 a)

GStorePeek U1

Methods

gpeek :: Peek (U1 a)

Store a => GStorePeek (K1 i a)

Methods

gpeek :: Peek (K1 i a a)

((<=) (SumArity ((:+:) a b)) 255, GStorePeekSum 0 ((:+:) a b)) => GStorePeek ((:+:) a b)

Methods

gpeek :: Peek ((a :+: b) a)

(GStorePeek a, GStorePeek b) => GStorePeek ((:*:) a b)

Methods

gpeek :: Peek ((a :*: b) a)

GStorePeek f => GStorePeek (M1 i c f)

Methods

gpeek :: Peek (M1 i c f a)

genericPeek :: (Generic a, GStorePeek (Rep a)) => Peek a

Peek utilities

skip :: Int -> Peek ()

Skip n bytes forward.

isolate :: Int -> Peek a -> Peek a

Isolate the input to n bytes, skipping n bytes forward. Fails if m advances the offset beyond the isolated region.

Static Size type

class KnownNat n => IsStaticSize n a where

Minimal complete definition

toStaticSize

Methods

toStaticSize :: a -> Maybe (StaticSize n a)

Instances

KnownNat n => IsStaticSize n ByteString

Methods

toStaticSize :: ByteString -> Maybe (StaticSize n ByteString)

newtype StaticSize n a

Constructors

StaticSize

Fields

• unStaticSize :: a

Instances

Eq a => Eq (StaticSize n a)

Methods

(==) :: StaticSize n a -> StaticSize n a -> Bool

(/=) :: StaticSize n a -> StaticSize n a -> Bool

(Data a, KnownNat n) => Data (StaticSize n a)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> StaticSize n a -> c (StaticSize n a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (StaticSize n a)

toConstr :: StaticSize n a -> Constr

dataTypeOf :: StaticSize n a -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (StaticSize n a))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (StaticSize n a))

gmapT :: (forall b. Data b => b -> b) -> StaticSize n a -> StaticSize n a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> StaticSize n a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> StaticSize n a -> r

gmapQ :: (forall d. Data d => d -> u) -> StaticSize n a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> StaticSize n a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> StaticSize n a -> m (StaticSize n a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> StaticSize n a -> m (StaticSize n a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> StaticSize n a -> m (StaticSize n a)

Ord a => Ord (StaticSize n a)

Methods

compare :: StaticSize n a -> StaticSize n a -> Ordering

(<) :: StaticSize n a -> StaticSize n a -> Bool

(<=) :: StaticSize n a -> StaticSize n a -> Bool

(>) :: StaticSize n a -> StaticSize n a -> Bool

(>=) :: StaticSize n a -> StaticSize n a -> Bool

max :: StaticSize n a -> StaticSize n a -> StaticSize n a

min :: StaticSize n a -> StaticSize n a -> StaticSize n a

Show a => Show (StaticSize n a)

Methods

showsPrec :: Int -> StaticSize n a -> ShowS

show :: StaticSize n a -> String

showList :: [StaticSize n a] -> ShowS

Generic (StaticSize n a)

Associated Types

type Rep (StaticSize n a) :: * -> *

Methods

from :: StaticSize n a -> Rep (StaticSize n a) x

to :: Rep (StaticSize n a) x -> StaticSize n a

NFData a => NFData (StaticSize n a)

Methods

rnf :: StaticSize n a -> ()

KnownNat n => Store (StaticSize n ByteString)

Methods

size :: Size (StaticSize n ByteString)

poke :: StaticSize n ByteString -> Poke ()

peek :: Peek (StaticSize n ByteString)

type Rep (StaticSize n a)

type Rep (StaticSize n a) = D1 (MetaData "StaticSize" "Data.Store.Internal" "store-0.2.1.0-8oKO4N1LZvu1TLjxdOcnFl" True) (C1 (MetaCons "StaticSize" PrefixI True) (S1 (MetaSel (Just Symbol "unStaticSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

toStaticSizeEx :: IsStaticSize n a => a -> StaticSize n a

liftStaticSize :: forall n a. (KnownNat n, Lift a) => TypeQ -> StaticSize n a -> ExpQ

staticByteStringExp :: ByteString -> ExpQ

Orphan instances

Store Bool

Methods

size :: Size Bool

poke :: Bool -> Poke ()

peek :: Peek Bool

Store Char

Methods

size :: Size Char

poke :: Char -> Poke ()

peek :: Peek Char

Store Double

Methods

size :: Size Double

poke :: Double -> Poke ()

peek :: Peek Double

Store Float

Methods

size :: Size Float

poke :: Float -> Poke ()

peek :: Peek Float

Store Int

Methods

size :: Size Int

poke :: Int -> Poke ()

peek :: Peek Int

Store Int8

Methods

size :: Size Int8

poke :: Int8 -> Poke ()

peek :: Peek Int8

Store Int16

Methods

size :: Size Int16

poke :: Int16 -> Poke ()

peek :: Peek Int16

Store Int32

Methods

size :: Size Int32

poke :: Int32 -> Poke ()

peek :: Peek Int32

Store Int64

Methods

size :: Size Int64

poke :: Int64 -> Poke ()

peek :: Peek Int64

Store Integer

Methods

size :: Size Integer

poke :: Integer -> Poke ()

peek :: Peek Integer

Store Word

Methods

size :: Size Word

poke :: Word -> Poke ()

peek :: Peek Word

Store Word8

Methods

size :: Size Word8

poke :: Word8 -> Poke ()

peek :: Peek Word8

Store Word16

Methods

size :: Size Word16

poke :: Word16 -> Poke ()

peek :: Peek Word16

Store Word32

Methods

size :: Size Word32

poke :: Word32 -> Poke ()

peek :: Peek Word32

Store Word64

Methods

size :: Size Word64

poke :: Word64 -> Poke ()

peek :: Peek Word64

Store Exp

Methods

size :: Size Exp

poke :: Exp -> Poke ()

peek :: Peek Exp

Store Match

Methods

size :: Size Match

poke :: Match -> Poke ()

peek :: Peek Match

Store Clause

Methods

size :: Size Clause

poke :: Clause -> Poke ()

peek :: Peek Clause

Store Pat

Methods

size :: Size Pat

poke :: Pat -> Poke ()

peek :: Peek Pat

Store Type

Methods

size :: Size Type

poke :: Type -> Poke ()

peek :: Peek Type

Store Dec

Methods

size :: Size Dec

poke :: Dec -> Poke ()

peek :: Peek Dec

Store Name

Methods

size :: Size Name

poke :: Name -> Poke ()

peek :: Peek Name

Store FunDep

Methods

size :: Size FunDep

poke :: FunDep -> Poke ()

peek :: Peek FunDep

Store TyVarBndr

Methods

size :: Size TyVarBndr

poke :: TyVarBndr -> Poke ()

peek :: Peek TyVarBndr

Store InjectivityAnn

Methods

size :: Size InjectivityAnn

poke :: InjectivityAnn -> Poke ()

peek :: Peek InjectivityAnn

Store Overlap

Methods

size :: Size Overlap

poke :: Overlap -> Poke ()

peek :: Peek Overlap

Store ()

Methods

size :: Size ()

poke :: () -> Poke ()

peek :: Peek ()

Store Void

Methods

size :: Size Void

poke :: Void -> Poke ()

peek :: Peek Void

Store WordPtr

Methods

size :: Size WordPtr

poke :: WordPtr -> Poke ()

peek :: Peek WordPtr

Store IntPtr

Methods

size :: Size IntPtr

poke :: IntPtr -> Poke ()

peek :: Peek IntPtr

Store CChar

Methods

size :: Size CChar

poke :: CChar -> Poke ()

peek :: Peek CChar

Store CSChar

Methods

size :: Size CSChar

poke :: CSChar -> Poke ()

peek :: Peek CSChar

Store CUChar

Methods

size :: Size CUChar

poke :: CUChar -> Poke ()

peek :: Peek CUChar

Store CShort

Methods

size :: Size CShort

poke :: CShort -> Poke ()

peek :: Peek CShort

Store CUShort

Methods

size :: Size CUShort

poke :: CUShort -> Poke ()

peek :: Peek CUShort

Store CInt

Methods

size :: Size CInt

poke :: CInt -> Poke ()

peek :: Peek CInt

Store CUInt

Methods

size :: Size CUInt

poke :: CUInt -> Poke ()

peek :: Peek CUInt

Store CLong

Methods

size :: Size CLong

poke :: CLong -> Poke ()

peek :: Peek CLong

Store CULong

Methods

size :: Size CULong

poke :: CULong -> Poke ()

peek :: Peek CULong

Store CLLong

Methods

size :: Size CLLong

poke :: CLLong -> Poke ()

peek :: Peek CLLong

Store CULLong

Methods

size :: Size CULLong

poke :: CULLong -> Poke ()

peek :: Peek CULLong

Store CFloat

Methods

size :: Size CFloat

poke :: CFloat -> Poke ()

peek :: Peek CFloat

Store CDouble

Methods

size :: Size CDouble

poke :: CDouble -> Poke ()

peek :: Peek CDouble

Store CPtrdiff

Methods

size :: Size CPtrdiff

poke :: CPtrdiff -> Poke ()

peek :: Peek CPtrdiff

Store CSize

Methods

size :: Size CSize

poke :: CSize -> Poke ()

peek :: Peek CSize

Store CWchar

Methods

size :: Size CWchar

poke :: CWchar -> Poke ()

peek :: Peek CWchar

Store CSigAtomic

Methods

size :: Size CSigAtomic

poke :: CSigAtomic -> Poke ()

peek :: Peek CSigAtomic

Store CClock

Methods

size :: Size CClock

poke :: CClock -> Poke ()

peek :: Peek CClock

Store CTime

Methods

size :: Size CTime

poke :: CTime -> Poke ()

peek :: Peek CTime

Store CUSeconds

Methods

size :: Size CUSeconds

poke :: CUSeconds -> Poke ()

peek :: Peek CUSeconds

Store CSUSeconds

Methods

size :: Size CSUSeconds

poke :: CSUSeconds -> Poke ()

peek :: Peek CSUSeconds

Store CIntPtr

Methods

size :: Size CIntPtr

poke :: CIntPtr -> Poke ()

peek :: Peek CIntPtr

Store CUIntPtr

Methods

size :: Size CUIntPtr

poke :: CUIntPtr -> Poke ()

peek :: Peek CUIntPtr

Store CIntMax

Methods

size :: Size CIntMax

poke :: CIntMax -> Poke ()

peek :: Peek CIntMax

Store CUIntMax

Methods

size :: Size CUIntMax

poke :: CUIntMax -> Poke ()

peek :: Peek CUIntMax

Store All

Methods

size :: Size All

poke :: All -> Poke ()

peek :: Peek All

Store Any

Methods

size :: Size Any

poke :: Any -> Poke ()

peek :: Peek Any

Store Fingerprint

Methods

size :: Size Fingerprint

poke :: Fingerprint -> Poke ()

peek :: Peek Fingerprint

Store ShortByteString

Methods

size :: Size ShortByteString

poke :: ShortByteString -> Poke ()

peek :: Peek ShortByteString

Store ByteString

Methods

size :: Size ByteString

poke :: ByteString -> Poke ()

peek :: Peek ByteString

Store ByteString

Methods

size :: Size ByteString

poke :: ByteString -> Poke ()

peek :: Peek ByteString

Store IntSet

Methods

size :: Size IntSet

poke :: IntSet -> Poke ()

peek :: Peek IntSet

Store ModName

Methods

size :: Size ModName

poke :: ModName -> Poke ()

peek :: Peek ModName

Store PkgName

Methods

size :: Size PkgName

poke :: PkgName -> Poke ()

peek :: Peek PkgName

Store OccName

Methods

size :: Size OccName

poke :: OccName -> Poke ()

peek :: Peek OccName

Store NameFlavour

Methods

size :: Size NameFlavour

poke :: NameFlavour -> Poke ()

peek :: Peek NameFlavour

Store NameSpace

Methods

size :: Size NameSpace

poke :: NameSpace -> Poke ()

peek :: Peek NameSpace

Store Info

Methods

size :: Size Info

poke :: Info -> Poke ()

peek :: Peek Info

Store Fixity

Methods

size :: Size Fixity

poke :: Fixity -> Poke ()

peek :: Peek Fixity

Store FixityDirection

Methods

size :: Size FixityDirection

poke :: FixityDirection -> Poke ()

peek :: Peek FixityDirection

Store Lit

Methods

size :: Size Lit

poke :: Lit -> Poke ()

peek :: Peek Lit

Store Body

Methods

size :: Size Body

poke :: Body -> Poke ()

peek :: Peek Body

Store Guard

Methods

size :: Size Guard

poke :: Guard -> Poke ()

peek :: Peek Guard

Store Stmt

Methods

size :: Size Stmt

poke :: Stmt -> Poke ()

peek :: Peek Stmt

Store Range

Methods

size :: Size Range

poke :: Range -> Poke ()

peek :: Peek Range

Store TypeFamilyHead

Methods

size :: Size TypeFamilyHead

poke :: TypeFamilyHead -> Poke ()

peek :: Peek TypeFamilyHead

Store TySynEqn

Methods

size :: Size TySynEqn

poke :: TySynEqn -> Poke ()

peek :: Peek TySynEqn

Store Foreign

Methods

size :: Size Foreign

poke :: Foreign -> Poke ()

peek :: Peek Foreign

Store Callconv

Methods

size :: Size Callconv

poke :: Callconv -> Poke ()

peek :: Peek Callconv

Store Safety

Methods

size :: Size Safety

poke :: Safety -> Poke ()

peek :: Peek Safety

Store Pragma

Methods

size :: Size Pragma

poke :: Pragma -> Poke ()

peek :: Peek Pragma

Store Inline

Methods

size :: Size Inline

poke :: Inline -> Poke ()

peek :: Peek Inline

Store RuleMatch

Methods

size :: Size RuleMatch

poke :: RuleMatch -> Poke ()

peek :: Peek RuleMatch

Store Phases

Methods

size :: Size Phases

poke :: Phases -> Poke ()

peek :: Peek Phases

Store RuleBndr

Methods

size :: Size RuleBndr

poke :: RuleBndr -> Poke ()

peek :: Peek RuleBndr

Store AnnTarget

Methods

size :: Size AnnTarget

poke :: AnnTarget -> Poke ()

peek :: Peek AnnTarget

Store SourceUnpackedness

Methods

size :: Size SourceUnpackedness

poke :: SourceUnpackedness -> Poke ()

peek :: Peek SourceUnpackedness

Store SourceStrictness

Methods

size :: Size SourceStrictness

poke :: SourceStrictness -> Poke ()

peek :: Peek SourceStrictness

Store Con

Methods

size :: Size Con

poke :: Con -> Poke ()

peek :: Peek Con

Store Bang

Methods

size :: Size Bang

poke :: Bang -> Poke ()

peek :: Peek Bang

Store FamilyResultSig

Methods

size :: Size FamilyResultSig

poke :: FamilyResultSig -> Poke ()

peek :: Peek FamilyResultSig

Store TyLit

Methods

size :: Size TyLit

poke :: TyLit -> Poke ()

peek :: Peek TyLit

Store Role

Methods

size :: Size Role

poke :: Role -> Poke ()

peek :: Peek Role

Store Text

Methods

size :: Size Text

poke :: Text -> Poke ()

peek :: Peek Text

Store UTCTime

Methods

size :: Size UTCTime

poke :: UTCTime -> Poke ()

peek :: Peek UTCTime

Store Day

Methods

size :: Size Day

poke :: Day -> Poke ()

peek :: Peek Day

Store DiffTime

Methods

size :: Size DiffTime

poke :: DiffTime -> Poke ()

peek :: Peek DiffTime

Store a => Store [a]

Methods

size :: Size [a]

poke :: [a] -> Poke ()

peek :: Peek [a]

Store a => Store (Maybe a)

Methods

size :: Size (Maybe a)

poke :: Maybe a -> Poke ()

peek :: Peek (Maybe a)

Store a => Store (Ratio a)

Methods

size :: Size (Ratio a)

poke :: Ratio a -> Poke ()

peek :: Peek (Ratio a)

Store (StablePtr a0)

Methods

size :: Size (StablePtr a0)

poke :: StablePtr a0 -> Poke ()

peek :: Peek (StablePtr a0)

Store (Ptr a0)

Methods

size :: Size (Ptr a0)

poke :: Ptr a0 -> Poke ()

peek :: Peek (Ptr a0)

Store (FunPtr a0)

Methods

size :: Size (FunPtr a0)

poke :: FunPtr a0 -> Poke ()

peek :: Peek (FunPtr a0)

Storable a0 => Store (Identity a0)

Methods

size :: Size (Identity a0)

poke :: Identity a0 -> Poke ()

peek :: Peek (Identity a0)

Store a => Store (NonEmpty a)

Methods

size :: Size (NonEmpty a)

poke :: NonEmpty a -> Poke ()

peek :: Peek (NonEmpty a)

Store (Fixed a)

Methods

size :: Size (Fixed a)

poke :: Fixed a -> Poke ()

peek :: Peek (Fixed a)

Storable a0 => Store (Complex a0)

Methods

size :: Size (Complex a0)

poke :: Complex a0 -> Poke ()

peek :: Peek (Complex a0)

Store a => Store (Dual a)

Methods

size :: Size (Dual a)

poke :: Dual a -> Poke ()

peek :: Peek (Dual a)

Store a => Store (Sum a)

Methods

size :: Size (Sum a)

poke :: Sum a -> Poke ()

peek :: Peek (Sum a)

Store a => Store (Product a)

Methods

size :: Size (Product a)

poke :: Product a -> Poke ()

peek :: Peek (Product a)

Store a => Store (First a)

Methods

size :: Size (First a)

poke :: First a -> Poke ()

peek :: Peek (First a)

Store a => Store (Last a)

Methods

size :: Size (Last a)

poke :: Last a -> Poke ()

peek :: Peek (Last a)

Store a => Store (Seq a)

Methods

size :: Size (Seq a)

poke :: Seq a -> Poke ()

peek :: Peek (Seq a)

Store a => Store (IntMap a)

Methods

size :: Size (IntMap a)

poke :: IntMap a -> Poke ()

peek :: Peek (IntMap a)

(Store a, Ord a) => Store (Set a)

Methods

size :: Size (Set a)

poke :: Set a -> Poke ()

peek :: Peek (Set a)

(Eq a, Hashable a, Store a) => Store (HashSet a)

Methods

size :: Size (HashSet a)

poke :: HashSet a -> Poke ()

peek :: Peek (HashSet a)

Store a => Store (Vector a)

Methods

size :: Size (Vector a)

poke :: Vector a -> Poke ()

peek :: Peek (Vector a)

Store (Vector Bool)

Methods

size :: Size (Vector Bool)

poke :: Vector Bool -> Poke ()

peek :: Peek (Vector Bool)

Store (Vector Char)

Methods

size :: Size (Vector Char)

poke :: Vector Char -> Poke ()

peek :: Peek (Vector Char)

Store (Vector Double)

Methods

size :: Size (Vector Double)

poke :: Vector Double -> Poke ()

peek :: Peek (Vector Double)

Store (Vector Float)

Methods

size :: Size (Vector Float)

poke :: Vector Float -> Poke ()

peek :: Peek (Vector Float)

Store (Vector Int)

Methods

size :: Size (Vector Int)

poke :: Vector Int -> Poke ()

peek :: Peek (Vector Int)

Store (Vector Int8)

Methods

size :: Size (Vector Int8)

poke :: Vector Int8 -> Poke ()

peek :: Peek (Vector Int8)

Store (Vector Int16)

Methods

size :: Size (Vector Int16)

poke :: Vector Int16 -> Poke ()

peek :: Peek (Vector Int16)

Store (Vector Int32)

Methods

size :: Size (Vector Int32)

poke :: Vector Int32 -> Poke ()

peek :: Peek (Vector Int32)

Store (Vector Int64)

Methods

size :: Size (Vector Int64)

poke :: Vector Int64 -> Poke ()

peek :: Peek (Vector Int64)

Store (Vector Word)

Methods

size :: Size (Vector Word)

poke :: Vector Word -> Poke ()

peek :: Peek (Vector Word)

Store (Vector Word8)

Methods

size :: Size (Vector Word8)

poke :: Vector Word8 -> Poke ()

peek :: Peek (Vector Word8)

Store (Vector Word16)

Methods

size :: Size (Vector Word16)

poke :: Vector Word16 -> Poke ()

peek :: Peek (Vector Word16)

Store (Vector Word32)

Methods

size :: Size (Vector Word32)

poke :: Vector Word32 -> Poke ()

peek :: Peek (Vector Word32)

Store (Vector Word64)

Methods

size :: Size (Vector Word64)

poke :: Vector Word64 -> Poke ()

peek :: Peek (Vector Word64)

Store (Vector ())

Methods

size :: Size (Vector ())

poke :: Vector () -> Poke ()

peek :: Peek (Vector ())

(Store (Vector a), Store (Vector b)) => Store (Vector (a, b))

Methods

size :: Size (Vector (a, b))

poke :: Vector (a, b) -> Poke ()

peek :: Peek (Vector (a, b))

(Store (Vector a), Store (Vector b), Store (Vector c)) => Store (Vector (a, b, c))

Methods

size :: Size (Vector (a, b, c))

poke :: Vector (a, b, c) -> Poke ()

peek :: Peek (Vector (a, b, c))

(Store (Vector a), Store (Vector b), Store (Vector c), Store (Vector d)) => Store (Vector (a, b, c, d))

Methods

size :: Size (Vector (a, b, c, d))

poke :: Vector (a, b, c, d) -> Poke ()

peek :: Peek (Vector (a, b, c, d))

(Store (Vector a), Store (Vector b), Store (Vector c), Store (Vector d), Store (Vector e)) => Store (Vector (a, b, c, d, e))

Methods

size :: Size (Vector (a, b, c, d, e))

poke :: Vector (a, b, c, d, e) -> Poke ()

peek :: Peek (Vector (a, b, c, d, e))

(Store (Vector a), Store (Vector b), Store (Vector c), Store (Vector d), Store (Vector e), Store (Vector f)) => Store (Vector (a, b, c, d, e, f))

Methods

size :: Size (Vector (a, b, c, d, e, f))

poke :: Vector (a, b, c, d, e, f) -> Poke ()

peek :: Peek (Vector (a, b, c, d, e, f))

Store (Vector a) => Store (Vector (Complex a))

Methods

size :: Size (Vector (Complex a))

poke :: Vector (Complex a) -> Poke ()

peek :: Peek (Vector (Complex a))

Storable a => Store (Vector a)

Methods

size :: Size (Vector a)

poke :: Vector a -> Poke ()

peek :: Peek (Vector a)

Store (Vector Char)

Methods

size :: Size (Vector Char)

poke :: Vector Char -> Poke ()

peek :: Peek (Vector Char)

Store (Vector Double)

Methods

size :: Size (Vector Double)

poke :: Vector Double -> Poke ()

peek :: Peek (Vector Double)

Store (Vector Float)

Methods

size :: Size (Vector Float)

poke :: Vector Float -> Poke ()

peek :: Peek (Vector Float)

Store (Vector Int)

Methods

size :: Size (Vector Int)

poke :: Vector Int -> Poke ()

peek :: Peek (Vector Int)

Store (Vector Int8)

Methods

size :: Size (Vector Int8)

poke :: Vector Int8 -> Poke ()

peek :: Peek (Vector Int8)

Store (Vector Int16)

Methods

size :: Size (Vector Int16)

poke :: Vector Int16 -> Poke ()

peek :: Peek (Vector Int16)

Store (Vector Int32)

Methods

size :: Size (Vector Int32)

poke :: Vector Int32 -> Poke ()

peek :: Peek (Vector Int32)

Store (Vector Int64)

Methods

size :: Size (Vector Int64)

poke :: Vector Int64 -> Poke ()

peek :: Peek (Vector Int64)

Store (Vector Word)

Methods

size :: Size (Vector Word)

poke :: Vector Word -> Poke ()

peek :: Peek (Vector Word)

Store (Vector Word8)

Methods

size :: Size (Vector Word8)

poke :: Vector Word8 -> Poke ()

peek :: Peek (Vector Word8)

Store (Vector Word16)

Methods

size :: Size (Vector Word16)

poke :: Vector Word16 -> Poke ()

peek :: Peek (Vector Word16)

Store (Vector Word32)

Methods

size :: Size (Vector Word32)

poke :: Vector Word32 -> Poke ()

peek :: Peek (Vector Word32)

Store (Vector Word64)

Methods

size :: Size (Vector Word64)

poke :: Vector Word64 -> Poke ()

peek :: Peek (Vector Word64)

Store (Vector Addr)

Methods

size :: Size (Vector Addr)

poke :: Vector Addr -> Poke ()

peek :: Peek (Vector Addr)

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

Methods

size :: Size (Either a b)

poke :: Either a b -> Poke ()

peek :: Peek (Either a b)

(Store a, Store b) => Store (a, b)

Methods

size :: Size (a, b)

poke :: (a, b) -> Poke ()

peek :: Peek (a, b)

(Ix i, IArray UArray e, Store i, Store e) => Store (UArray i e)

Methods

size :: Size (UArray i e)

poke :: UArray i e -> Poke ()

peek :: Peek (UArray i e)

(Ix i, Store i, Store e) => Store (Array i e)

Methods

size :: Size (Array i e)

poke :: Array i e -> Poke ()

peek :: Peek (Array i e)

(Ord k, Store k, Store a) => Store (Map k a)

Methods

size :: Size (Map k a)

poke :: Map k a -> Poke ()

peek :: Peek (Map k a)

(Eq k, Hashable k, Store k, Store a) => Store (HashMap k a)

Methods

size :: Size (HashMap k a)

poke :: HashMap k a -> Poke ()

peek :: Peek (HashMap k a)

(Store a, Store b, Store c) => Store (a, b, c)

Methods

size :: Size (a, b, c)

poke :: (a, b, c) -> Poke ()

peek :: Peek (a, b, c)

Storable a0 => Store (Const * a0 b0)

Methods

size :: Size (Const * a0 b0)

poke :: Const * a0 b0 -> Poke ()

peek :: Peek (Const * a0 b0)

(Store a, Store b, Store c, Store d) => Store (a, b, c, d)

Methods

size :: Size (a, b, c, d)

poke :: (a, b, c, d) -> Poke ()

peek :: Peek (a, b, c, d)

(Store a, Store b, Store c, Store d, Store e) => Store (a, b, c, d, e)

Methods

size :: Size (a, b, c, d, e)

poke :: (a, b, c, d, e) -> Poke ()

peek :: Peek (a, b, c, d, e)

(Store a, Store b, Store c, Store d, Store e, Store f) => Store (a, b, c, d, e, f)

Methods

size :: Size (a, b, c, d, e, f)

poke :: (a, b, c, d, e, f) -> Poke ()

peek :: Peek (a, b, c, d, e, f)

(Store a, Store b, Store c, Store d, Store e, Store f, Store g) => Store (a, b, c, d, e, f, g)

Methods

size :: Size (a, b, c, d, e, f, g)

poke :: (a, b, c, d, e, f, g) -> Poke ()

peek :: Peek (a, b, c, d, e, f, g)