Data.Store

This is the main public API of the store package. The functions exported here are more likely to be stable between versions.

Usually you won't need to write your own Store instances, and instead can rely on either using the Generic deriving approach or Data.Store.TH for defining Store instances for your datatypes. There are some tradeoffs here - the generics instances do not require -XTemplateHaskell, but they do not optimize as well for sum types that only require a constant number of bytes.

If you need streaming encode / decode of multiple store encoded messages, take a look at the store-streaming package.

Gotchas

Store is best used for communication between trusted processes and local caches. It can certainly be used for other purposes, but the builtin set of instances have some gotchas to be aware of:

• Store's builtin instances serialize in a format which depends on machine endianness.
• Store's builtin instances trust the data when deserializing. For example, the deserialization of Vector will read the vector's link from the first 8 bytes. It will then allocate enough memory to store all the elements. Malicious or malformed input could cause allocation of large amounts of memory. See https://github.com/fpco/store/issues/122

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 .

Minimal complete definition

Nothing

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 Bool

Defined in Data.Store.Internal

Methods

size :: Size Bool

poke :: Bool -> Poke ()

peek :: Peek Bool

Store Char

Defined in Data.Store.Internal

Methods

size :: Size Char

poke :: Char -> Poke ()

peek :: Peek Char

Store Double

Defined in Data.Store.Internal

Methods

size :: Size Double

poke :: Double -> Poke ()

peek :: Peek Double

Store Float

Defined in Data.Store.Internal

Methods

size :: Size Float

poke :: Float -> Poke ()

peek :: Peek Float

Store Int

Defined in Data.Store.Internal

Methods

size :: Size Int

poke :: Int -> Poke ()

peek :: Peek Int

Store Int8

Defined in Data.Store.Internal

Methods

size :: Size Int8

poke :: Int8 -> Poke ()

peek :: Peek Int8

Store Int16

Defined in Data.Store.Internal

Methods

size :: Size Int16

poke :: Int16 -> Poke ()

peek :: Peek Int16

Store Int32

Defined in Data.Store.Internal

Methods

size :: Size Int32

poke :: Int32 -> Poke ()

peek :: Peek Int32

Store Int64

Defined in Data.Store.Internal

Methods

size :: Size Int64

poke :: Int64 -> Poke ()

peek :: Peek Int64

Store Integer

Defined in Data.Store.Internal

Methods

size :: Size Integer

poke :: Integer -> Poke ()

peek :: Peek Integer

Store Word

Defined in Data.Store.Internal

Methods

size :: Size Word

poke :: Word -> Poke ()

peek :: Peek Word

Store Word8

Defined in Data.Store.Internal

Methods

size :: Size Word8

poke :: Word8 -> Poke ()

peek :: Peek Word8

Store Word16

Defined in Data.Store.Internal

Methods

size :: Size Word16

poke :: Word16 -> Poke ()

peek :: Peek Word16

Store Word32

Defined in Data.Store.Internal

Methods

size :: Size Word32

poke :: Word32 -> Poke ()

peek :: Peek Word32

Store Word64

Defined in Data.Store.Internal

Methods

size :: Size Word64

poke :: Word64 -> Poke ()

peek :: Peek Word64

Store Exp

Defined in Data.Store.Internal

Methods

size :: Size Exp

poke :: Exp -> Poke ()

peek :: Peek Exp

Store Match

Defined in Data.Store.Internal

Methods

size :: Size Match

poke :: Match -> Poke ()

peek :: Peek Match

Store Clause

Defined in Data.Store.Internal

Methods

size :: Size Clause

poke :: Clause -> Poke ()

peek :: Peek Clause

Store Pat

Defined in Data.Store.Internal

Methods

size :: Size Pat

poke :: Pat -> Poke ()

peek :: Peek Pat

Store Type

Defined in Data.Store.Internal

Methods

size :: Size Type

poke :: Type -> Poke ()

peek :: Peek Type

Store Dec

Defined in Data.Store.Internal

Methods

size :: Size Dec

poke :: Dec -> Poke ()

peek :: Peek Dec

Store Name

Defined in Data.Store.Internal

Methods

size :: Size Name

poke :: Name -> Poke ()

peek :: Peek Name

Store FunDep

Defined in Data.Store.Internal

Methods

size :: Size FunDep

poke :: FunDep -> Poke ()

peek :: Peek FunDep

Store InjectivityAnn

Defined in Data.Store.Internal

Methods

size :: Size InjectivityAnn

poke :: InjectivityAnn -> Poke ()

peek :: Peek InjectivityAnn

Store Overlap

Defined in Data.Store.Internal

Methods

size :: Size Overlap

poke :: Overlap -> Poke ()

peek :: Peek Overlap

Store ()

Defined in Data.Store.Internal

Methods

size :: Size ()

poke :: () -> Poke ()

peek :: Peek ()

Store Void

Defined in Data.Store.Internal

Methods

size :: Size Void

poke :: Void -> Poke ()

peek :: Peek Void

Store All

Defined in Data.Store.Internal

Methods

size :: Size All

poke :: All -> Poke ()

peek :: Peek All

Store Any

Defined in Data.Store.Internal

Methods

size :: Size Any

poke :: Any -> Poke ()

peek :: Peek Any

Store CChar

Defined in Data.Store.Internal

Methods

size :: Size CChar

poke :: CChar -> Poke ()

peek :: Peek CChar

Store CSChar

Defined in Data.Store.Internal

Methods

size :: Size CSChar

poke :: CSChar -> Poke ()

peek :: Peek CSChar

Store CUChar

Defined in Data.Store.Internal

Methods

size :: Size CUChar

