Copyright | (c) Edward Kmett 2013-2015 |
---|---|
License | BSD3 |
Maintainer | Edward Kmett <ekmett@gmail.com> |
Stability | experimental |
Portability | non-portable |
Safe Haskell | Trustworthy |
Language | Haskell98 |
This module contains two main classes, each providing methods to
serialize and deserialize types. Serial
is the primary class,
to be used for the canonical way to serialize a specific
type. SerialEndian
is used to provide endian-specific methods
for serializing a type.
- class Serial a where
- class SerialEndian a where
- class Serial1 f where
- serialize1 :: (MonadPut m, Serial1 f, Serial a) => f a -> m ()
- deserialize1 :: (MonadGet m, Serial1 f, Serial a) => m (f a)
- class Serial2 f where
- serialize2 :: (MonadPut m, Serial2 f, Serial a, Serial b) => f a b -> m ()
- deserialize2 :: (MonadGet m, Serial2 f, Serial a, Serial b) => m (f a b)
- store :: (MonadPut m, Storable a) => a -> m ()
- restore :: forall m a. (MonadGet m, Storable a) => m a
- class GSerial f where
- class GSerialEndian f where
- class GSerial1 f where
Serialization
Methods to serialize and deserialize type a
to a binary representation
Instances provided here for fixed-with Integers and Words are big endian. Instances for strict and lazy bytestrings store also the length of bytestring big endian. Instances for Word and Int are host endian as they are machine-specific types.
serialize :: MonadPut m => a -> m () #
serialize :: (MonadPut m, GSerial (Rep a), Generic a) => a -> m () #
deserialize :: MonadGet m => m a #
deserialize :: (MonadGet m, GSerial (Rep a), Generic a) => m a #
Serial Bool # | |
Serial Char # | |
Serial Double # | |
Serial Float # | |
Serial Int # | |
Serial Int8 # | |
Serial Int16 # | |
Serial Int32 # | |
Serial Int64 # | |
Serial Integer # |
|
Serial Ordering # |
|
Serial Word # | |
Serial Word8 # | |
Serial Word16 # | |
Serial Word32 # | |
Serial Word64 # | |
Serial () # | |
Serial Natural # |
|
Serial Void # | |
Serial Version # | |
Serial All # | |
Serial Any # | |
Serial ByteString # | |
Serial ByteString # | |
Serial IntSet # | |
Serial Scientific # | |
Serial Text # | |
Serial Text # | |
Serial AbsoluteTime # |
|
Serial LocalTime # | |
Serial ZonedTime # | |
Serial TimeOfDay # | |
Serial TimeZone # | |
Serial UTCTime # |
|
Serial NominalDiffTime # |
|
Serial Day # |
|
Serial UniversalTime # |
|
Serial DiffTime # |
|
Serial a => Serial [a] # | |
Serial a => Serial (Maybe a) # | |
(Serial a, Integral a) => Serial (Ratio a) # |
|
Serial a => Serial (Identity a) # | |
HasResolution a => Serial (Fixed a) # |
|
Serial a => Serial (ZipList a) # | |
Serial a => Serial (Dual a) # | |
Serial a => Serial (Sum a) # | |
Serial a => Serial (Product a) # | |
Serial a => Serial (First a) # | |
Serial a => Serial (Last a) # | |
Serial a => Serial (Down a) # | |
Serial v => Serial (IntMap v) # | |
Serial a => Serial (Seq a) # | |
(Serial a, Ord a) => Serial (Set a) # | |
(Serial v, Hashable v, Eq v) => Serial (HashSet v) # | |
(Bits n, Integral n, Bits (Unsigned n), Integral (Unsigned n)) => Serial (VarInt n) # | Integer/Word types serialized to base-128 variable-width ints.
|
(Serial a, Serial b) => Serial (Either a b) # | |
(Serial a, Serial b) => Serial (a, b) # | |
(Serial k, Serial v, Ord k) => Serial (Map k v) # | |
(Serial k, Serial v, Hashable k, Eq k) => Serial (HashMap k v) # | |
(Serial a, Serial b, Serial c) => Serial (a, b, c) # | |
Serial (f a) => Serial (Reverse * f a) # | |
Serial a => Serial (Constant * a b) # | |
(Serial a, Serial b, Serial c, Serial d) => Serial (a, b, c, d) # | |
(Serial (f a), Serial (g a)) => Serial (Product * f g a) # | |
(Serial a, Serial b, Serial c, Serial d, Serial e) => Serial (a, b, c, d, e) # | |
Specifying endianness
class SerialEndian a where #
Methods to serialize and deserialize type a
to a big and little endian
binary representations. Methods suffixed with "host" are automatically defined
to use equal the methods corresponding to the current machine's native
endianness, but they can be overridden.
serializeBE :: MonadPut m => a -> m () #
serializeBE :: (MonadPut m, GSerialEndian (Rep a), Generic a) => a -> m () #
deserializeBE :: MonadGet m => m a #
deserializeBE :: (MonadGet m, GSerialEndian (Rep a), Generic a) => m a #
serializeLE :: MonadPut m => a -> m () #
serializeLE :: (MonadPut m, GSerialEndian (Rep a), Generic a) => a -> m () #
deserializeLE :: MonadGet m => m a #
deserializeLE :: (MonadGet m, GSerialEndian (Rep a), Generic a) => m a #
serializeHost :: MonadPut m => a -> m () #
deserializeHost :: MonadGet m => m a #
Higher-order
These classes provide us with the ability to serialize containers that need polymorphic recursion.
serializeWith :: MonadPut m => (a -> m ()) -> f a -> m () #
serializeWith :: (MonadPut m, GSerial1 (Rep1 f), Generic1 f) => (a -> m ()) -> f a -> m () #
deserializeWith :: MonadGet m => m a -> m (f a) #
deserializeWith :: (MonadGet m, GSerial1 (Rep1 f), Generic1 f) => m a -> m (f a) #
Serial1 [] # | |
Serial1 Maybe # | |
Serial1 IntMap # | |
Serial1 Seq # | |
Serial a => Serial1 (Either a) # | |
Serial a => Serial1 ((,) a) # | |
(Ord k, Serial k) => Serial1 (Map k) # | |
(Hashable k, Eq k, Serial k) => Serial1 (HashMap k) # | |
(Serial a, Serial b) => Serial1 ((,,) a b) # | |
(Serial a, Serial b, Serial c) => Serial1 ((,,,) a b c) # | |
(Serial a, Serial b, Serial c, Serial d) => Serial1 ((,,,,) a b c d) # | |
serialize1 :: (MonadPut m, Serial1 f, Serial a) => f a -> m () #
deserialize1 :: (MonadGet m, Serial1 f, Serial a) => m (f a) #
serializeWith2 :: MonadPut m => (a -> m ()) -> (b -> m ()) -> f a b -> m () #
deserializeWith2 :: MonadGet m => m a -> m b -> m (f a b) #
Storable
restore :: forall m a. (MonadGet m, Storable a) => m a #
deserialize any Storable
in a host-specific format.
Generics
You probably will never need to care that these exist except they
provide us with default definitions for Serial
and SerialEndian
Used internally to provide generic serialization
gserialize :: MonadPut m => f a -> m () #
gdeserialize :: MonadGet m => m (f a) #
class GSerialEndian f where #
Used internally to provide generic big-endian serialization
gserializeBE :: MonadPut m => f a -> m () #
gserializeBE :: (MonadPut m, GSerial f) => f a -> m () #
gdeserializeBE :: MonadGet m => m (f a) #
gdeserializeBE :: (MonadGet m, GSerial f) => m (f a) #
gserializeLE :: MonadPut m => f a -> m () #
gserializeLE :: (MonadPut m, GSerial f) => f a -> m () #
gdeserializeLE :: MonadGet m => m (f a) #
gdeserializeLE :: (MonadGet m, GSerial f) => m (f a) #
SerialEndian a => GSerialEndian (K1 i a) # | |
Used internally to provide generic serialization
gserializeWith :: MonadPut m => (a -> m ()) -> f a -> m () #
gdeserializeWith :: MonadGet m => m a -> m (f a) #