store-0.3: Fast binary serialization

Safe HaskellNone
LanguageHaskell2010

Data.Store.Internal

Contents

Description

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

Synopsis

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.

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 :: * -> *) :: * #

type PrimState Peek 

runPeek :: Peek a -> PeekState -> Ptr Word8 -> IO (Ptr Word8, 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.

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.

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)

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)

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

newtype StaticSize n a #

Constructors

StaticSize 

Fields

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) # 
type Rep (StaticSize n a) # 
type Rep (StaticSize n a) = D1 (MetaData "StaticSize" "Data.Store.Internal" "store-0.3-3DtT0roqFxe896L8CbwuxK" True) (C1 (MetaCons "StaticSize" PrefixI True) (S1 (MetaSel (Just Symbol "unStaticSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

liftStaticSize :: forall n a. (KnownNat n, Lift a) => TypeQ -> StaticSize n a -> 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 # 
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 # 
Store InjectivityAnn # 
Store Overlap # 
Store () # 

Methods

size :: Size () #

poke :: () -> Poke () #

peek :: Peek () #

Store Void # 

Methods

size :: Size Void #

poke :: Void -> Poke () #

peek :: Peek Void #

Store CDev # 

Methods

size :: Size CDev #

poke :: CDev -> Poke () #

peek :: Peek CDev #

Store CIno # 

Methods

size :: Size CIno #

poke :: CIno -> Poke () #

peek :: Peek CIno #

Store CMode # 

Methods

size :: Size CMode #

poke :: CMode -> Poke () #

peek :: Peek CMode #

Store COff # 

Methods

size :: Size COff #

poke :: COff -> Poke () #

peek :: Peek COff #

Store CPid # 

Methods

size :: Size CPid #

poke :: CPid -> Poke () #

peek :: Peek CPid #

Store CSsize # 

Methods

size :: Size CSsize #

poke :: CSsize -> Poke () #

peek :: Peek CSsize #

Store CGid # 

Methods

size :: Size CGid #

poke :: CGid -> Poke () #

peek :: Peek CGid #

Store CNlink # 

Methods

size :: Size CNlink #

poke :: CNlink -> Poke () #

peek :: Peek CNlink #

Store CUid # 

Methods

size :: Size CUid #

poke :: CUid -> Poke () #

peek :: Peek CUid #

Store CCc # 

Methods

size :: Size CCc #

poke :: CCc -> Poke () #

peek :: Peek CCc #

Store CSpeed # 

Methods

size :: Size CSpeed #

poke :: CSpeed -> Poke () #

peek :: Peek CSpeed #

Store CTcflag # 
Store CRLim # 

Methods

size :: Size CRLim #

poke :: CRLim -> Poke () #

peek :: Peek CRLim #

Store Fd # 

Methods

size :: Size Fd #

poke :: Fd -> Poke () #

peek :: Peek Fd #

Store 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 # 
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 # 
Store CFloat # 

Methods

size :: Size CFloat #

poke :: CFloat -> Poke () #

peek :: Peek CFloat #

Store CDouble # 
Store 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 # 
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 # 
Store CSUSeconds # 
Store CIntPtr # 
Store CUIntPtr # 
Store CIntMax # 
Store 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 # 
Store ShortByteString # 
Store ByteString # 
Store ByteString # 
Store Text # 

Methods

size :: Size Text #

poke :: Text -> Poke () #

peek :: Peek Text #

Store IntSet # 

Methods

size :: Size IntSet #

poke :: IntSet -> Poke () #

peek :: Peek IntSet #

Store ModName # 
Store PkgName # 
Store OccName # 
Store NameFlavour # 
Store 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 # 
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 # 
Store TySynEqn # 
Store Foreign # 
Store 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 # 
Store Phases # 

Methods

size :: Size Phases #

poke :: Phases -> Poke () #

peek :: Peek Phases #

Store RuleBndr # 
Store AnnTarget # 
Store SourceUnpackedness # 
Store 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 # 
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 UTCTime # 
Store Day # 

Methods

size :: Size Day #

poke :: Day -> Poke () #

peek :: Peek Day #

Store 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) # 
Store (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) # 
Store (Vector Int32) # 
Store (Vector Int64) # 
Store (Vector Word) # 

Methods

size :: Size (Vector Word) #

poke :: Vector Word -> Poke () #

peek :: Peek (Vector Word) #

Store (Vector Word8) # 
Store (Vector Word16) # 
Store (Vector Word32) # 
Store (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) # 
Store (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) # 
Store (Vector Int32) # 
Store (Vector Int64) # 
Store (Vector Word) # 

Methods

size :: Size (Vector Word) #

poke :: Vector Word -> Poke () #

peek :: Peek (Vector Word) #

Store (Vector Word8) # 
Store (Vector Word16) # 
Store (Vector Word32) # 
Store (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) #