poke :: CUChar -> Poke ()

peek :: Peek CUChar

Store CShort

Defined in Data.Store.Internal

Methods

size :: Size CShort

poke :: CShort -> Poke ()

peek :: Peek CShort

Store CUShort

Defined in Data.Store.Internal

Methods

size :: Size CUShort

poke :: CUShort -> Poke ()

peek :: Peek CUShort

Store CInt

Defined in Data.Store.Internal

Methods

size :: Size CInt

poke :: CInt -> Poke ()

peek :: Peek CInt

Store CUInt

Defined in Data.Store.Internal

Methods

size :: Size CUInt

poke :: CUInt -> Poke ()

peek :: Peek CUInt

Store CLong

Defined in Data.Store.Internal

Methods

size :: Size CLong

poke :: CLong -> Poke ()

peek :: Peek CLong

Store CULong

Defined in Data.Store.Internal

Methods

size :: Size CULong

poke :: CULong -> Poke ()

peek :: Peek CULong

Store CLLong

Defined in Data.Store.Internal

Methods

size :: Size CLLong

poke :: CLLong -> Poke ()

peek :: Peek CLLong

Store CULLong

Defined in Data.Store.Internal

Methods

size :: Size CULLong

poke :: CULLong -> Poke ()

peek :: Peek CULLong

Store CBool

Defined in Data.Store.Internal

Methods

size :: Size CBool

poke :: CBool -> Poke ()

peek :: Peek CBool

Store CFloat

Defined in Data.Store.Internal

Methods

size :: Size CFloat

poke :: CFloat -> Poke ()

peek :: Peek CFloat

Store CDouble

Defined in Data.Store.Internal

Methods

size :: Size CDouble

poke :: CDouble -> Poke ()

peek :: Peek CDouble

Store CPtrdiff

Defined in Data.Store.Internal

Methods

size :: Size CPtrdiff

poke :: CPtrdiff -> Poke ()

peek :: Peek CPtrdiff

Store CSize

Defined in Data.Store.Internal

Methods

size :: Size CSize

poke :: CSize -> Poke ()

peek :: Peek CSize

Store CWchar

Defined in Data.Store.Internal

Methods

size :: Size CWchar

poke :: CWchar -> Poke ()

peek :: Peek CWchar

Store CSigAtomic

Defined in Data.Store.Internal

Methods

size :: Size CSigAtomic

poke :: CSigAtomic -> Poke ()

peek :: Peek CSigAtomic

Store CClock

Defined in Data.Store.Internal

Methods

size :: Size CClock

poke :: CClock -> Poke ()

peek :: Peek CClock

Store CTime

Defined in Data.Store.Internal

Methods

size :: Size CTime

poke :: CTime -> Poke ()

peek :: Peek CTime

Store CUSeconds

Defined in Data.Store.Internal

Methods

size :: Size CUSeconds

poke :: CUSeconds -> Poke ()

peek :: Peek CUSeconds

Store CSUSeconds

Defined in Data.Store.Internal

Methods

size :: Size CSUSeconds

poke :: CSUSeconds -> Poke ()

peek :: Peek CSUSeconds

Store CIntPtr

Defined in Data.Store.Internal

Methods

size :: Size CIntPtr

poke :: CIntPtr -> Poke ()

peek :: Peek CIntPtr

Store CUIntPtr

Defined in Data.Store.Internal

Methods

size :: Size CUIntPtr

poke :: CUIntPtr -> Poke ()

peek :: Peek CUIntPtr

Store CIntMax

Defined in Data.Store.Internal

Methods

size :: Size CIntMax

poke :: CIntMax -> Poke ()

peek :: Peek CIntMax

Store CUIntMax

Defined in Data.Store.Internal

Methods

size :: Size CUIntMax

poke :: CUIntMax -> Poke ()

peek :: Peek CUIntMax

Store WordPtr

Defined in Data.Store.Internal

Methods

size :: Size WordPtr

poke :: WordPtr -> Poke ()

peek :: Peek WordPtr

Store IntPtr

Defined in Data.Store.Internal

Methods

size :: Size IntPtr

poke :: IntPtr -> Poke ()

peek :: Peek IntPtr

Store Fingerprint

Defined in Data.Store.Internal

Methods

size :: Size Fingerprint

poke :: Fingerprint -> Poke ()

peek :: Peek Fingerprint

Store ShortByteString

Defined in Data.Store.Internal

Methods

size :: Size ShortByteString

poke :: ShortByteString -> Poke ()

peek :: Peek ShortByteString

Store ByteString

Defined in Data.Store.Internal

Methods

size :: Size ByteString

poke :: ByteString -> Poke ()

peek :: Peek ByteString

Store ByteString

Defined in Data.Store.Internal

Methods

size :: Size ByteString

poke :: ByteString -> Poke ()

peek :: Peek ByteString

Store TimeSpec

Defined in Data.Store.Internal

Methods

size :: Size TimeSpec

poke :: TimeSpec -> Poke ()

peek :: Peek TimeSpec

Store IntSet

Defined in Data.Store.Internal

Methods

size :: Size IntSet

poke :: IntSet -> Poke ()

peek :: Peek IntSet

Store PortNumber

Defined in Data.Store.Internal

Methods

size :: Size PortNumber

poke :: PortNumber -> Poke ()

peek :: Peek PortNumber

Store ModName

Defined in Data.Store.Internal

Methods

size :: Size ModName

poke :: ModName -> Poke ()

peek :: Peek ModName

Store PkgName

Defined in Data.Store.Internal

Methods

size :: Size PkgName

poke :: PkgName -> Poke ()

peek :: Peek PkgName

