store-0.4.3.1: Fast binary serialization

Safe Haskell | None
Language | Haskell2010

Data.Store.Internal

Contents

- Encoding and decoding strict ByteStrings.
- Store class and related types.
  - Exceptions thrown by Poke
  - Exceptions thrown by Peek
  - Size type
  - Store instances in terms of IsSequence
  - Store instances in terms of IsSet
  - Store instances in terms of IsMap
    - Utilities for ordered maps
  - Store instances in terms of IArray
  - Store instances in terms of Generic
  - Peek utilities
  - Static Size type
- Orphan instances

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

- encode :: Store a => a -> ByteString
- decode :: Store a => ByteString -> Either PeekException a
- decodeWith :: Peek a -> ByteString -> Either PeekException a
- decodeEx :: Store a => ByteString -> a
- decodeExWith :: Peek a -> ByteString -> a
- decodeExPortionWith :: Peek a -> ByteString -> (Offset, a)
- decodeIO :: Store a => ByteString -> IO a
- decodeIOWith :: Peek a -> ByteString -> IO a
- decodeIOPortionWith :: Peek a -> ByteString -> IO (Offset, a)
- class Store a where
- data Poke a :: * -> *
- data Peek a :: * -> *
- runPeek :: Peek a -> PeekState -> Ptr Word8 -> IO (PeekResult a)
- data PokeException :: * = PokeException {
  - pokeExByteIndex :: Offset
  - pokeExMessage :: Text
  }
- pokeException :: Text -> Poke a
- data PeekException :: * = PeekException {
  - peekExBytesFromEnd :: Offset
  - peekExMessage :: Text
  }
- peekException :: Text -> Peek a
- tooManyBytes :: Int -> Int -> String -> IO void
- data Size a
  - = VarSize (a -> Int)
  - | ConstSize !Int
- getSize :: Store a => a -> Int
- getSizeWith :: Size a -> a -> Int
- combineSize :: forall a b c. (Store a, Store b) => (c -> a) -> (c -> b) -> Size c
- combineSizeWith :: forall a b c. (c -> a) -> (c -> b) -> Size a -> Size b -> Size c
- addSize :: Int -> Size a -> Size a
- sizeSequence :: forall t. (IsSequence t, Store (Element t)) => Size t
- pokeSequence :: (IsSequence t, Store (Element t)) => t -> Poke ()
- peekSequence :: (IsSequence t, Store (Element t), Index t ~ Int) => Peek t
- sizeSet :: forall t. (IsSet t, Store (Element t)) => Size t
- pokeSet :: (IsSet t, Store (Element t)) => t -> Poke ()
- peekSet :: (IsSet t, Store (Element t)) => Peek t
- sizeMap :: forall t. (Store (ContainerKey t), Store (MapValue t), IsMap t) => Size t
- pokeMap :: (Store (ContainerKey t), Store (MapValue t), IsMap t) => t -> Poke ()
- peekMap :: (Store (ContainerKey t), Store (MapValue t), IsMap t) => Peek t
- sizeOrdMap :: forall t. (Store (ContainerKey t), Store (MapValue t), IsMap t) => Size t
- pokeOrdMap :: (Store (ContainerKey t), Store (MapValue t), IsMap t) => t -> Poke ()
- peekOrdMapWith :: (Store (ContainerKey t), Store (MapValue t)) => ([(ContainerKey t, MapValue t)] -> t) -> Peek t
- 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)
- class GStoreSize f
- genericSize :: (Generic a, GStoreSize (Rep a)) => Size a
- class GStorePoke f
- genericPoke :: (Generic a, GStorePoke (Rep a)) => a -> Poke ()
- class GStorePeek f
- genericPeek :: (Generic a, GStorePeek (Rep a)) => Peek a
- skip :: Int -> Peek ()
- isolate :: Int -> Peek a -> Peek a
- peekMagic :: (Eq a, Show a, Store a) => String -> a -> Peek ()
- class KnownNat n => IsStaticSize n a where
- newtype StaticSize n a = StaticSize {
  - unStaticSize :: 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

# 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, 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 `Poke`s 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 -> PeekState -> Ptr Word8 -> IO (PeekResult 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.

`PokeException`s 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 |

Instances

Contravariant Size # |
Methods contramap :: (a -> b) -> Size b -> Size a # (>$) :: b -> Size b -> Size a #

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.

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.

### Utilities for ordered maps

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

Like `sizeMap` but should only be used for ordered containers where `mapToList` returns an ascending list.

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

Like `pokeMap` but should only be used for ordered containers where `mapToList` returns an ascending list.

peekOrdMapWith #

Arguments

:: (Store (ContainerKey t), Store (MapValue t)) |
=> ([(ContainerKey t, MapValue t)] -> t) | A function to construct the map from an ascending list such as `fromDistinctAscList`.
-> Peek t |

Decode the results of `pokeOrdMap` using a given function to construct the map.

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

peekMagic :: (Eq a, Show a, Store a) => String -> a -> Peek () #

Ensure the presence of a given magic value.

Throws a `PeekException` if the value isn't present.

## 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.4.3.1-GlJz9kjb2kSBDpUelzHNU6" 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 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 # |
Methods size :: Size CTcflag # poke :: CTcflag -> Poke () # peek :: Peek 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 # |
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 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 # |
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 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 (Ptr a0)) # |
Methods size :: Size (Vector (Ptr a0)) # poke :: Vector (Ptr a0) -> Poke () # peek :: Peek (Vector (Ptr a0)) #
Store (Vector (FunPtr a0)) # |
Methods size :: Size (Vector (FunPtr a0)) # poke :: Vector (FunPtr a0) -> Poke () # peek :: Peek (Vector (FunPtr a0)) #
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) #