Codec.Winery.Class

Documentation

class Typeable a => Serialise a where

Serialisable datatype

Minimal complete definition

schemaGen, toBuilder, extractor, decodeCurrent | bundleSerialise

Methods

schemaGen :: Proxy a -> SchemaGen Schema

Obtain the schema of the datatype.

toBuilder :: a -> Builder

Serialise a value.

extractor :: Extractor a

A value of 'Extractor a' interprets a schema and builds a function from Term to a. This must be equivalent to decodeCurrent when the schema is the current one.

If extractor s returns a function, the function must return a non-bottom for any Term decodeTerm s returns.

It must not return a function if an unsupported schema is supplied.

getDecoderBy extractor (schema (Proxy a)) must be Right d where d@ is equivalent to decodeCurrent.

decodeCurrent :: Decoder a

Decode a value with the current schema.

decodeCurrent evalDecoder toBuilder x ≡ x

bundleSerialise :: BundleSerialise a

Instead of the four methods above, you can supply a bundle.

Instances

Serialise Bool

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy Bool -> SchemaGen Schema

toBuilder :: Bool -> Builder

extractor :: Extractor Bool

decodeCurrent :: Decoder Bool

bundleSerialise :: BundleSerialise Bool

Serialise Char

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy Char -> SchemaGen Schema

toBuilder :: Char -> Builder

extractor :: Extractor Char

decodeCurrent :: Decoder Char

bundleSerialise :: BundleSerialise Char

Serialise Double

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy Double -> SchemaGen Schema

toBuilder :: Double -> Builder

extractor :: Extractor Double

decodeCurrent :: Decoder Double

bundleSerialise :: BundleSerialise Double

Serialise Float

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy Float -> SchemaGen Schema

toBuilder :: Float -> Builder

extractor :: Extractor Float

decodeCurrent :: Decoder Float

bundleSerialise :: BundleSerialise Float

Serialise Int

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy Int -> SchemaGen Schema

toBuilder :: Int -> Builder

extractor :: Extractor Int

decodeCurrent :: Decoder Int

bundleSerialise :: BundleSerialise Int

Serialise Int8

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy Int8 -> SchemaGen Schema

toBuilder :: Int8 -> Builder

extractor :: Extractor Int8

decodeCurrent :: Decoder Int8

bundleSerialise :: BundleSerialise Int8

Serialise Int16

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy Int16 -> SchemaGen Schema

toBuilder :: Int16 -> Builder

extractor :: Extractor Int16

decodeCurrent :: Decoder Int16

bundleSerialise :: BundleSerialise Int16

Serialise Int32

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy Int32 -> SchemaGen Schema

toBuilder :: Int32 -> Builder

extractor :: Extractor Int32

decodeCurrent :: Decoder Int32

bundleSerialise :: BundleSerialise Int32

Serialise Int64

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy Int64 -> SchemaGen Schema

toBuilder :: Int64 -> Builder

extractor :: Extractor Int64

decodeCurrent :: Decoder Int64

bundleSerialise :: BundleSerialise Int64

Serialise Integer

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy Integer -> SchemaGen Schema

toBuilder :: Integer -> Builder

extractor :: Extractor Integer

decodeCurrent :: Decoder Integer

bundleSerialise :: BundleSerialise Integer

Serialise Natural

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy Natural -> SchemaGen Schema

toBuilder :: Natural -> Builder

extractor :: Extractor Natural

decodeCurrent :: Decoder Natural

bundleSerialise :: BundleSerialise Natural

Serialise Ordering

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy Ordering -> SchemaGen Schema

toBuilder :: Ordering -> Builder

extractor :: Extractor Ordering

decodeCurrent :: Decoder Ordering

bundleSerialise :: BundleSerialise Ordering

Serialise Word

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy Word -> SchemaGen Schema

toBuilder :: Word -> Builder

extractor :: Extractor Word

decodeCurrent :: Decoder Word

bundleSerialise :: BundleSerialise Word

Serialise Word8

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy Word8 -> SchemaGen Schema

toBuilder :: Word8 -> Builder

extractor :: Extractor Word8

decodeCurrent :: Decoder Word8

bundleSerialise :: BundleSerialise Word8

Serialise Word16

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy Word16 -> SchemaGen Schema

toBuilder :: Word16 -> Builder

extractor :: Extractor Word16

decodeCurrent :: Decoder Word16

bundleSerialise :: BundleSerialise Word16

Serialise Word32

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy Word32 -> SchemaGen Schema

toBuilder :: Word32 -> Builder

extractor :: Extractor Word32

decodeCurrent :: Decoder Word32

bundleSerialise :: BundleSerialise Word32

Serialise Word64

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy Word64 -> SchemaGen Schema

toBuilder :: Word64 -> Builder

extractor :: Extractor Word64

decodeCurrent :: Decoder Word64

bundleSerialise :: BundleSerialise Word64

Serialise ()

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy () -> SchemaGen Schema