Store OccName

Defined in Data.Store.Internal

Methods

size :: Size OccName

poke :: OccName -> Poke ()

peek :: Peek OccName

Store NameFlavour

Defined in Data.Store.Internal

Methods

size :: Size NameFlavour

poke :: NameFlavour -> Poke ()

peek :: Peek NameFlavour

Store NameSpace

Defined in Data.Store.Internal

Methods

size :: Size NameSpace

poke :: NameSpace -> Poke ()

peek :: Peek NameSpace

Store Info

Defined in Data.Store.Internal

Methods

size :: Size Info

poke :: Info -> Poke ()

peek :: Peek Info

Store Fixity

Defined in Data.Store.Internal

Methods

size :: Size Fixity

poke :: Fixity -> Poke ()

peek :: Peek Fixity

Store FixityDirection

Defined in Data.Store.Internal

Methods

size :: Size FixityDirection

poke :: FixityDirection -> Poke ()

peek :: Peek FixityDirection

Store Lit

Defined in Data.Store.Internal

Methods

size :: Size Lit

poke :: Lit -> Poke ()

peek :: Peek Lit

Store Body

Defined in Data.Store.Internal

Methods

size :: Size Body

poke :: Body -> Poke ()

peek :: Peek Body

Store Guard

Defined in Data.Store.Internal

Methods

size :: Size Guard

poke :: Guard -> Poke ()

peek :: Peek Guard

Store Stmt

Defined in Data.Store.Internal

Methods

size :: Size Stmt

poke :: Stmt -> Poke ()

peek :: Peek Stmt

Store Range

Defined in Data.Store.Internal

Methods

size :: Size Range

poke :: Range -> Poke ()

peek :: Peek Range

Store DerivClause

Defined in Data.Store.Internal

Methods

size :: Size DerivClause

poke :: DerivClause -> Poke ()

peek :: Peek DerivClause

Store DerivStrategy

Defined in Data.Store.Internal

Methods

size :: Size DerivStrategy

poke :: DerivStrategy -> Poke ()

peek :: Peek DerivStrategy

Store TypeFamilyHead

Defined in Data.Store.Internal

Methods

size :: Size TypeFamilyHead

poke :: TypeFamilyHead -> Poke ()

peek :: Peek TypeFamilyHead

Store TySynEqn

Defined in Data.Store.Internal

Methods

size :: Size TySynEqn

poke :: TySynEqn -> Poke ()

peek :: Peek TySynEqn

Store Foreign

Defined in Data.Store.Internal

Methods

size :: Size Foreign

poke :: Foreign -> Poke ()

peek :: Peek Foreign

Store Callconv

Defined in Data.Store.Internal

Methods

size :: Size Callconv

poke :: Callconv -> Poke ()

peek :: Peek Callconv

Store Safety

Defined in Data.Store.Internal

Methods

size :: Size Safety

poke :: Safety -> Poke ()

peek :: Peek Safety

Store Pragma

Defined in Data.Store.Internal

Methods

size :: Size Pragma

poke :: Pragma -> Poke ()

peek :: Peek Pragma

Store Inline

Defined in Data.Store.Internal

Methods

size :: Size Inline

poke :: Inline -> Poke ()

peek :: Peek Inline

Store RuleMatch

Defined in Data.Store.Internal

Methods

size :: Size RuleMatch

poke :: RuleMatch -> Poke ()

peek :: Peek RuleMatch

Store Phases

Defined in Data.Store.Internal

Methods

size :: Size Phases

poke :: Phases -> Poke ()

peek :: Peek Phases

Store RuleBndr

Defined in Data.Store.Internal

Methods

size :: Size RuleBndr

poke :: RuleBndr -> Poke ()

peek :: Peek RuleBndr

Store AnnTarget

Defined in Data.Store.Internal

Methods

size :: Size AnnTarget

poke :: AnnTarget -> Poke ()

peek :: Peek AnnTarget

Store SourceUnpackedness

Defined in Data.Store.Internal

Methods

size :: Size SourceUnpackedness

poke :: SourceUnpackedness -> Poke ()

peek :: Peek SourceUnpackedness

Store SourceStrictness

Defined in Data.Store.Internal

Methods

size :: Size SourceStrictness

poke :: SourceStrictness -> Poke ()

peek :: Peek SourceStrictness

Store Con

Defined in Data.Store.Internal

Methods

size :: Size Con

poke :: Con -> Poke ()

peek :: Peek Con

Store Bang

Defined in Data.Store.Internal

Methods

size :: Size Bang

poke :: Bang -> Poke ()

peek :: Peek Bang

Store PatSynDir

Defined in Data.Store.Internal

Methods

size :: Size PatSynDir

poke :: PatSynDir -> Poke ()

peek :: Peek PatSynDir

Store PatSynArgs

Defined in Data.Store.Internal

Methods

size :: Size PatSynArgs

poke :: PatSynArgs -> Poke ()

peek :: Peek PatSynArgs

Store TyVarBndr

Defined in Data.Store.Internal

Methods

size :: Size TyVarBndr

poke :: TyVarBndr -> Poke ()

peek :: Peek TyVarBndr

Store FamilyResultSig

Defined in Data.Store.Internal

Methods

size :: Size FamilyResultSig

poke :: FamilyResultSig -> Poke ()

peek :: Peek FamilyResultSig

Store TyLit

Defined in Data.Store.Internal

Methods

size :: Size TyLit

poke :: TyLit -> Poke ()

peek :: Peek TyLit

Store Role

Defined in Data.Store.Internal

Methods

size :: Size Role

poke :: Role -> Poke ()

peek :: Peek Role

