Safe Haskell	None
Language	Haskell2010

Data.Coders

Description

MemoBytes is an abstration for a datetype that encodes its own seriialization. The idea is to use a newtype around a MemoBytes non-memoizing version. For example: newtype Foo = Foo(MemoBytes NonMemoizingFoo) This way all the instances for Foo (Eq,Show,Ord,ToCBOR,FromCBOR,NoThunks,Generic) can be derived for free.

Synopsis

data Encode (w :: Wrapped) t where
- Sum :: t -> Word -> Encode 'Open t
- Rec :: t -> Encode 'Closed t
- To :: ToCBOR a => a -> Encode 'Closed a
- E :: (t -> Encoding) -> t -> Encode 'Closed t
- ApplyE :: Encode w (a -> t) -> Encode 'Closed a -> Encode w t
data Decode (w :: Wrapped) t where
- Summands :: String -> (Word -> Decode 'Open t) -> Decode 'Closed t
- SumD :: t -> Decode 'Open t
- RecD :: t -> Decode 'Closed t
- From :: FromCBOR t => Decode 'Closed t
- D :: (forall s. Decoder s t) -> Decode 'Closed t
- ApplyD :: Decode w (a -> t) -> Decode 'Closed a -> Decode w t
- Invalid :: Word -> Decode w t
- Map :: (a -> b) -> Decode w a -> Decode w b
(!>) :: Encode w (a -> t) -> Encode 'Closed a -> Encode w t
(<!) :: Decode w (a -> t) -> Decode 'Closed a -> Decode w t
data Wrapped
- = Open
- | Closed
encode :: Encode w t -> Encoding
decode :: Decode w t -> Decoder s t
runE :: Encode w t -> t
decodeClosed :: Decode 'Closed t -> Decoder s t
decodeList :: Decoder s a -> Decoder s [a]
decodeSeq :: Decoder s a -> Decoder s (Seq a)
decodeStrictSeq :: Decoder s a -> Decoder s (StrictSeq a)
decodeSet :: Ord a => Decoder s a -> Decoder s (Set a)
encodeList :: ToCBOR a => [a] -> Encoding
encodeSeq :: ToCBOR a => Seq a -> Encoding
encodeStrictSeq :: ToCBOR a => StrictSeq a -> Encoding
encodeSet :: ToCBOR a => Set a -> Encoding
decodeRecordNamed :: Text -> (a -> Int) -> Decoder s a -> Decoder s a
decodeRecordSum :: String -> (Word -> Decoder s (Int, a)) -> Decoder s a
invalidKey :: Word -> Decoder s a
wrapCBORArray :: Word -> Encoding -> Encoding
encodeFoldable :: (ToCBOR a, Foldable f) => f a -> Encoding
decodeCollectionWithLen :: Decoder s (Maybe Int) -> Decoder s a -> Decoder s (Int, [a])
decodeCollection :: Decoder s (Maybe Int) -> Decoder s a -> Decoder s [a]
encodeFoldableEncoder :: Foldable f => (a -> Encoding) -> f a -> Encoding
roundTrip :: (ToCBOR t, FromCBOR t) => t -> Either DeserialiseFailure (ByteString, t)

Documentation

data Encode (w :: Wrapped) t where Source #

Constructors

Sum :: t -> Word -> Encode 'Open t
Rec :: t -> Encode 'Closed t
To :: ToCBOR a => a -> Encode 'Closed a
E :: (t -> Encoding) -> t -> Encode 'Closed t
ApplyE :: Encode w (a -> t) -> Encode 'Closed a -> Encode w t

data Decode (w :: Wrapped) t where Source #

Constructors

Summands :: String -> (Word -> Decode 'Open t) -> Decode 'Closed t
SumD :: t -> Decode 'Open t
RecD :: t -> Decode 'Closed t
From :: FromCBOR t => Decode 'Closed t
D :: (forall s. Decoder s t) -> Decode 'Closed t
ApplyD :: Decode w (a -> t) -> Decode 'Closed a -> Decode w t
Invalid :: Word -> Decode w t
Map :: (a -> b) -> Decode w a -> Decode w b

Instances

Instances details

Functor (Decode w) Source #
Instance details Defined in Data.Coders Methods fmap :: (a -> b) -> Decode w a -> Decode w b # (<$) :: a -> Decode w b -> Decode w a #

(!>) :: Encode w (a -> t) -> Encode 'Closed a -> Encode w t infixl 4 Source #

(<!) :: Decode w (a -> t) -> Decode 'Closed a -> Decode w t infixl 4 Source #

data Wrapped Source #

Some CBOR instances wrap encoding sequences with prefixes and suffixes. I.e. prefix , encode, encode, encode , ... , suffix A type that MUST do this is called 'Open. Other types are called 'Closed. The point is that a Closed type may have a prefix, but it can still be inlined by using the context it appears in, inside another Closed type. It does so by sharing the prefix of its containing type, and using positional context. In terms of Open and Closed, a datatype with more than one constructor is Open, and one with only one constructor is Closed (we call these records). Primitive types with no constructors can also be inlined, so we mark them as closed.

Constructors