toBuilder :: () -> Builder

extractor :: Extractor ()

decodeCurrent :: Decoder ()

bundleSerialise :: BundleSerialise ()

Serialise ByteString

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy ByteString -> SchemaGen Schema

toBuilder :: ByteString -> Builder

extractor :: Extractor ByteString

decodeCurrent :: Decoder ByteString

bundleSerialise :: BundleSerialise ByteString

Serialise ByteString

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy ByteString -> SchemaGen Schema

toBuilder :: ByteString -> Builder

extractor :: Extractor ByteString

decodeCurrent :: Decoder ByteString

bundleSerialise :: BundleSerialise ByteString

Serialise Scientific

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy Scientific -> SchemaGen Schema

toBuilder :: Scientific -> Builder

extractor :: Extractor Scientific

decodeCurrent :: Decoder Scientific

bundleSerialise :: BundleSerialise Scientific

Serialise Text

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy Text -> SchemaGen Schema

toBuilder :: Text -> Builder

extractor :: Extractor Text

decodeCurrent :: Decoder Text

bundleSerialise :: BundleSerialise Text

Serialise UTCTime

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy UTCTime -> SchemaGen Schema

toBuilder :: UTCTime -> Builder

extractor :: Extractor UTCTime

decodeCurrent :: Decoder UTCTime

bundleSerialise :: BundleSerialise UTCTime

Serialise Void

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy Void -> SchemaGen Schema

toBuilder :: Void -> Builder

extractor :: Extractor Void

decodeCurrent :: Decoder Void

bundleSerialise :: BundleSerialise Void

Serialise All

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy All -> SchemaGen Schema

toBuilder :: All -> Builder

extractor :: Extractor All

decodeCurrent :: Decoder All

bundleSerialise :: BundleSerialise All

Serialise Any

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy Any -> SchemaGen Schema

toBuilder :: Any -> Builder

extractor :: Extractor Any

decodeCurrent :: Decoder Any

bundleSerialise :: BundleSerialise Any

Serialise IntSet

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy IntSet -> SchemaGen Schema

toBuilder :: IntSet -> Builder

extractor :: Extractor IntSet

decodeCurrent :: Decoder IntSet

bundleSerialise :: BundleSerialise IntSet

Serialise NominalDiffTime

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy NominalDiffTime -> SchemaGen Schema

toBuilder :: NominalDiffTime -> Builder

extractor :: Extractor NominalDiffTime

decodeCurrent :: Decoder NominalDiffTime

bundleSerialise :: BundleSerialise NominalDiffTime

Serialise Schema

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy Schema -> SchemaGen Schema

toBuilder :: Schema -> Builder

extractor :: Extractor Schema

decodeCurrent :: Decoder Schema

bundleSerialise :: BundleSerialise Schema

Serialise Tag

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy Tag -> SchemaGen Schema

toBuilder :: Tag -> Builder

extractor :: Extractor Tag

decodeCurrent :: Decoder Tag

bundleSerialise :: BundleSerialise Tag

Serialise a => Serialise [a]

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy [a] -> SchemaGen Schema

toBuilder :: [a] -> Builder

extractor :: Extractor [a]

decodeCurrent :: Decoder [a]

bundleSerialise :: BundleSerialise [a]

Serialise a => Serialise (Maybe a)

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy (Maybe a) -> SchemaGen Schema

toBuilder :: Maybe a -> Builder

extractor :: Extractor (Maybe a)

decodeCurrent :: Decoder (Maybe a)

bundleSerialise :: BundleSerialise (Maybe a)

(Integral a, Serialise a) => Serialise (Ratio a)

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy (Ratio a) -> SchemaGen Schema

toBuilder :: Ratio a -> Builder

extractor :: Extractor (Ratio a)

decodeCurrent :: Decoder (Ratio a)

bundleSerialise :: BundleSerialise (Ratio a)

Serialise a => Serialise (Complex a)

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy (Complex a) -> SchemaGen Schema

toBuilder :: Complex a -> Builder

extractor :: Extractor (Complex a)

decodeCurrent :: Decoder (Complex a)

bundleSerialise :: BundleSerialise (Complex a)

Serialise a => Serialise (Min a)

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy (Min a) -> SchemaGen Schema

toBuilder :: Min a -> Builder

extractor :: Extractor (Min a)

decodeCurrent :: Decoder (Min a)

bundleSerialise :: BundleSerialise (Min a)

Serialise a => Serialise (Max a)

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy (Max a) -> SchemaGen Schema

toBuilder :: Max a -> Builder

extractor :: Extractor (Max a)

decodeCurrent :: Decoder (Max a)

bundleSerialise :: BundleSerialise (Max a)

Serialise a => Serialise (First a)

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy (First a) -> SchemaGen Schema

toBuilder :: First a -> Builder

extractor :: Extractor (First a)

decodeCurrent :: Decoder (First a)

bundleSerialise :: BundleSerialise (First a)