Store Text

Defined in Data.Store.Internal

Methods

size :: Size Text

poke :: Text -> Poke ()

peek :: Peek Text

Store UTCTime

Defined in Data.Store.Internal

Methods

size :: Size UTCTime

poke :: UTCTime -> Poke ()

peek :: Peek UTCTime

Store DiffTime

Defined in Data.Store.Internal

Methods

size :: Size DiffTime

poke :: DiffTime -> Poke ()

peek :: Peek DiffTime

Store Day

Defined in Data.Store.Internal

Methods

size :: Size Day

poke :: Day -> Poke ()

peek :: Peek Day

Store TypeHash

Defined in Data.Store.TypeHash.Internal

Methods

size :: Size TypeHash

poke :: TypeHash -> Poke ()

peek :: Peek TypeHash

Store StoreVersion

Defined in Data.Store.Version

Methods

size :: Size StoreVersion

poke :: StoreVersion -> Poke ()

peek :: Peek StoreVersion

Deriver (Store a)

Defined in Data.Store.TH.Internal

Methods

runDeriver :: Proxy (Store a) -> Cxt -> Type -> Q [Dec]

Store a => Store [a]

Defined in Data.Store.Internal

Methods

size :: Size [a]

poke :: [a] -> Poke ()

peek :: Peek [a]

Store a => Store (Maybe a)

Defined in Data.Store.Internal

Methods

size :: Size (Maybe a)

poke :: Maybe a -> Poke ()

peek :: Peek (Maybe a)

Store a => Store (Ratio a)

Defined in Data.Store.Internal

Methods

size :: Size (Ratio a)

poke :: Ratio a -> Poke ()

peek :: Peek (Ratio a)

Store (StablePtr a)

Defined in Data.Store.Internal

Methods

size :: Size (StablePtr a)

poke :: StablePtr a -> Poke ()

peek :: Peek (StablePtr a)

Store (Ptr a)

Defined in Data.Store.Internal

Methods

size :: Size (Ptr a)

poke :: Ptr a -> Poke ()

peek :: Peek (Ptr a)

Store (FunPtr a)

Defined in Data.Store.Internal

Methods

size :: Size (FunPtr a)

poke :: FunPtr a -> Poke ()

peek :: Peek (FunPtr a)

Store a => Store (Complex a)

Defined in Data.Store.Internal

Methods

size :: Size (Complex a)

poke :: Complex a -> Poke ()

peek :: Peek (Complex a)

Store (Fixed a)

Defined in Data.Store.Internal

Methods

size :: Size (Fixed a)

poke :: Fixed a -> Poke ()

peek :: Peek (Fixed a)

Store a => Store (Identity a)

Defined in Data.Store.Internal

Methods

size :: Size (Identity a)

poke :: Identity a -> Poke ()

peek :: Peek (Identity a)

Store a => Store (First a)

Defined in Data.Store.Internal

Methods

size :: Size (First a)

poke :: First a -> Poke ()

peek :: Peek (First a)

Store a => Store (Last a)

Defined in Data.Store.Internal

Methods

size :: Size (Last a)

poke :: Last a -> Poke ()

peek :: Peek (Last a)

Store a => Store (Dual a)

Defined in Data.Store.Internal

Methods

size :: Size (Dual a)

poke :: Dual a -> Poke ()

peek :: Peek (Dual a)

Store a => Store (Sum a)

Defined in Data.Store.Internal

Methods

size :: Size (Sum a)

poke :: Sum a -> Poke ()

peek :: Peek (Sum a)

Store a => Store (Product a)

Defined in Data.Store.Internal

Methods

size :: Size (Product a)

poke :: Product a -> Poke ()

peek :: Peek (Product a)

Store a => Store (NonEmpty a)

Defined in Data.Store.Internal

Methods

size :: Size (NonEmpty a)

poke :: NonEmpty a -> Poke ()

peek :: Peek (NonEmpty a)

Store a => Store (IntMap a)

Defined in Data.Store.Internal

Methods

size :: Size (IntMap a)

poke :: IntMap a -> Poke ()

peek :: Peek (IntMap a)

Store a => Store (Seq a)

Defined in Data.Store.Internal

Methods

size :: Size (Seq a)

poke :: Seq a -> Poke ()

peek :: Peek (Seq a)

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

Defined in Data.Store.Internal

Methods

size :: Size (Set a)

poke :: Set a -> Poke ()

peek :: Peek (Set a)

Prim a => Store (PrimStorable a)

Defined in Data.Store.Internal

Methods

size :: Size (PrimStorable a)

poke :: PrimStorable a -> Poke ()

peek :: Peek (PrimStorable a)

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

Defined in Data.Store.Internal

Methods

size :: Size (HashSet a)

poke :: HashSet a -> Poke ()

peek :: Peek (HashSet a)

Store (Vector Bool)

Defined in Data.Store.Internal

Methods

size :: Size (Vector Bool)

poke :: Vector Bool -> Poke ()

peek :: Peek (Vector Bool)

Store (Vector Char)

Defined in Data.Store.Internal

Methods

size :: Size (Vector Char)

poke :: Vector Char -> Poke ()

peek :: Peek (Vector Char)

Store (Vector Double)

Defined in Data.Store.Internal

Methods

size :: Size (Vector Double)

poke :: Vector Double -> Poke ()

peek :: Peek (Vector Double)

Store (Vector Float)

Defined in Data.Store.Internal

Methods

size :: Size (Vector Float)

poke :: Vector Float -> Poke ()

peek :: Peek (Vector Float)

Store (Vector Int)

Defined in Data.Store.Internal

Methods

