Safe Haskell	None
Language	Haskell2010

Data.Coders

Contents

Utility functions

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
- Rec :: t -> Encode (' Closed ' Dense ) t
- Sum :: t -> Word -> Encode ' Open t
- Keyed :: t -> Encode (' Closed ' Sparse ) t
- To :: ToCBOR a => a -> Encode (' Closed ' Dense ) a
- E :: (t -> Encoding ) -> t -> Encode (' Closed ' Dense ) t
- MapE :: (a -> b) -> Encode w a -> Encode w b
- ED :: Dual t -> t -> Encode (' Closed ' Dense ) t
- OmitC :: t -> Encode w t
- Tag :: Word -> Encode (' Closed x) t -> Encode (' Closed x) t
- Omit :: (t -> Bool ) -> Encode (' Closed ' Sparse ) t -> Encode (' Closed ' Sparse ) t
- Key :: Word -> Encode (' Closed ' Dense ) t -> Encode (' Closed ' Sparse ) t
- ApplyE :: Encode w (a -> t) -> Encode (' Closed r) a -> Encode w t
data Decode (w :: Wrapped ) t where
- Summands :: String -> ( Word -> Decode ' Open t) -> Decode (' Closed ' Dense ) t
- SparseKeyed :: Typeable t => String -> t -> ( Word -> Field t) -> [( Word , String )] -> Decode (' Closed ' Dense ) t
- SumD :: t -> Decode ' Open t
- RecD :: t -> Decode (' Closed ' Dense ) t
- KeyedD :: t -> Decode (' Closed ' Sparse ) t
- From :: FromCBOR t => Decode w t
- D :: ( forall s. Decoder s t) -> Decode (' Closed ' Dense ) t
- ApplyD :: Decode w1 (a -> t) -> Decode (' Closed d) a -> Decode w1 t
- Invalid :: Word -> Decode w t
- Map :: (a -> b) -> Decode w a -> Decode w b
- DD :: Dual t -> Decode (' Closed ' Dense ) t
- TagD :: Word -> Decode (' Closed x) t -> Decode (' Closed x) t
- Emit :: t -> Decode w t
- Ann :: Decode w t -> Decode w ( Annotator t)
- ApplyAnn :: Decode w1 ( Annotator (a -> t)) -> Decode (' Closed d) ( Annotator a) -> Decode w1 ( Annotator t)
- ApplyErr :: Decode w1 (a -> Either String t) -> Decode (' Closed d) a -> Decode w1 t
(!>) :: Encode w (a -> t) -> Encode (' Closed r) a -> Encode w t
(<!) :: Decode w1 (a -> t) -> Decode (' Closed w) a -> Decode w1 t
(<*!) :: Decode w1 ( Annotator (a -> t)) -> Decode (' Closed d) ( Annotator a) -> Decode w1 ( Annotator t)
(<?) :: Decode w1 (a -> Either String t) -> Decode (' Closed d) a -> Decode w1 t
data Density
- = Dense
- | Sparse
data Wrapped where
- Open :: Wrapped
- Closed :: Density -> Wrapped
newtype Annotator a = Annotator {
- runAnnotator :: FullByteString -> a
}
data Dual t = Dual (t -> Encoding ) ( forall s. Decoder s t)
data Field t where
- Field :: (x -> t -> t) -> ( forall s. Decoder s x) -> Field t
ofield :: ( StrictMaybe x -> t -> t) -> Decode (' Closed d) x -> Field t
invalidField :: forall t. Word -> Field t
field :: (x -> t -> t) -> Decode (' Closed d) x -> Field t
fieldA :: Applicative ann => (x -> t -> t) -> Decode (' Closed d) x -> Field (ann t)
fieldAA :: Applicative ann => (x -> t -> t) -> Decode (' Closed d) (ann x) -> Field (ann t)
encode :: Encode w t -> Encoding
decode :: Decode w t -> Decoder s t
runE :: Encode w t -> t
decodeList :: Decoder s a -> Decoder s [a]
decodePair :: Decoder s a -> Decoder s b -> Decoder s (a, b)
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)
decodeAnnSet :: Ord t => Decoder s ( Annotator t) -> Decoder s ( Annotator ( Set t))
decodeRecordNamed :: Text -> (a -> Int ) -> Decoder s a -> Decoder s a
decodeRecordNamedT :: ( MonadTrans m, Monad (m ( Decoder s))) => Text -> (a -> Int ) -> m ( Decoder s) a -> m ( Decoder s) a
decodeRecordSum :: String -> ( Word -> Decoder s ( Int , a)) -> Decoder s a
invalidKey :: Word -> Decoder s a
unusedRequiredKeys :: Set Word -> [( Word , String )] -> String -> Decoder s a
duplicateKey :: String -> Word -> Decoder s a
wrapCBORArray :: Word -> Encoding -> Encoding
encodePair :: (a -> Encoding ) -> (b -> Encoding ) -> (a, b) -> Encoding
encodeFoldable :: ( ToCBOR a, Foldable f) => f a -> Encoding
encodeFoldableAsDefinite :: ( ToCBOR a, Foldable f) => f a -> Encoding
encodeFoldableAsIndefinite :: ( ToCBOR a, Foldable f) => f a -> Encoding
encodeFoldableMapPairs :: ( ToCBOR a, ToCBOR b, Foldable f) => f (a, b) -> 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
encodeMap :: (a -> Encoding ) -> (b -> Encoding ) -> Map a b -> Encoding
encodeVMap :: ( Vector vk k, Vector vv v) => (k -> Encoding ) -> (v -> Encoding ) -> VMap vk vv k v -> Encoding
wrapCBORMap :: Word -> Encoding -> Encoding
decodeMap :: Ord a => Decoder s a -> Decoder s b -> Decoder s ( Map a b)
decodeVMap :: ( Vector kv k, Vector vv v, Ord k) => Decoder s k -> Decoder s v -> Decoder s ( VMap kv vv k v)
decodeMapNoDuplicates :: Ord a => Decoder s a -> Decoder s b -> Decoder s ( Map a b)
decodeMapByKey :: ( IsList t, Item t ~ (k, v)) => Decoder s k -> (k -> Decoder s v) -> Decoder s t
decodeMapContents :: Decoder s a -> Decoder s [a]
decodeMapTraverse :: ( Ord a, Applicative t) => Decoder s (t a) -> Decoder s (t b) -> Decoder s (t ( Map a b))
decodeMapContentsTraverse :: Applicative t => Decoder s (t a) -> Decoder s (t b) -> Decoder s (t [(a, b)])
dualList :: ( ToCBOR a, FromCBOR a) => Dual [a]
dualSeq :: ( ToCBOR a, FromCBOR a) => Dual ( Seq a)
dualSet :: ( Ord a, ToCBOR a, FromCBOR a) => Dual ( Set a)
dualMaybeAsList :: ( ToCBOR a, FromCBOR a) => Dual ( Maybe a)
dualMaybeAsNull :: ( ToCBOR a, FromCBOR a) => Dual ( Maybe a)
dualText :: Dual Text
dualStrictSeq :: ( ToCBOR a, FromCBOR a) => Dual ( StrictSeq a)
dualCBOR :: ( ToCBOR a, FromCBOR a) => Dual a
to :: ( ToCBOR t, FromCBOR t) => t -> Encode (' Closed ' Dense ) t
from :: ( ToCBOR t, FromCBOR t) => Decode (' Closed ' Dense ) t
data Decoder s a
data Encoding
encodeNullMaybe :: (a -> Encoding ) -> Maybe a -> Encoding
encodeKeyedStrictMaybeWith :: Word -> (a -> Encoding ) -> StrictMaybe a -> Encode (' Closed ' Sparse ) ( StrictMaybe a)
encodeKeyedStrictMaybe :: ToCBOR a => Word -> StrictMaybe a -> Encode (' Closed ' Sparse ) ( StrictMaybe a)
decodeNullMaybe :: Decoder s a -> Decoder s ( Maybe a)
decodeSparse :: Typeable a => String -> a -> ( Word -> Field a) -> [( Word , String )] -> Decoder s a
mapEncode :: ( ToCBOR k, ToCBOR v) => Map k v -> Encode (' Closed ' Dense ) ( Map k v)
mapDecode :: ( Ord k, FromCBOR k, FromCBOR v) => Decode (' Closed ' Dense ) ( Map k v)
mapDecodeA :: Ord k => Decode (' Closed ' Dense ) ( Annotator k) -> Decode (' Closed ' Dense ) ( Annotator v) -> Decode (' Closed ' Dense ) ( Annotator ( Map k v))
vMapEncode :: ( Vector kv k, Vector vv v, ToCBOR k, ToCBOR v) => VMap kv vv k v -> Encode (' Closed ' Dense ) ( VMap kv vv k v)
vMapDecode :: ( Vector kv k, Vector vv v, Ord k, FromCBOR k, FromCBOR v) => Decode (' Closed ' Dense ) ( VMap kv vv k v)
setEncode :: ToCBOR v => Set v -> Encode (' Closed ' Dense ) ( Set v)
setDecode :: ( Ord v, FromCBOR v) => Decode (' Closed ' Dense ) ( Set v)
setDecodeA :: Ord x => Decode (' Closed ' Dense ) ( Annotator x) -> Decode (' Closed ' Dense ) ( Annotator ( Set x))
listEncode :: ToCBOR v => [v] -> Encode (' Closed ' Dense ) [v]
listDecode :: FromCBOR v => Decode (' Closed ' Dense ) [v]
listDecodeA :: Decode (' Closed ' Dense ) ( Annotator x) -> Decode (' Closed ' Dense ) ( Annotator [x])
pairDecodeA :: Decode (' Closed ' Dense ) ( Annotator x) -> Decode (' Closed ' Dense ) ( Annotator y) -> Decode (' Closed ' Dense ) ( Annotator (x, y))
cborError :: Buildable e => e -> Decoder s a

Documentation

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

Constructors

Rec :: t -> Encode (' Closed ' Dense ) t
Sum :: t -> Word -> Encode ' Open t
Keyed :: t -> Encode (' Closed ' Sparse ) t
To :: ToCBOR a => a -> Encode (' Closed ' Dense ) a
E :: (t -> Encoding ) -> t -> Encode (' Closed ' Dense ) t
MapE :: (a -> b) -> Encode w a -> Encode w b
ED :: Dual t -> t -> Encode (' Closed ' Dense ) t
OmitC :: t -> Encode w t
Tag :: Word -> Encode (' Closed x) t -> Encode (' Closed x) t
Omit :: (t -> Bool ) -> Encode (' Closed ' Sparse ) t -> Encode (' Closed ' Sparse ) t
Key :: Word -> Encode (' Closed ' Dense ) t -> Encode (' Closed ' Sparse ) t
ApplyE :: Encode w (a -> t) -> Encode (' Closed r) a -> Encode w t

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

Constructors

Summands :: String -> ( Word -> Decode ' Open t) -> Decode (' Closed ' Dense ) t
SparseKeyed :: Typeable t => String -> t -> ( Word -> Field t) -> [( Word , String )] -> Decode (' Closed ' Dense ) t
SumD :: t -> Decode ' Open t
RecD :: t -> Decode (' Closed ' Dense ) t
KeyedD :: t -> Decode (' Closed ' Sparse ) t
From :: FromCBOR t => Decode w t
D :: ( forall s. Decoder s t) -> Decode (' Closed ' Dense ) t
ApplyD :: Decode w1 (a -> t) -> Decode (' Closed d) a -> Decode w1 t
Invalid :: Word -> Decode w t
Map :: (a -> b) -> Decode w a -> Decode w b
DD :: Dual t -> Decode (' Closed ' Dense ) t
TagD :: Word -> Decode (' Closed x) t -> Decode (' Closed x) t
Emit :: t -> Decode w t
Ann :: Decode w t -> Decode w ( Annotator t)
ApplyAnn :: Decode w1 ( Annotator (a -> t)) -> Decode (' Closed d) ( Annotator a) -> Decode w1 ( Annotator t)
ApplyErr :: Decode w1 (a -> Either String t) -> Decode (' Closed d) a -> Decode w1 t

Instances

Instances details

Functor ( Decode w) Source #
Instance details Defined in Data.Coders Methods fmap :: (a -> b) -> Decode w a -> Decode w b Source # (<$) :: a -> Decode w b -> Decode w a Source #
Applicative ( Decode (' Closed d)) Source #
Instance details Defined in Data.Coders Methods pure :: a -> Decode (' Closed d) a Source # (<>) :: Decode (' Closed d) (a -> b) -> Decode (' Closed d) a -> Decode (' Closed d) b Source # liftA2 :: (a -> b -> c) -> Decode (' Closed d) a -> Decode (' Closed d) b -> Decode (' Closed d) c Source # (>) :: Decode (' Closed d) a -> Decode (' Closed d) b -> Decode (' Closed d) b Source # (<*) :: Decode (' Closed d) a -> Decode (' Closed d) b -> Decode (' Closed d) a Source #

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

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

(<*!) :: Decode w1 ( Annotator (a -> t)) -> Decode (' Closed d) ( Annotator a) -> Decode w1 ( Annotator t) infixl 4 Source #

(<?) :: Decode w1 (a -> Either String t) -> Decode (' Closed d) a -> Decode w1 t infixl 4 Source #

data Density Source #

Some CBOR instances wrap encoding sequences with prefixes and suffixes. I.e. prefix , encode, encode, encode , ... , suffix. There are two kinds of wrapping coders: Nary sums, and Sparsely encoded products. Coders in these classes can only be decoded when they are wrapped by their closing forms Summand and SparseKeyed. In another dimension records can be encoded densely (all their fields serialised) or sparsely (only some of their fields). We use indexes to types to try and mark (and enforce) these distinctions.

Record density (all the fields) vs (some of the fields)

Constructors

Dense
Sparse

data Wrapped where Source #

Constructors

Open :: Wrapped
Closed :: Density -> Wrapped

newtype Annotator a Source #

A value of type `Annotator a` is one that needs access to the entire | bytestring used during decoding to finish construction.

Constructors

Annotator
Fields runAnnotator :: FullByteString -> a

Instances

Instances details

Monad Annotator
Instance details Defined in Cardano.Binary.Annotated Methods (>>=) :: Annotator a -> (a -> Annotator b) -> Annotator b Source # (>>) :: Annotator a -> Annotator b -> Annotator b Source # return :: a -> Annotator a Source #
Functor Annotator
Instance details Defined in Cardano.Binary.Annotated Methods fmap :: (a -> b) -> Annotator a -> Annotator b Source # (<$) :: a -> Annotator b -> Annotator a Source #
Applicative Annotator
Instance details Defined in Cardano.Binary.Annotated Methods pure :: a -> Annotator a Source # (<>) :: Annotator (a -> b) -> Annotator a -> Annotator b Source # liftA2 :: (a -> b -> c) -> Annotator a -> Annotator b -> Annotator c Source # (>) :: Annotator a -> Annotator b -> Annotator b Source # (<*) :: Annotator a -> Annotator b -> Annotator a Source #
( Typeable t, FromCBOR ( Annotator t)) => FromCBOR ( Annotator ( MemoBytes t)) Source #
Instance details Defined in Data.MemoBytes Methods fromCBOR :: Decoder s ( Annotator ( MemoBytes t)) Source # label :: Proxy ( Annotator ( MemoBytes t)) -> Text Source #

data Dual t Source #

Analogous to paired ToCBOR and FromCBOR instances with out freezing out alternate ways to code. Unlike ToCBOR and FromCBOR where there is only one instance per type. There can be multiple Duals with the same type.

Constructors

Dual (t -> Encoding ) ( forall s. Decoder s t)

data Field t where Source #

A Field pairs an update function and a decoder for one field of a Sparse record.

Constructors

Field :: (x -> t -> t) -> ( forall s. Decoder s x) -> Field t

ofield :: ( StrictMaybe x -> t -> t) -> Decode (' Closed d) x -> Field t Source #

invalidField :: forall t. Word -> Field t Source #

field :: (x -> t -> t) -> Decode (' Closed d) x -> Field t Source #

fieldA :: Applicative ann => (x -> t -> t) -> Decode (' Closed d) x -> Field (ann t) Source #

fieldAA :: Applicative ann => (x -> t -> t) -> Decode (' Closed d) (ann x) -> Field (ann t) Source #

encode :: Encode w t -> Encoding Source #

decode :: Decode w t -> Decoder s t Source #

runE :: Encode w t -> t Source #

decodeList :: Decoder s a -> Decoder s [a] Source #

decodePair :: Decoder s a -> Decoder s b -> Decoder s (a, b) Source #

decodeSeq :: Decoder s a -> Decoder s ( Seq a) Source #

decodeStrictSeq :: Decoder s a -> Decoder s ( StrictSeq a) Source #

decodeSet :: Ord a => Decoder s a -> Decoder s ( Set a) Source #

decodeAnnSet :: Ord t => Decoder s ( Annotator t) -> Decoder s ( Annotator ( Set t)) Source #

decodeRecordNamed :: Text -> (a -> Int ) -> Decoder s a -> Decoder s a Source #

decodeRecordNamedT :: ( MonadTrans m, Monad (m ( Decoder s))) => Text -> (a -> Int ) -> m ( Decoder s) a -> m ( Decoder s) a Source #

decodeRecordSum :: String -> ( Word -> Decoder s ( Int , a)) -> Decoder s a Source #

invalidKey :: Word -> Decoder s a Source #

unusedRequiredKeys :: Set Word -> [( Word , String )] -> String -> Decoder s a Source #

duplicateKey :: String -> Word -> Decoder s a Source #

wrapCBORArray :: Word -> Encoding -> Encoding Source #

encodePair :: (a -> Encoding ) -> (b -> Encoding ) -> (a, b) -> Encoding Source #

encodeFoldable :: ( ToCBOR a, Foldable f) => f a -> Encoding Source #

encodeFoldableAsDefinite :: ( ToCBOR a, Foldable f) => f a -> Encoding Source #

encodeFoldableAsIndefinite :: ( ToCBOR a, Foldable f) => f a -> Encoding Source #

encodeFoldableMapPairs :: ( ToCBOR a, ToCBOR b, Foldable f) => f (a, b) -> Encoding Source #

decodeCollectionWithLen :: Decoder s ( Maybe Int ) -> Decoder s a -> Decoder s ( Int , [a]) Source #

decodeCollection :: Decoder s ( Maybe Int ) -> Decoder s a -> Decoder s [a] Source #

encodeFoldableEncoder :: Foldable f => (a -> Encoding ) -> f a -> Encoding Source #

encodeMap :: (a -> Encoding ) -> (b -> Encoding ) -> Map a b -> Encoding Source #

encodeVMap :: ( Vector vk k, Vector vv v) => (k -> Encoding ) -> (v -> Encoding ) -> VMap vk vv k v -> Encoding Source #

wrapCBORMap :: Word -> Encoding -> Encoding Source #

decodeMap :: Ord a => Decoder s a -> Decoder s b -> Decoder s ( Map a b) Source #

decodeVMap :: ( Vector kv k, Vector vv v, Ord k) => Decoder s k -> Decoder s v -> Decoder s ( VMap kv vv k v) Source #

decodeMapNoDuplicates :: Ord a => Decoder s a -> Decoder s b -> Decoder s ( Map a b) Source #

Just like decodeMap , but assumes there are no duplicate keys

decodeMapByKey :: ( IsList t, Item t ~ (k, v)) => Decoder s k -> (k -> Decoder s v) -> Decoder s t Source #

decodeMapContents :: Decoder s a -> Decoder s [a] Source #

decodeMapTraverse :: ( Ord a, Applicative t) => Decoder s (t a) -> Decoder s (t b) -> Decoder s (t ( Map a b)) Source #

decodeMapContentsTraverse :: Applicative t => Decoder s (t a) -> Decoder s (t b) -> Decoder s (t [(a, b)]) Source #

dualList :: ( ToCBOR a, FromCBOR a) => Dual [a] Source #

dualSeq :: ( ToCBOR a, FromCBOR a) => Dual ( Seq a) Source #

dualSet :: ( Ord a, ToCBOR a, FromCBOR a) => Dual ( Set a) Source #

dualMaybeAsList :: ( ToCBOR a, FromCBOR a) => Dual ( Maybe a) Source #

Good for encoding (Maybe t) if is another Maybe. Uses more space than dualMaybeAsNull

dualMaybeAsNull :: ( ToCBOR a, FromCBOR a) => Dual ( Maybe a) Source #

Good for encoding (Maybe T) as long as T isn't another Maybe

dualText :: Dual Text Source #

dualStrictSeq :: ( ToCBOR a, FromCBOR a) => Dual ( StrictSeq a) Source #

dualCBOR :: ( ToCBOR a, FromCBOR a) => Dual a Source #

to :: ( ToCBOR t, FromCBOR t) => t -> Encode (' Closed ' Dense ) t Source #

from :: ( ToCBOR t, FromCBOR t) => Decode (' Closed ' Dense ) t Source #

data Decoder s a Source #

A continuation-based decoder, used for decoding values that were previously encoded using the Codec.CBOR.Encoding module. As Decoder has a Monad instance, you can easily write Decoder s monadically for building your deserialisation logic.

Since: cborg-0.2.0.0

Instances

Instances details

Monad ( Decoder s)	Since: cborg-0.2.0.0
Instance details Defined in Codec.CBOR.Decoding Methods (>>=) :: Decoder s a -> (a -> Decoder s b) -> Decoder s b Source # (>>) :: Decoder s a -> Decoder s b -> Decoder s b Source # return :: a -> Decoder s a Source #
Functor ( Decoder s)	Since: cborg-0.2.0.0
Instance details Defined in Codec.CBOR.Decoding Methods fmap :: (a -> b) -> Decoder s a -> Decoder s b Source # (<$) :: a -> Decoder s b -> Decoder s a Source #
MonadFail ( Decoder s)	Since: cborg-0.2.0.0
Instance details Defined in Codec.CBOR.Decoding Methods fail :: String -> Decoder s a Source #
Applicative ( Decoder s)	Since: cborg-0.2.0.0
Instance details Defined in Codec.CBOR.Decoding Methods pure :: a -> Decoder s a Source # (<>) :: Decoder s (a -> b) -> Decoder s a -> Decoder s b Source # liftA2 :: (a -> b -> c) -> Decoder s a -> Decoder s b -> Decoder s c Source # (>) :: Decoder s a -> Decoder s b -> Decoder s b Source # (<*) :: Decoder s a -> Decoder s b -> Decoder s a Source #

data Encoding Source #

An intermediate form used during serialisation, specified as a Monoid . It supports efficient concatenation, and is equivalent to a specialised Endo Tokens type.

It is used for the stage in serialisation where we flatten out the Haskell data structure but it is independent of any specific external binary or text format.

Traditionally, to build any arbitrary Encoding value, you specify larger structures from smaller ones and append the small ones together using mconcat .

Since: cborg-0.2.0.0

Instances

Instances details

Show Encoding
Instance details Defined in Codec.CBOR.Encoding Methods showsPrec :: Int -> Encoding -> ShowS Source # show :: Encoding -> String Source # showList :: [ Encoding ] -> ShowS Source #
Semigroup Encoding	Since: cborg-0.2.0.0
Instance details Defined in Codec.CBOR.Encoding Methods (<>) :: Encoding -> Encoding -> Encoding Source # sconcat :: NonEmpty Encoding -> Encoding Source # stimes :: Integral b => b -> Encoding -> Encoding Source #
Monoid Encoding	Since: cborg-0.2.0.0
Instance details Defined in Codec.CBOR.Encoding Methods mempty :: Encoding Source # mappend :: Encoding -> Encoding -> Encoding Source # mconcat :: [ Encoding ] -> Encoding Source #

encodeNullMaybe :: (a -> Encoding ) -> Maybe a -> Encoding Source #

encodeKeyedStrictMaybeWith :: Word -> (a -> Encoding ) -> StrictMaybe a -> Encode (' Closed ' Sparse ) ( StrictMaybe a) Source #

encodeKeyedStrictMaybe :: ToCBOR a => Word -> StrictMaybe a -> Encode (' Closed ' Sparse ) ( StrictMaybe a) Source #

decodeNullMaybe :: Decoder s a -> Decoder s ( Maybe a) Source #

decodeSparse :: Typeable a => String -> a -> ( Word -> Field a) -> [( Word , String )] -> Decoder s a Source #

mapEncode :: ( ToCBOR k, ToCBOR v) => Map k v -> Encode (' Closed ' Dense ) ( Map k v) Source #

(mapEncode x) is self-documenting, correct way to encode Map. use mapDecode as its dual

mapDecode :: ( Ord k, FromCBOR k, FromCBOR v) => Decode (' Closed ' Dense ) ( Map k v) Source #

(mapDecode) is the Dual for (mapEncode x)

mapDecodeA :: Ord k => Decode (' Closed ' Dense ) ( Annotator k) -> Decode (' Closed ' Dense ) ( Annotator v) -> Decode (' Closed ' Dense ) ( Annotator ( Map k v)) Source #

vMapEncode :: ( Vector kv k, Vector vv v, ToCBOR k, ToCBOR v) => VMap kv vv k v -> Encode (' Closed ' Dense ) ( VMap kv vv k v) Source #

(vMapEncode x) is self-documenting, correct way to encode VMap. use vMapDecode as its dual

vMapDecode :: ( Vector kv k, Vector vv v, Ord k, FromCBOR k, FromCBOR v) => Decode (' Closed ' Dense ) ( VMap kv vv k v) Source #

(vMapDecode) is the Dual for (vMapEncode x)

setEncode :: ToCBOR v => Set v -> Encode (' Closed ' Dense ) ( Set v) Source #

(setEncode x) is self-documenting (E encodeFoldable x), use setDecode as its dual

setDecode :: ( Ord v, FromCBOR v) => Decode (' Closed ' Dense ) ( Set v) Source #

(setDecode) is the Dual for (setEncode x)

setDecodeA :: Ord x => Decode (' Closed ' Dense ) ( Annotator x) -> Decode (' Closed ' Dense ) ( Annotator ( Set x)) Source #

listEncode :: ToCBOR v => [v] -> Encode (' Closed ' Dense ) [v] Source #

(listEncode x) is self-documenting (E encodeFoldable x), use listDecode as its dual

listDecode :: FromCBOR v => Decode (' Closed ' Dense ) [v] Source #

(listDecode) is the Dual for (listEncode x)

listDecodeA :: Decode (' Closed ' Dense ) ( Annotator x) -> Decode (' Closed ' Dense ) ( Annotator [x]) Source #

pairDecodeA :: Decode (' Closed ' Dense ) ( Annotator x) -> Decode (' Closed ' Dense ) ( Annotator y) -> Decode (' Closed ' Dense ) ( Annotator (x, y)) Source #

Utility functions

cborError :: Buildable e => e -> Decoder s a Source #

Convert a Buildable error into a cborg decoder error