Serialise a => Serialise (Last a)

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy (Last a) -> SchemaGen Schema

toBuilder :: Last a -> Builder

extractor :: Extractor (Last a)

decodeCurrent :: Decoder (Last a)

bundleSerialise :: BundleSerialise (Last a)

Serialise a => Serialise (Option a)

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy (Option a) -> SchemaGen Schema

toBuilder :: Option a -> Builder

extractor :: Extractor (Option a)

decodeCurrent :: Decoder (Option a)

bundleSerialise :: BundleSerialise (Option a)

Serialise a => Serialise (ZipList a)

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy (ZipList a) -> SchemaGen Schema

toBuilder :: ZipList a -> Builder

extractor :: Extractor (ZipList a)

decodeCurrent :: Decoder (ZipList a)

bundleSerialise :: BundleSerialise (ZipList a)

Serialise a => Serialise (Identity a)

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy (Identity a) -> SchemaGen Schema

toBuilder :: Identity a -> Builder

extractor :: Extractor (Identity a)

decodeCurrent :: Decoder (Identity a)

bundleSerialise :: BundleSerialise (Identity a)

Serialise a => Serialise (First a)

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy (First a) -> SchemaGen Schema

toBuilder :: First a -> Builder

extractor :: Extractor (First a)

decodeCurrent :: Decoder (First a)

bundleSerialise :: BundleSerialise (First a)

Serialise a => Serialise (Last a)

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy (Last a) -> SchemaGen Schema

toBuilder :: Last a -> Builder

extractor :: Extractor (Last a)

decodeCurrent :: Decoder (Last a)

bundleSerialise :: BundleSerialise (Last a)

Serialise a => Serialise (Dual a)

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy (Dual a) -> SchemaGen Schema

toBuilder :: Dual a -> Builder

extractor :: Extractor (Dual a)

decodeCurrent :: Decoder (Dual a)

bundleSerialise :: BundleSerialise (Dual a)

Serialise a => Serialise (Sum a)

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy (Sum a) -> SchemaGen Schema

toBuilder :: Sum a -> Builder

extractor :: Extractor (Sum a)

decodeCurrent :: Decoder (Sum a)

bundleSerialise :: BundleSerialise (Sum a)

Serialise a => Serialise (Product a)

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy (Product a) -> SchemaGen Schema

toBuilder :: Product a -> Builder

extractor :: Extractor (Product a)

decodeCurrent :: Decoder (Product a)

bundleSerialise :: BundleSerialise (Product a)

Serialise a => Serialise (Down a)

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy (Down a) -> SchemaGen Schema

toBuilder :: Down a -> Builder

extractor :: Extractor (Down a)

decodeCurrent :: Decoder (Down a)

bundleSerialise :: BundleSerialise (Down a)

Serialise v => Serialise (IntMap v)

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy (IntMap v) -> SchemaGen Schema

toBuilder :: IntMap v -> Builder

extractor :: Extractor (IntMap v)

decodeCurrent :: Decoder (IntMap v)

bundleSerialise :: BundleSerialise (IntMap v)

Serialise a => Serialise (Seq a)

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy (Seq a) -> SchemaGen Schema

toBuilder :: Seq a -> Builder

extractor :: Extractor (Seq a)

decodeCurrent :: Decoder (Seq a)

bundleSerialise :: BundleSerialise (Seq a)

(Ord a, Serialise a) => Serialise (Set a)

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy (Set a) -> SchemaGen Schema

toBuilder :: Set a -> Builder

extractor :: Extractor (Set a)

decodeCurrent :: Decoder (Set a)

bundleSerialise :: BundleSerialise (Set a)

(Unbox a, Serialise a) => Serialise (Vector a)

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy (Vector a) -> SchemaGen Schema

toBuilder :: Vector a -> Builder

extractor :: Extractor (Vector a)

decodeCurrent :: Decoder (Vector a)

bundleSerialise :: BundleSerialise (Vector a)

(Storable a, Serialise a) => Serialise (Vector a)

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy (Vector a) -> SchemaGen Schema

toBuilder :: Vector a -> Builder

extractor :: Extractor (Vector a)

decodeCurrent :: Decoder (Vector a)

bundleSerialise :: BundleSerialise (Vector a)

Serialise a => Serialise (Vector a)

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy (Vector a) -> SchemaGen Schema

toBuilder :: Vector a -> Builder

extractor :: Extractor (Vector a)

decodeCurrent :: Decoder (Vector a)

bundleSerialise :: BundleSerialise (Vector a)

(Typeable a, Bits a, Integral a) => Serialise (VarInt a)

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy (VarInt a) -> SchemaGen Schema

toBuilder :: VarInt a -> Builder

extractor :: Extractor (VarInt a)

decodeCurrent :: Decoder (VarInt a)

bundleSerialise :: BundleSerialise (VarInt a)

(GConstructorCount (Rep a), GSerialiseVariant (Rep a), GEncodeVariant (Rep a), GDecodeVariant (Rep a), Generic a, Typeable a) => Serialise (WineryVariant a)