size :: Size (Vector Int)

poke :: Vector Int -> Poke ()

peek :: Peek (Vector Int)

Store (Vector Int8)

Defined in Data.Store.Internal

Methods

size :: Size (Vector Int8)

poke :: Vector Int8 -> Poke ()

peek :: Peek (Vector Int8)

Store (Vector Int16)

Defined in Data.Store.Internal

Methods

size :: Size (Vector Int16)

poke :: Vector Int16 -> Poke ()

peek :: Peek (Vector Int16)

Store (Vector Int32)

Defined in Data.Store.Internal

Methods

size :: Size (Vector Int32)

poke :: Vector Int32 -> Poke ()

peek :: Peek (Vector Int32)

Store (Vector Int64)

Defined in Data.Store.Internal

Methods

size :: Size (Vector Int64)

poke :: Vector Int64 -> Poke ()

peek :: Peek (Vector Int64)

Store (Vector Word)

Defined in Data.Store.Internal

Methods

size :: Size (Vector Word)

poke :: Vector Word -> Poke ()

peek :: Peek (Vector Word)

Store (Vector Word8)

Defined in Data.Store.Internal

Methods

size :: Size (Vector Word8)

poke :: Vector Word8 -> Poke ()

peek :: Peek (Vector Word8)

Store (Vector Word16)

Defined in Data.Store.Internal

Methods

size :: Size (Vector Word16)

poke :: Vector Word16 -> Poke ()

peek :: Peek (Vector Word16)

Store (Vector Word32)

Defined in Data.Store.Internal

Methods

size :: Size (Vector Word32)

poke :: Vector Word32 -> Poke ()

peek :: Peek (Vector Word32)

Store (Vector Word64)

Defined in Data.Store.Internal

Methods

size :: Size (Vector Word64)

poke :: Vector Word64 -> Poke ()

peek :: Peek (Vector Word64)

Store (Vector ())

Defined in Data.Store.Internal

Methods

size :: Size (Vector ())

poke :: Vector () -> Poke ()

peek :: Peek (Vector ())

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

Defined in Data.Store.Internal

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))

Defined in Data.Store.Internal

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))

Defined in Data.Store.Internal

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))

Defined in Data.Store.Internal

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))

Defined in Data.Store.Internal

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))

Defined in Data.Store.Internal

Methods

size :: Size (Vector (Complex a))

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

peek :: Peek (Vector (Complex a))

Store (Vector (f (g a))) => Store (Vector (Compose f g a))

Defined in Data.Store.Internal

Methods

size :: Size (Vector (Compose f g a))

poke :: Vector (Compose f g a) -> Poke ()

peek :: Peek (Vector (Compose f g a))

Store (Vector a) => Store (Vector (Min a))

Defined in Data.Store.Internal

Methods

size :: Size (Vector (Min a))

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

peek :: Peek (Vector (Min a))

Store (Vector a) => Store (Vector (Max a))

Defined in Data.Store.Internal

Methods

size :: Size (Vector (Max a))

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

peek :: Peek (Vector (Max a))

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

Defined in Data.Store.Internal

Methods

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

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

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

Store (Vector a) => Store (Vector (First a))

Defined in Data.Store.Internal

Methods

size :: Size (Vector (First a))

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

peek :: Peek (Vector (First a))

Store (Vector a) => Store (Vector (Last a))

Defined in Data.Store.Internal

Methods

size :: Size (Vector (Last a))

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

peek :: Peek (Vector (Last a))

Store (Vector a) => Store (Vector (WrappedMonoid a))

Defined in Data.Store.Internal

Methods

size :: Size (Vector (WrappedMonoid a))

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

peek :: Peek (Vector (WrappedMonoid a))

Store (Vector a) => Store (Vector (Identity a))

Defined in Data.Store.Internal

Methods

size :: Size (Vector (Identity a))

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

peek :: Peek (Vector (Identity a))

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

Defined in Data.Store.Internal

Methods

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

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

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

Store (Vector a) => Store (Vector (Dual a))

Defined in Data.Store.Internal

Methods

size :: Size (Vector (Dual a))

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

peek :: Peek (Vector (Dual a))

Store (Vector All)

Defined in Data.Store.Internal

Methods

size :: Size (Vector All)

poke :: Vector All -> Poke ()

peek :: Peek (Vector All)

Store (Vector Any)

Defined in Data.Store.Internal

Methods

size :: Size (Vector Any)

poke :: Vector Any -> Poke ()

peek :: Peek (Vector Any)

Store (Vector a) => Store (Vector (Sum a))

Defined in Data.Store.Internal

Methods

size :: Size (Vector (Sum a))

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

peek :: Peek (Vector (Sum a))

Store (Vector a) => Store (Vector (Product a))

Defined in Data.Store.Internal

Methods

size :: Size (Vector (Product a))

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

peek :: Peek (Vector (Product a))

Store (Vector (f a)) => Store (Vector (Alt f a))

Defined in Data.Store.Internal

Methods

size :: Size (Vector (Alt f a))

poke :: Vector (Alt f a) -> Poke ()

peek :: Peek (Vector (Alt f a))

Store (Vector a) => Store (Vector (Down a))

Defined in Data.Store.Internal

Methods

size :: Size (Vector (Down a))

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

peek :: Peek (Vector (Down a))

Storable a => Store (Vector a)

Defined in Data.Store.Internal

Methods

size :: Size (Vector a)

poke :: Vector a -> Poke ()

peek :: Peek (Vector a)

Store (Vector Char)

Defined in Data.Store.Internal

Methods

size :: Size (Vector Char)

poke :: Vector Char -> Poke ()

peek :: Peek (Vector Char)

Store (Vector Double)

Defined in Data.Store.Internal

Methods

size :: Size (Vector Double)

poke :: Vector Double -> Poke ()

peek :: Peek (Vector Double)

Store (Vector Float)

Defined in Data.Store.Internal

Methods

size :: Size (Vector Float)

poke :: Vector Float -> Poke ()

peek :: Peek (Vector Float)

Store (Vector Int)

Defined in Data.Store.Internal

Methods

size :: Size (Vector Int)

poke :: Vector Int -> Poke ()

peek :: Peek (Vector Int)

Store (Vector Int8)

Defined in Data.Store.Internal

Methods

size :: Size (Vector Int8)

poke :: Vector Int8 -> Poke ()

peek :: Peek (Vector Int8)

Store (Vector Int16)

Defined in Data.Store.Internal

Methods

size :: Size (Vector Int16)

poke :: Vector Int16 -> Poke ()

peek :: Peek (Vector Int16)

Store (Vector Int32)

Defined in Data.Store.Internal

Methods

size :: Size (Vector Int32)

poke :: Vector Int32 -> Poke ()

peek :: Peek (Vector Int32)

Store (Vector Int64)

Defined in Data.Store.Internal

Methods

size :: Size (Vector Int64)

poke :: Vector Int64 -> Poke ()

peek :: Peek (Vector Int64)

Store (Vector (StablePtr a))

Defined in Data.Store.Internal

Methods

size :: Size (Vector (StablePtr a))

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

peek :: Peek (Vector (StablePtr a))

Store (Vector Word)

Defined in Data.Store.Internal

Methods

size :: Size (Vector Word)

poke :: Vector Word -> Poke ()

peek :: Peek (Vector Word)

Store (Vector Word8)

Defined in Data.Store.Internal

Methods

size :: Size (Vector Word8)

poke :: Vector Word8 -> Poke ()

peek :: Peek (Vector Word8)

Store (Vector Word16)

Defined in Data.Store.Internal

Methods

size :: Size (Vector Word16)

poke :: Vector Word16 -> Poke ()

peek :: Peek (Vector Word16)

Store (Vector Word32)

Defined in Data.Store.Internal

Methods

size :: Size (Vector Word32)

poke :: Vector Word32 -> Poke ()

peek :: Peek (Vector Word32)

Store (Vector Word64)

Defined in Data.Store.Internal

Methods

size :: Size (Vector Word64)

poke :: Vector Word64 -> Poke ()

peek :: Peek (Vector Word64)

Store (Vector (Ptr a))

Defined in Data.Store.Internal

Methods

size :: Size (Vector (Ptr a))

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

peek :: Peek (Vector (Ptr a))

Store (Vector (FunPtr a))

Defined in Data.Store.Internal

Methods

size :: Size (Vector (FunPtr a))

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

peek :: Peek (Vector (FunPtr a))

Prim a => Store (Vector (Min a))

Defined in Data.Store.Internal

Methods

size :: Size (Vector (Min a))

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

peek :: Peek (Vector (Min a))

Prim a => Store (Vector (Max a))

Defined in Data.Store.Internal

Methods

size :: Size (Vector (Max a))

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

peek :: Peek (Vector (Max a))

Prim a => Store (Vector (First a))

Defined in Data.Store.Internal

Methods

size :: Size (Vector (First a))

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

peek :: Peek (Vector (First a))

Prim a => Store (Vector (Last a))

Defined in Data.Store.Internal

Methods

size :: Size (Vector (Last a))

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

peek :: Peek (Vector (Last a))

Prim a => Store (Vector (Identity a))

Defined in Data.Store.Internal

Methods

size :: Size (Vector (Identity a))

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

peek :: Peek (Vector (Identity a))

Store (Vector CDev)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CDev)

poke :: Vector CDev -> Poke ()

peek :: Peek (Vector CDev)

Store (Vector CIno)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CIno)

poke :: Vector CIno -> Poke ()

peek :: Peek (Vector CIno)

Store (Vector CMode)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CMode)

poke :: Vector CMode -> Poke ()

peek :: Peek (Vector CMode)

Store (Vector COff)

Defined in Data.Store.Internal

Methods

size :: Size (Vector COff)

poke :: Vector COff -> Poke ()

peek :: Peek (Vector COff)

Store (Vector CPid)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CPid)

poke :: Vector CPid -> Poke ()

peek :: Peek (Vector CPid)

Store (Vector CSsize)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CSsize)

poke :: Vector CSsize -> Poke ()

peek :: Peek (Vector CSsize)

Store (Vector CGid)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CGid)

poke :: Vector CGid -> Poke ()

peek :: Peek (Vector CGid)

Store (Vector CNlink)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CNlink)

poke :: Vector CNlink -> Poke ()

peek :: Peek (Vector CNlink)

Store (Vector CUid)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CUid)

poke :: Vector CUid -> Poke ()

peek :: Peek (Vector CUid)

Store (Vector CCc)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CCc)

poke :: Vector CCc -> Poke ()

peek :: Peek (Vector CCc)

Store (Vector CSpeed)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CSpeed)

poke :: Vector CSpeed -> Poke ()

peek :: Peek (Vector CSpeed)

Store (Vector CTcflag)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CTcflag)

poke :: Vector CTcflag -> Poke ()

peek :: Peek (Vector CTcflag)

Store (Vector CRLim)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CRLim)

poke :: Vector CRLim -> Poke ()

peek :: Peek (Vector CRLim)

Store (Vector CBlkSize)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CBlkSize)

poke :: Vector CBlkSize -> Poke ()

peek :: Peek (Vector CBlkSize)