Defined in Codec.Winery

Methods

schemaGen :: Proxy (WineryVariant a) -> SchemaGen Schema

toBuilder :: WineryVariant a -> Builder

extractor :: Extractor (WineryVariant a)

decodeCurrent :: Decoder (WineryVariant a)

bundleSerialise :: BundleSerialise (WineryVariant a)

(GEncodeProduct (Rep a), GSerialiseProduct (Rep a), GDecodeProduct (Rep a), Generic a, Typeable a) => Serialise (WineryProduct a)

Defined in Codec.Winery

Methods

schemaGen :: Proxy (WineryProduct a) -> SchemaGen Schema

toBuilder :: WineryProduct a -> Builder

extractor :: Extractor (WineryProduct a)

decodeCurrent :: Decoder (WineryProduct a)

bundleSerialise :: BundleSerialise (WineryProduct a)

(GEncodeProduct (Rep a), GSerialiseRecord (Rep a), GDecodeProduct (Rep a), Generic a, Typeable a) => Serialise (WineryRecord a)

Defined in Codec.Winery

Methods

schemaGen :: Proxy (WineryRecord a) -> SchemaGen Schema

toBuilder :: WineryRecord a -> Builder

extractor :: Extractor (WineryRecord a)

decodeCurrent :: Decoder (WineryRecord a)

bundleSerialise :: BundleSerialise (WineryRecord a)

(Serialise a, Serialise b) => Serialise (Either a b)

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy (Either a b) -> SchemaGen Schema

toBuilder :: Either a b -> Builder

extractor :: Extractor (Either a b)

decodeCurrent :: Decoder (Either a b)

bundleSerialise :: BundleSerialise (Either a b)

(Serialise a, Serialise b) => Serialise (a, b)

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy (a, b) -> SchemaGen Schema

toBuilder :: (a, b) -> Builder

extractor :: Extractor (a, b)

decodeCurrent :: Decoder (a, b)

bundleSerialise :: BundleSerialise (a, b)

(Eq k, Hashable k, Serialise k, Serialise v) => Serialise (HashMap k v)

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy (HashMap k v) -> SchemaGen Schema

toBuilder :: HashMap k v -> Builder

extractor :: Extractor (HashMap k v)

decodeCurrent :: Decoder (HashMap k v)

bundleSerialise :: BundleSerialise (HashMap k v)

(Ord k, Serialise k, Serialise v) => Serialise (Map k v)

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy (Map k v) -> SchemaGen Schema

toBuilder :: Map k v -> Builder

extractor :: Extractor (Map k v)

decodeCurrent :: Decoder (Map k v)

bundleSerialise :: BundleSerialise (Map k v)

(Serialise a, Serialise b) => Serialise (Arg a b)

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy (Arg a b) -> SchemaGen Schema

toBuilder :: Arg a b -> Builder

extractor :: Extractor (Arg a b)

decodeCurrent :: Decoder (Arg a b)

bundleSerialise :: BundleSerialise (Arg a b)

(Serialise a, Serialise b, Serialise c) => Serialise (a, b, c)

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy (a, b, c) -> SchemaGen Schema

toBuilder :: (a, b, c) -> Builder

extractor :: Extractor (a, b, c)

decodeCurrent :: Decoder (a, b, c)

bundleSerialise :: BundleSerialise (a, b, c)

(Serialise a, Typeable b, Typeable k) => Serialise (Const a b)

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy (Const a b) -> SchemaGen Schema

toBuilder :: Const a b -> Builder

extractor :: Extractor (Const a b)

decodeCurrent :: Decoder (Const a b)

bundleSerialise :: BundleSerialise (Const a b)

(Typeable k, Typeable f, Typeable a, Serialise (f a)) => Serialise (Ap f a)

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy (Ap f a) -> SchemaGen Schema

toBuilder :: Ap f a -> Builder

extractor :: Extractor (Ap f a)

decodeCurrent :: Decoder (Ap f a)

bundleSerialise :: BundleSerialise (Ap f a)

(Typeable k, Typeable f, Typeable a, Serialise (f a)) => Serialise (Alt f a)

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy (Alt f a) -> SchemaGen Schema

toBuilder :: Alt f a -> Builder

extractor :: Extractor (Alt f a)

decodeCurrent :: Decoder (Alt f a)

bundleSerialise :: BundleSerialise (Alt f a)

(Typeable k, Typeable a, Typeable b, a ~ b) => Serialise (a :~: b)

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy (a :~: b) -> SchemaGen Schema

toBuilder :: (a :~: b) -> Builder

extractor :: Extractor (a :~: b)

decodeCurrent :: Decoder (a :~: b)

bundleSerialise :: BundleSerialise (a :~: b)

(Serialise a, Serialise b, Serialise c, Serialise d) => Serialise (a, b, c, d)

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy (a, b, c, d) -> SchemaGen Schema