Store (Vector CBlkCnt)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CBlkCnt)

poke :: Vector CBlkCnt -> Poke ()

peek :: Peek (Vector CBlkCnt)

Store (Vector CClockId)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CClockId)

poke :: Vector CClockId -> Poke ()

peek :: Peek (Vector CClockId)

Store (Vector CFsBlkCnt)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CFsBlkCnt)

poke :: Vector CFsBlkCnt -> Poke ()

peek :: Peek (Vector CFsBlkCnt)

Store (Vector CFsFilCnt)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CFsFilCnt)

poke :: Vector CFsFilCnt -> Poke ()

peek :: Peek (Vector CFsFilCnt)

Store (Vector CId)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CId)

poke :: Vector CId -> Poke ()

peek :: Peek (Vector CId)

Store (Vector CKey)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CKey)

poke :: Vector CKey -> Poke ()

peek :: Peek (Vector CKey)

Store (Vector CTimer)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CTimer)

poke :: Vector CTimer -> Poke ()

peek :: Peek (Vector CTimer)

Store (Vector Fd)

Defined in Data.Store.Internal

Methods

size :: Size (Vector Fd)

poke :: Vector Fd -> Poke ()

peek :: Peek (Vector Fd)

Prim a => Store (Vector (Const a b))

Defined in Data.Store.Internal

Methods

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

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

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

Prim a => Store (Vector (Dual a))

Defined in Data.Store.Internal

Methods

size :: Size (Vector (Dual a))

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

peek :: Peek (Vector (Dual a))

Prim a => Store (Vector (Sum a))

Defined in Data.Store.Internal

Methods

size :: Size (Vector (Sum a))

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

peek :: Peek (Vector (Sum a))

Prim a => Store (Vector (Product a))

Defined in Data.Store.Internal

Methods

size :: Size (Vector (Product a))

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

peek :: Peek (Vector (Product a))

Prim a => Store (Vector (Down a))

Defined in Data.Store.Internal

Methods

size :: Size (Vector (Down a))

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

peek :: Peek (Vector (Down a))

Store (Vector CChar)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CChar)

poke :: Vector CChar -> Poke ()

peek :: Peek (Vector CChar)

Store (Vector CSChar)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CSChar)

poke :: Vector CSChar -> Poke ()

peek :: Peek (Vector CSChar)

Store (Vector CUChar)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CUChar)

poke :: Vector CUChar -> Poke ()

peek :: Peek (Vector CUChar)

Store (Vector CShort)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CShort)

poke :: Vector CShort -> Poke ()

peek :: Peek (Vector CShort)

Store (Vector CUShort)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CUShort)

poke :: Vector CUShort -> Poke ()

peek :: Peek (Vector CUShort)

Store (Vector CInt)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CInt)

poke :: Vector CInt -> Poke ()

peek :: Peek (Vector CInt)

Store (Vector CUInt)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CUInt)

poke :: Vector CUInt -> Poke ()

peek :: Peek (Vector CUInt)

Store (Vector CLong)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CLong)

poke :: Vector CLong -> Poke ()

peek :: Peek (Vector CLong)

Store (Vector CULong)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CULong)

poke :: Vector CULong -> Poke ()

peek :: Peek (Vector CULong)

Store (Vector CLLong)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CLLong)

poke :: Vector CLLong -> Poke ()

peek :: Peek (Vector CLLong)

Store (Vector CULLong)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CULLong)

poke :: Vector CULLong -> Poke ()

peek :: Peek (Vector CULLong)

Store (Vector CBool)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CBool)

poke :: Vector CBool -> Poke ()

peek :: Peek (Vector CBool)

Store (Vector CFloat)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CFloat)

poke :: Vector CFloat -> Poke ()

peek :: Peek (Vector CFloat)

Store (Vector CDouble)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CDouble)

poke :: Vector CDouble -> Poke ()

peek :: Peek (Vector CDouble)

Store (Vector CPtrdiff)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CPtrdiff)

poke :: Vector CPtrdiff -> Poke ()

peek :: Peek (Vector CPtrdiff)

Store (Vector CSize)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CSize)

poke :: Vector CSize -> Poke ()

peek :: Peek (Vector CSize)

Store (Vector CWchar)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CWchar)

poke :: Vector CWchar -> Poke ()

peek :: Peek (Vector CWchar)

Store (Vector CSigAtomic)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CSigAtomic)

poke :: Vector CSigAtomic -> Poke ()

peek :: Peek (Vector CSigAtomic)

Store (Vector CClock)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CClock)

poke :: Vector CClock -> Poke ()

peek :: Peek (Vector CClock)

Store (Vector CTime)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CTime)

poke :: Vector CTime -> Poke ()

peek :: Peek (Vector CTime)

Store (Vector CUSeconds)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CUSeconds)

poke :: Vector CUSeconds -> Poke ()

peek :: Peek (Vector CUSeconds)

Store (Vector CSUSeconds)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CSUSeconds)

poke :: Vector CSUSeconds -> Poke ()

peek :: Peek (Vector CSUSeconds)

Store (Vector CIntPtr)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CIntPtr)

poke :: Vector CIntPtr -> Poke ()

peek :: Peek (Vector CIntPtr)

Store (Vector CUIntPtr)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CUIntPtr)

poke :: Vector CUIntPtr -> Poke ()

peek :: Peek (Vector CUIntPtr)

Store (Vector CIntMax)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CIntMax)

poke :: Vector CIntMax -> Poke ()

peek :: Peek (Vector CIntMax)

Store (Vector CUIntMax)

Defined in Data.Store.Internal

Methods