toBuilder :: (a, b, c, d) -> Builder

extractor :: Extractor (a, b, c, d)

decodeCurrent :: Decoder (a, b, c, d)

bundleSerialise :: BundleSerialise (a, b, c, d)

(Serialise a, Serialise b, Serialise c, Serialise d, Serialise e) => Serialise (a, b, c, d, e)

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy (a, b, c, d, e) -> SchemaGen Schema

toBuilder :: (a, b, c, d, e) -> Builder

extractor :: Extractor (a, b, c, d, e)

decodeCurrent :: Decoder (a, b, c, d, e)

bundleSerialise :: BundleSerialise (a, b, c, d, e)

(Typeable j, Typeable k, Typeable f, Typeable g, Typeable a, Serialise (f (g a))) => Serialise (Compose f g a)

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy (Compose f g a) -> SchemaGen Schema

toBuilder :: Compose f g a -> Builder

extractor :: Extractor (Compose f g a)

decodeCurrent :: Decoder (Compose f g a)

bundleSerialise :: BundleSerialise (Compose f g a)

(Serialise a, Serialise b, Serialise c, Serialise d, Serialise e, Serialise f) => Serialise (a, b, c, d, e, f)

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy (a, b, c, d, e, f) -> SchemaGen Schema

toBuilder :: (a, b, c, d, e, f) -> Builder

extractor :: Extractor (a, b, c, d, e, f)

decodeCurrent :: Decoder (a, b, c, d, e, f)

bundleSerialise :: BundleSerialise (a, b, c, d, e, f)

newtype VarInt a

Encoded in variable-length quantity.

Constructors

VarInt

Fields

• getVarInt :: a

Instances

Bounded a => Bounded (VarInt a)

Defined in Codec.Winery.Class

Methods

minBound :: VarInt a

maxBound :: VarInt a

Enum a => Enum (VarInt a)

Defined in Codec.Winery.Class

Methods

succ :: VarInt a -> VarInt a

pred :: VarInt a -> VarInt a

toEnum :: Int -> VarInt a

fromEnum :: VarInt a -> Int

enumFrom :: VarInt a -> [VarInt a]

enumFromThen :: VarInt a -> VarInt a -> [VarInt a]

enumFromTo :: VarInt a -> VarInt a -> [VarInt a]

enumFromThenTo :: VarInt a -> VarInt a -> VarInt a -> [VarInt a]

Eq a => Eq (VarInt a)

Defined in Codec.Winery.Class

Methods

(==) :: VarInt a -> VarInt a -> Bool

(/=) :: VarInt a -> VarInt a -> Bool

Integral a => Integral (VarInt a)

Defined in Codec.Winery.Class

Methods

quot :: VarInt a -> VarInt a -> VarInt a

rem :: VarInt a -> VarInt a -> VarInt a

div :: VarInt a -> VarInt a -> VarInt a

mod :: VarInt a -> VarInt a -> VarInt a

quotRem :: VarInt a -> VarInt a -> (VarInt a, VarInt a)

divMod :: VarInt a -> VarInt a -> (VarInt a, VarInt a)

toInteger :: VarInt a -> Integer

Num a => Num (VarInt a)

Defined in Codec.Winery.Class

Methods

(+) :: VarInt a -> VarInt a -> VarInt a

(-) :: VarInt a -> VarInt a -> VarInt a

(*) :: VarInt a -> VarInt a -> VarInt a

negate :: VarInt a -> VarInt a

abs :: VarInt a -> VarInt a

signum :: VarInt a -> VarInt a

fromInteger :: Integer -> VarInt a

Ord a => Ord (VarInt a)

Defined in Codec.Winery.Class

Methods

compare :: VarInt a -> VarInt a -> Ordering

(<) :: VarInt a -> VarInt a -> Bool

(<=) :: VarInt a -> VarInt a -> Bool

(>) :: VarInt a -> VarInt a -> Bool

(>=) :: VarInt a -> VarInt a -> Bool

max :: VarInt a -> VarInt a -> VarInt a

min :: VarInt a -> VarInt a -> VarInt a

Read a => Read (VarInt a)

Defined in Codec.Winery.Class

Methods

readsPrec :: Int -> ReadS (VarInt a)

readList :: ReadS [VarInt a]

readPrec :: ReadPrec (VarInt a)

readListPrec :: ReadPrec [VarInt a]

Real a => Real (VarInt a)

Defined in Codec.Winery.Class

Methods

toRational :: VarInt a -> Rational

Show a => Show (VarInt a)

Defined in Codec.Winery.Class

Methods

showsPrec :: Int -> VarInt a -> ShowS

show :: VarInt a -> String

showList :: [VarInt a] -> ShowS

Bits a => Bits (VarInt a)

Defined in Codec.Winery.Class

Methods

(.&.) :: VarInt a -> VarInt a -> VarInt a

(.|.) :: VarInt a -> VarInt a -> VarInt a

xor :: VarInt a -> VarInt a -> VarInt a

complement :: VarInt a -> VarInt a

shift :: VarInt a -> Int -> VarInt a

rotate :: VarInt a -> Int -> VarInt a

zeroBits :: VarInt a

bit :: Int -> VarInt a

setBit :: VarInt a -> Int -> VarInt a

clearBit :: VarInt a -> Int -> VarInt a

complementBit :: VarInt a -> Int -> VarInt a

testBit :: VarInt a -> Int -> Bool

bitSizeMaybe :: VarInt a -> Maybe Int

bitSize :: VarInt a -> Int

isSigned :: VarInt a -> Bool

shiftL :: VarInt a -> Int -> VarInt a

unsafeShiftL :: VarInt a -> Int -> VarInt a

shiftR :: VarInt a -> Int -> VarInt a

unsafeShiftR :: VarInt a -> Int -> VarInt a

rotateL :: VarInt a -> Int -> VarInt a

rotateR :: VarInt a -> Int -> VarInt a

popCount :: VarInt a -> Int

(Typeable a, Bits a, Integral a) => Serialise (VarInt a)

Defined in Codec.Winery.Class

Methods

schemaGen :: Proxy (VarInt a) -> SchemaGen Schema

toBuilder :: VarInt a -> Builder

extractor :: Extractor (VarInt a)

decodeCurrent :: Decoder (VarInt a)

bundleSerialise :: BundleSerialise (VarInt a)

data BundleSerialise a

A bundle of Serialise methods

Constructors

BundleSerialise

Fields

• bundleSchemaGen :: Proxy a -> SchemaGen Schema
• bundleToBuilder :: a -> Builder
• bundleExtractor :: Extractor a
• bundleDecodeCurrent :: Decoder a

bundleRecord :: (GEncodeProduct (Rep a), GSerialiseRecord (Rep a), GDecodeProduct (Rep a), Generic a, Typeable a) => (Extractor a -> Extractor a) -> BundleSerialise a

A bundle of generic implementations for records

bundleRecordDefault :: (GEncodeProduct (Rep a), GSerialiseRecord (Rep a), GDecodeProduct (Rep a), Generic a, Typeable a) => a -> (Extractor a -> Extractor a) -> BundleSerialise a

A bundle of generic implementations for records, with a default value

bundleVariant :: (GSerialiseVariant (Rep a), GConstructorCount (Rep a), GEncodeVariant (Rep a), GDecodeVariant (Rep a), Generic a, Typeable a) => (Extractor a -> Extractor a) -> BundleSerialise a

A bundle of generic implementations for variants

getSchema :: forall proxy a. Serialise a => proxy a -> SchemaGen Schema

Obtain a schema on SchemaGen, binding a fixpoint when necessary. If you are hand-rolling a definition of schemaGen, you should call this instead of schemaGen.

schema :: forall proxy a. Serialise a => proxy a -> Schema

Obtain the schema of the datatype.

"Tell me what you drink, and I will tell you what you are."

unexpectedSchema :: forall f a. Serialise a => Doc AnsiStyle -> Schema -> Strategy' (f a)