size :: Size (Vector CUIntMax)

poke :: Vector CUIntMax -> Poke ()

peek :: Peek (Vector CUIntMax)

Store a => Store (Vector a)

Defined in Data.Store.Internal

Methods

size :: Size (Vector a)

poke :: Vector a -> Poke ()

peek :: Peek (Vector a)

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

Defined in Data.Store.TypeHash.Internal

Methods

size :: Size (Tagged a)

poke :: Tagged a -> Poke ()

peek :: Peek (Tagged a)

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

Defined in Data.Store.Internal

Methods

size :: Size (Either a b)

poke :: Either a b -> Poke ()

peek :: Peek (Either a b)

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

Defined in Data.Store.Internal

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)

Defined in Data.Store.Internal

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)

Defined in Data.Store.Internal

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)

Defined in Data.Store.Internal

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)

Defined in Data.Store.Internal

Methods

size :: Size (HashMap k a)

poke :: HashMap k a -> Poke ()

peek :: Peek (HashMap k a)

KnownNat n => Store (StaticSize n ByteString)

Defined in Data.Store.Internal

Methods

size :: Size (StaticSize n ByteString)

poke :: StaticSize n ByteString -> Poke ()

peek :: Peek (StaticSize n ByteString)

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

Defined in Data.Store.Internal

Methods

size :: Size (a, b, c)

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

peek :: Peek (a, b, c)

Store a => Store (Const a b)

Defined in Data.Store.Internal

Methods

size :: Size (Const a b)

poke :: Const a b -> Poke ()

peek :: Peek (Const a b)

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

Defined in Data.Store.Internal

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)

Defined in Data.Store.Internal

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)

Defined in Data.Store.Internal

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)

Defined in Data.Store.Internal

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)

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

Instances

Contravariant Size

Defined in Data.Store.Impl

Methods

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

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

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

Defined in Data.Store.Core

Methods

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

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

return :: a -> Poke a

fail :: String -> Poke a

Functor Poke

Defined in Data.Store.Core

Methods

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

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

MonadFail Poke

Defined in Data.Store.Core

Methods

fail :: String -> Poke a

Applicative Poke

Defined in Data.Store.Core

Methods

pure :: a -> Poke a

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

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

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

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

MonadIO Poke

Defined in Data.Store.Core

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

Defined in Data.Store.Core

Methods

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

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

return :: a -> Peek a

fail :: String -> Peek a

Functor Peek

Defined in Data.Store.Core

Methods

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

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

MonadFail Peek

Defined in Data.Store.Core

Methods

fail :: String -> Peek a

Applicative Peek

Defined in Data.Store.Core

Methods

pure :: a -> Peek a

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

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

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

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

MonadIO Peek

Defined in Data.Store.Core

Methods

liftIO :: IO a -> Peek a

PrimMonad Peek

Defined in Data.Store.Core

Associated Types

type PrimState Peek :: Type

Methods

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

type PrimState Peek

Defined in Data.Store.Core

type PrimState Peek = RealWorld

class GStoreSize f

Minimal complete definition

gsize

Instances

GStoreSize (V1 :: Type -> Type)

Defined in Data.Store.Impl

Methods

gsize :: Size (V1 a)

GStoreSize (U1 :: Type -> Type)

Defined in Data.Store.Impl

Methods

gsize :: Size (U1 a)

Store a => GStoreSize (K1 i a :: Type -> Type)

Defined in Data.Store.Impl

Methods

gsize :: Size (K1 i a a0)

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

Defined in Data.Store.Impl

Methods

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

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

Defined in Data.Store.Impl

Methods

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

GStoreSize f => GStoreSize (M1 i c f)

Defined in Data.Store.Impl

Methods

gsize :: Size (M1 i c f a)

class GStorePoke f

Minimal complete definition

gpoke

Instances

GStorePoke (V1 :: Type -> Type)

Defined in Data.Store.Impl

Methods

gpoke :: V1 a -> Poke ()

GStorePoke (U1 :: Type -> Type)

Defined in Data.Store.Impl

Methods

gpoke :: U1 a -> Poke ()

Store a => GStorePoke (K1 i a :: Type -> Type)

Defined in Data.Store.Impl

Methods

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

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

Defined in Data.Store.Impl

Methods

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

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

Defined in Data.Store.Impl

Methods

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

GStorePoke f => GStorePoke (M1 i c f)

Defined in Data.Store.Impl

Methods

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

class GStorePeek f

Minimal complete definition

gpeek

Instances

GStorePeek (V1 :: Type -> Type)

Defined in Data.Store.Impl

Methods

gpeek :: Peek (V1 a)

GStorePeek (U1 :: Type -> Type)

Defined in Data.Store.Impl

Methods

gpeek :: Peek (U1 a)

Store a => GStorePeek (K1 i a :: Type -> Type)

Defined in Data.Store.Impl

Methods

gpeek :: Peek (K1 i a a0)

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

Defined in Data.Store.Impl

Methods

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

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

Defined in Data.Store.Impl

Methods

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

GStorePeek f => GStorePeek (M1 i c f)

Defined in Data.Store.Impl

Methods

gpeek :: Peek (M1 i c f a)

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

Defined in Data.Store.Core

Methods

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

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

Show PeekException

Defined in Data.Store.Core

Methods

showsPrec :: Int -> PeekException -> ShowS

show :: PeekException -> String

showList :: [PeekException] -> ShowS

Exception PeekException

Defined in Data.Store.Core

Methods

toException :: PeekException -> SomeException

fromException :: SomeException -> Maybe PeekException

displayException :: PeekException -> String

peekException :: Text -> Peek a

Throws a PeekException.