mkPlan :: forall a. Typeable a => (Schema -> Strategy' (Term -> a)) -> Plan (Term -> a)

Construct a plan, expanding fixpoints and let bindings.

extractListBy :: Typeable a => Extractor a -> Extractor (Vector a)

Extract a list or an array of values.

gschemaGenRecord :: forall proxy a. (GSerialiseRecord (Rep a), Generic a, Typeable a) => proxy a -> SchemaGen Schema

Generic implementation of schemaGen for a record.

gtoBuilderRecord :: (GEncodeProduct (Rep a), Generic a) => a -> Builder

Generic implementation of toBuilder for a record.

gextractorRecord

Arguments

:: (GSerialiseRecord (Rep a), Generic a, Typeable a)

=> Maybe a

default value (optional)

-> Extractor a

Generic implementation of extractor for a record.

extractorRecord'

Arguments

:: GSerialiseRecord f

=> Doc AnsiStyle

-> Maybe (f x)

default value (optional)

-> Schema

-> Strategy' (Term -> f x)

Generic implementation of extractor for a record.

gdecodeCurrentRecord :: (GDecodeProduct (Rep a), Generic a) => Decoder a

Synonym for gdecodeCurrentProduct

class GEncodeProduct f where

Encode all the fields

Methods

productEncoder :: f x -> Builder

Instances

GEncodeProduct (U1 :: k -> Type)

Defined in Codec.Winery.Class

Methods

productEncoder :: U1 x -> Builder

GEncodeProduct f => GEncodeProduct (D1 c f :: k -> Type)

Defined in Codec.Winery.Class

Methods

productEncoder :: D1 c f x -> Builder

GEncodeProduct f => GEncodeProduct (C1 c f :: k -> Type)

Defined in Codec.Winery.Class

Methods

productEncoder :: C1 c f x -> Builder

Serialise a => GEncodeProduct (S1 c (K1 i a :: k -> Type) :: k -> Type)

Defined in Codec.Winery.Class

Methods

productEncoder :: S1 c (K1 i a) x -> Builder

(GEncodeProduct f, GEncodeProduct g) => GEncodeProduct (f :*: g :: k -> Type)

Defined in Codec.Winery.Class

Methods

productEncoder :: (f :*: g) x -> Builder

class GDecodeProduct f where

Methods

productDecoder :: Decoder (f x)

Instances

GDecodeProduct (U1 :: k -> Type)

Defined in Codec.Winery.Class

Methods

productDecoder :: Decoder (U1 x)

(GDecodeProduct f, GDecodeProduct g) => GDecodeProduct (f :*: g :: k -> Type)

Defined in Codec.Winery.Class

Methods

productDecoder :: Decoder ((f :*: g) x)

Serialise a => GDecodeProduct (K1 i a :: k -> Type)

Defined in Codec.Winery.Class

Methods

productDecoder :: Decoder (K1 i a x)

GDecodeProduct f => GDecodeProduct (M1 i c f :: k -> Type)

Defined in Codec.Winery.Class

Methods

productDecoder :: Decoder (M1 i c f x)

class GSerialiseRecord f where

Methods

recordSchema :: proxy f -> SchemaGen [(Text, Schema)]

recordExtractor :: Maybe (f x) -> TransFusion (FieldDecoder Text) ((->) Term) (Term -> f x)

Instances

GSerialiseRecord f => GSerialiseRecord (D1 c f :: k -> Type)

Defined in Codec.Winery.Class

Methods

recordSchema :: proxy (D1 c f) -> SchemaGen [(Text, Schema)]

recordExtractor :: Maybe (D1 c f x) -> TransFusion (FieldDecoder Text) ((->) Term) (Term -> D1 c f x)

GSerialiseRecord f => GSerialiseRecord (C1 c f :: k -> Type)

Defined in Codec.Winery.Class

Methods

recordSchema :: proxy (C1 c f) -> SchemaGen [(Text, Schema)]

recordExtractor :: Maybe (C1 c f x) -> TransFusion (FieldDecoder Text) ((->) Term) (Term -> C1 c f x)

(Serialise a, Selector c) => GSerialiseRecord (S1 c (K1 i a :: k -> Type) :: k -> Type)

Defined in Codec.Winery.Class

Methods

recordSchema :: proxy (S1 c (K1 i a)) -> SchemaGen [(Text, Schema)]

recordExtractor :: Maybe (S1 c (K1 i a) x) -> TransFusion (FieldDecoder Text) ((->) Term) (Term -> S1 c (K1 i a) x)

(GSerialiseRecord f, GSerialiseRecord g) => GSerialiseRecord (f :*: g :: k -> Type)

Defined in Codec.Winery.Class

Methods

recordSchema :: proxy (f :*: g) -> SchemaGen [(Text, Schema)]

recordExtractor :: Maybe ((f :*: g) x) -> TransFusion (FieldDecoder Text) ((->) Term) (Term -> (f :*: g) x)

class GSerialiseProduct f where

Methods

productSchema :: proxy f -> SchemaGen [Schema]

productExtractor :: Compose (State Int) (TransFusion (FieldDecoder Int) ((->) Term)) (Term -> f x)

Instances

GSerialiseProduct (U1 :: k -> Type)

Defined in Codec.Winery.Class

Methods

productSchema :: proxy U1 -> SchemaGen [Schema]

productExtractor :: Compose (State Int) (TransFusion (FieldDecoder Int) ((->) Term)) (Term -> U1 x)

(GSerialiseProduct f, GSerialiseProduct g) => GSerialiseProduct (f :*: g :: k -> Type)

Defined in Codec.Winery.Class

Methods

productSchema :: proxy (f :*: g) -> SchemaGen [Schema]

productExtractor :: Compose (State Int) (TransFusion (FieldDecoder Int) ((->) Term)) (Term -> (f :*: g) x)

Serialise a => GSerialiseProduct (K1 i a :: k -> Type)

Defined in Codec.Winery.Class

Methods

productSchema :: proxy (K1 i a) -> SchemaGen [Schema]

productExtractor :: Compose (State Int) (TransFusion (FieldDecoder Int) ((->) Term)) (Term -> K1 i a x)

GSerialiseProduct f => GSerialiseProduct (M1 i c f :: k -> Type)

Defined in Codec.Winery.Class

Methods

productSchema :: proxy (M1 i c f) -> SchemaGen [Schema]

productExtractor :: Compose (State Int) (TransFusion (FieldDecoder Int) ((->) Term)) (Term -> M1 i c f x)

gschemaGenProduct :: forall proxy a. (Generic a, GSerialiseProduct (Rep a)) => proxy a -> SchemaGen Schema

gtoBuilderProduct :: (Generic a, GEncodeProduct (Rep a)) => a -> Builder

gextractorProduct :: forall a. (GSerialiseProduct (Rep a), Generic a, Typeable a) => Extractor a

Generic implementation of extractor for a record.

gdecodeCurrentProduct :: forall a. (GDecodeProduct (Rep a), Generic a) => Decoder a

Generic implementation of extractor for a record.

extractorProduct' :: GSerialiseProduct f => Schema -> Strategy' (Term -> f x)

class GConstructorCount f where

Methods

variantCount :: proxy f -> Int

Instances

GConstructorCount f => GConstructorCount (D1 i f :: k -> Type)

Defined in Codec.Winery.Class

Methods

variantCount :: proxy (D1 i f) -> Int

GConstructorCount (C1 i f :: k -> Type)

Defined in Codec.Winery.Class

Methods

variantCount :: proxy (C1 i f) -> Int

(GConstructorCount f, GConstructorCount g) => GConstructorCount (f :+: g :: k -> Type)

Defined in Codec.Winery.Class

Methods

variantCount :: proxy (f :+: g) -> Int

class GDecodeVariant f where

Methods

variantDecoder :: Int -> Int -> Decoder (f x)

Instances

GDecodeVariant f => GDecodeVariant (D1 i f :: k -> Type)

Defined in Codec.Winery.Class

Methods

variantDecoder :: Int -> Int -> Decoder (D1 i f x)

GDecodeProduct f => GDecodeVariant (C1 i f :: k -> Type)

Defined in Codec.Winery.Class

Methods

variantDecoder :: Int -> Int -> Decoder (C1 i f x)

(GDecodeVariant f, GDecodeVariant g) => GDecodeVariant (f :+: g :: k -> Type)

Defined in Codec.Winery.Class

Methods

variantDecoder :: Int -> Int -> Decoder ((f :+: g) x)

class GEncodeVariant f where

Methods

variantEncoder :: Int -> Int -> f x -> Builder

Instances

GEncodeVariant f => GEncodeVariant (D1 i f :: k -> Type)

Defined in Codec.Winery.Class

Methods

variantEncoder :: Int -> Int -> D1 i f x -> Builder

GEncodeProduct f => GEncodeVariant (C1 i f :: k -> Type)

Defined in Codec.Winery.Class

Methods

variantEncoder :: Int -> Int -> C1 i f x -> Builder

(GEncodeVariant f, GEncodeVariant g) => GEncodeVariant (f :+: g :: k -> Type)

Defined in Codec.Winery.Class

Methods

variantEncoder :: Int -> Int -> (f :+: g) x -> Builder

class GSerialiseVariant f where

Methods

variantSchema :: proxy f -> SchemaGen [(Text, Schema)]

variantExtractor :: [(Text, Schema -> Strategy' (Term -> f x))]

Instances

GSerialiseVariant f => GSerialiseVariant (D1 c f :: k -> Type)

Defined in Codec.Winery.Class

Methods

variantSchema :: proxy (D1 c f) -> SchemaGen [(Text, Schema)]

variantExtractor :: [(Text, Schema -> Strategy' (Term -> D1 c f x))]

(GSerialiseRecord f, KnownSymbol name) => GSerialiseVariant (C1 (MetaCons name fixity True) f :: k -> Type)

Defined in Codec.Winery.Class

Methods

variantSchema :: proxy (C1 (MetaCons name fixity True) f) -> SchemaGen [(Text, Schema)]

variantExtractor :: [(Text, Schema -> Strategy' (Term -> C1 (MetaCons name fixity True) f x))]

(GSerialiseProduct f, KnownSymbol name) => GSerialiseVariant (C1 (MetaCons name fixity False) f :: k -> Type)

Defined in Codec.Winery.Class

Methods

variantSchema :: proxy (C1 (MetaCons name fixity False) f) -> SchemaGen [(Text, Schema)]

variantExtractor :: [(Text, Schema -> Strategy' (Term -> C1 (MetaCons name fixity False) f x))]

(GSerialiseVariant f, GSerialiseVariant g) => GSerialiseVariant (f :+: g :: k -> Type)

Defined in Codec.Winery.Class

Methods

variantSchema :: proxy (f :+: g) -> SchemaGen [(Text, Schema)]

variantExtractor :: [(Text, Schema -> Strategy' (Term -> (f :+: g) x))]

gschemaGenVariant :: forall proxy a. (GSerialiseVariant (Rep a), Typeable a, Generic a) => proxy a -> SchemaGen Schema

Generic implementation of schemaGen for an ADT.

gtoBuilderVariant :: forall a. (GConstructorCount (Rep a), GEncodeVariant (Rep a), Generic a) => a -> Builder

Generic implementation of toBuilder for an ADT.

gextractorVariant :: forall a. (GSerialiseVariant (Rep a), Generic a, Typeable a) => Extractor a

Generic implementation of extractor for an ADT.

gdecodeCurrentVariant :: forall a. (GConstructorCount (Rep a), GEncodeVariant (Rep a), GDecodeVariant (Rep a), Generic a) => Decoder a