Data.Winery

Maintainer : Fumiaki Kinoshita [e-mail]

The standard interface of winery serialisation library

Documentation

type Schema = SchemaP Int

A schema preserves structure of a datatype, allowing users to inspect the data regardless of the current implementation.

"Yeah, it’s just a memento. Just, you know, from the first time we met."

data SchemaP a

Constructors

SFix !(SchemaP a)

binds a fixpoint

SVar !a

SVar n refers to the n-th innermost fixpoint

SVector !(SchemaP a)

SProduct !(Vector (SchemaP a))

SRecord !(Vector (Text, SchemaP a))

SVariant !(Vector (Text, SchemaP a))

SBool

SChar

SWord8

SWord16

SWord32

SWord64

SInt8

SInt16

SInt32

SInt64

SInteger

SFloat

SDouble

SBytes

SText

SUTCTime

nanoseconds from POSIX epoch

STag !Tag !(SchemaP a)

SLet !(SchemaP a) !(SchemaP a)

Instances

Functor SchemaP

Defined in Data.Winery.Base

Methods

fmap :: (a -> b) -> SchemaP a -> SchemaP b

(<$) :: a -> SchemaP b -> SchemaP a

Foldable SchemaP

Defined in Data.Winery.Base

Methods

fold :: Monoid m => SchemaP m -> m

foldMap :: Monoid m => (a -> m) -> SchemaP a -> m

foldr :: (a -> b -> b) -> b -> SchemaP a -> b

foldr' :: (a -> b -> b) -> b -> SchemaP a -> b

foldl :: (b -> a -> b) -> b -> SchemaP a -> b

foldl' :: (b -> a -> b) -> b -> SchemaP a -> b

foldr1 :: (a -> a -> a) -> SchemaP a -> a

foldl1 :: (a -> a -> a) -> SchemaP a -> a

toList :: SchemaP a -> [a]

null :: SchemaP a -> Bool

length :: SchemaP a -> Int

elem :: Eq a => a -> SchemaP a -> Bool

maximum :: Ord a => SchemaP a -> a

minimum :: Ord a => SchemaP a -> a

sum :: Num a => SchemaP a -> a

product :: Num a => SchemaP a -> a

Traversable SchemaP

Defined in Data.Winery.Base

Methods

traverse :: Applicative f => (a -> f b) -> SchemaP a -> f (SchemaP b)

sequenceA :: Applicative f => SchemaP (f a) -> f (SchemaP a)

mapM :: Monad m => (a -> m b) -> SchemaP a -> m (SchemaP b)

sequence :: Monad m => SchemaP (m a) -> m (SchemaP a)

Serialise Schema

Defined in Data.Winery

Methods

schemaGen :: Proxy Schema -> SchemaGen Schema

toBuilder :: Schema -> Builder

extractor :: Extractor Schema

decodeCurrent :: Decoder Schema

Eq a => Eq (SchemaP a)

Defined in Data.Winery.Base

Methods

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

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

Read a => Read (SchemaP a)

Defined in Data.Winery.Base

Methods

readsPrec :: Int -> ReadS (SchemaP a)

readList :: ReadS [SchemaP a]

readPrec :: ReadPrec (SchemaP a)

readListPrec :: ReadPrec [SchemaP a]

Show a => Show (SchemaP a)

Defined in Data.Winery.Base

Methods

showsPrec :: Int -> SchemaP a -> ShowS

show :: SchemaP a -> String

showList :: [SchemaP a] -> ShowS

Generic (SchemaP a)

Defined in Data.Winery.Base

Associated Types

type Rep (SchemaP a) :: Type -> Type

Methods

from :: SchemaP a -> Rep (SchemaP a) x

to :: Rep (SchemaP a) x -> SchemaP a

Pretty a => Pretty (SchemaP a)

Defined in Data.Winery.Base

Methods

pretty :: SchemaP a -> Doc ann

prettyList :: [SchemaP a] -> Doc ann

type Rep (SchemaP a)

Defined in Data.Winery.Base

type Rep (SchemaP a) = D1 (MetaData "SchemaP" "Data.Winery.Base" "winery-1-Icmh3EEwZZX4DdnHtaSx4r" False) ((((C1 (MetaCons "SFix" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (SchemaP a))) :+: (C1 (MetaCons "SVar" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) :+: C1 (MetaCons "SVector" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (SchemaP a))))) :+: (C1 (MetaCons "SProduct" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Vector (SchemaP a)))) :+: (C1 (MetaCons "SRecord" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Vector (Text, SchemaP a)))) :+: C1 (MetaCons "SVariant" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Vector (Text, SchemaP a))))))) :+: ((C1 (MetaCons "SBool" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "SChar" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "SWord8" PrefixI False) (U1 :: Type -> Type))) :+: (C1 (MetaCons "SWord16" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "SWord32" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "SWord64" PrefixI False) (U1 :: Type -> Type))))) :+: (((C1 (MetaCons "SInt8" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "SInt16" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "SInt32" PrefixI False) (U1 :: Type -> Type))) :+: (C1 (MetaCons "SInt64" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "SInteger" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "SFloat" PrefixI False) (U1 :: Type -> Type)))) :+: ((C1 (MetaCons "SDouble" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "SBytes" PrefixI False) (U1 :: Type -> Type) :+: C1 (MetaCons "SText" PrefixI False) (U1 :: Type -> Type))) :+: (C1 (MetaCons "SUTCTime" PrefixI False) (U1 :: Type -> Type) :+: (C1 (MetaCons "STag" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 Tag) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (SchemaP a))) :+: C1 (MetaCons "SLet" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (SchemaP a)) :*: S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (SchemaP a))))))))

data Tag

Tag is an extra value that can be attached to a schema.

Constructors

TagInt !Int

TagStr !Text

TagList ![Tag]

Instances

IsList Tag

Defined in Data.Winery.Base

Associated Types

type Item Tag :: Type

Methods

fromList :: [Item Tag] -> Tag

fromListN :: Int -> [Item Tag] -> Tag

toList :: Tag -> [Item Tag]

Eq Tag

Defined in Data.Winery.Base

Methods

(==) :: Tag -> Tag -> Bool

(/=) :: Tag -> Tag -> Bool

Read Tag

Defined in Data.Winery.Base

Methods

readsPrec :: Int -> ReadS Tag

readList :: ReadS [Tag]

readPrec :: ReadPrec Tag

readListPrec :: ReadPrec [Tag]

Show Tag

Defined in Data.Winery.Base

Methods

showsPrec :: Int -> Tag -> ShowS

show :: Tag -> String

showList :: [Tag] -> ShowS

IsString Tag

Defined in Data.Winery.Base

Methods

fromString :: String -> Tag

Generic Tag

Defined in Data.Winery.Base

Associated Types

type Rep Tag :: Type -> Type

Methods

from :: Tag -> Rep Tag x

to :: Rep Tag x -> Tag

Pretty Tag

Defined in Data.Winery.Base

Methods

pretty :: Tag -> Doc ann

prettyList :: [Tag] -> Doc ann

Serialise Tag

Defined in Data.Winery

Methods

schemaGen :: Proxy Tag -> SchemaGen Schema

toBuilder :: Tag -> Builder

extractor :: Extractor Tag

decodeCurrent :: Decoder Tag

type Rep Tag

Defined in Data.Winery.Base

type Rep Tag = D1 (MetaData "Tag" "Data.Winery.Base" "winery-1-Icmh3EEwZZX4DdnHtaSx4r" False) (C1 (MetaCons "TagInt" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 Int)) :+: (C1 (MetaCons "TagStr" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 Text)) :+: C1 (MetaCons "TagList" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 [Tag]))))

type Item Tag

Defined in Data.Winery.Base

type Item Tag = Tag

class Typeable a => Serialise a where

Serialisable datatype

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

Instances

Serialise Bool

Defined in Data.Winery

Methods

schemaGen :: Proxy Bool -> SchemaGen Schema

toBuilder :: Bool -> Builder

extractor :: Extractor Bool

decodeCurrent :: Decoder Bool

Serialise Char

Defined in Data.Winery

Methods

schemaGen :: Proxy Char -> SchemaGen Schema

toBuilder :: Char -> Builder

extractor :: Extractor Char

decodeCurrent :: Decoder Char

Serialise Double

Defined in Data.Winery

Methods

schemaGen :: Proxy Double -> SchemaGen Schema

toBuilder :: Double -> Builder

extractor :: Extractor Double

decodeCurrent :: Decoder Double

Serialise Float

Defined in Data.Winery

Methods

schemaGen :: Proxy Float -> SchemaGen Schema

toBuilder :: Float -> Builder

extractor :: Extractor Float

decodeCurrent :: Decoder Float

Serialise Int

Defined in Data.Winery

Methods

schemaGen :: Proxy Int -> SchemaGen Schema

toBuilder :: Int -> Builder

extractor :: Extractor Int

decodeCurrent :: Decoder Int

Serialise Int8

Defined in Data.Winery

Methods

schemaGen :: Proxy Int8 -> SchemaGen Schema

toBuilder :: Int8 -> Builder

extractor :: Extractor Int8

decodeCurrent :: Decoder Int8

Serialise Int16

Defined in Data.Winery

Methods

schemaGen :: Proxy Int16 -> SchemaGen Schema

toBuilder :: Int16 -> Builder

extractor :: Extractor Int16

decodeCurrent :: Decoder Int16

Serialise Int32

Defined in Data.Winery

Methods

schemaGen :: Proxy Int32 -> SchemaGen Schema

toBuilder :: Int32 -> Builder

extractor :: Extractor Int32

decodeCurrent :: Decoder Int32

Serialise Int64

Defined in Data.Winery

Methods

schemaGen :: Proxy Int64 -> SchemaGen Schema

toBuilder :: Int64 -> Builder

extractor :: Extractor Int64

decodeCurrent :: Decoder Int64

Serialise Integer

Defined in Data.Winery

Methods

schemaGen :: Proxy Integer -> SchemaGen Schema

toBuilder :: Integer -> Builder

extractor :: Extractor Integer

decodeCurrent :: Decoder Integer

Serialise Natural

Defined in Data.Winery

Methods

schemaGen :: Proxy Natural -> SchemaGen Schema

toBuilder :: Natural -> Builder

extractor :: Extractor Natural

decodeCurrent :: Decoder Natural

Serialise Ordering

Defined in Data.Winery

Methods

schemaGen :: Proxy Ordering -> SchemaGen Schema

toBuilder :: Ordering -> Builder

extractor :: Extractor Ordering

decodeCurrent :: Decoder Ordering

Serialise Word

Defined in Data.Winery

Methods

schemaGen :: Proxy Word -> SchemaGen Schema

toBuilder :: Word -> Builder

extractor :: Extractor Word

decodeCurrent :: Decoder Word

Serialise Word8

Defined in Data.Winery

Methods

schemaGen :: Proxy Word8 -> SchemaGen Schema

toBuilder :: Word8 -> Builder

extractor :: Extractor Word8

decodeCurrent :: Decoder Word8

Serialise Word16

Defined in Data.Winery

Methods

schemaGen :: Proxy Word16 -> SchemaGen Schema

toBuilder :: Word16 -> Builder

extractor :: Extractor Word16

decodeCurrent :: Decoder Word16

Serialise Word32

Defined in Data.Winery

Methods

schemaGen :: Proxy Word32 -> SchemaGen Schema

toBuilder :: Word32 -> Builder

extractor :: Extractor Word32

decodeCurrent :: Decoder Word32

Serialise Word64

Defined in Data.Winery

Methods

schemaGen :: Proxy Word64 -> SchemaGen Schema

toBuilder :: Word64 -> Builder

extractor :: Extractor Word64

decodeCurrent :: Decoder Word64

Serialise ()

Defined in Data.Winery

Methods

schemaGen :: Proxy () -> SchemaGen Schema

toBuilder :: () -> Builder

extractor :: Extractor ()

decodeCurrent :: Decoder ()

Serialise ByteString

Defined in Data.Winery

Methods

schemaGen :: Proxy ByteString -> SchemaGen Schema

toBuilder :: ByteString -> Builder

extractor :: Extractor ByteString

decodeCurrent :: Decoder ByteString

Serialise ByteString

Defined in Data.Winery

Methods

schemaGen :: Proxy ByteString -> SchemaGen Schema

toBuilder :: ByteString -> Builder

extractor :: Extractor ByteString

decodeCurrent :: Decoder ByteString

Serialise Scientific

Defined in Data.Winery

Methods

schemaGen :: Proxy Scientific -> SchemaGen Schema

toBuilder :: Scientific -> Builder

extractor :: Extractor Scientific

decodeCurrent :: Decoder Scientific

Serialise Text

Defined in Data.Winery

Methods

schemaGen :: Proxy Text -> SchemaGen Schema

toBuilder :: Text -> Builder

extractor :: Extractor Text

decodeCurrent :: Decoder Text

Serialise UTCTime

Defined in Data.Winery

Methods

schemaGen :: Proxy UTCTime -> SchemaGen Schema

toBuilder :: UTCTime -> Builder

extractor :: Extractor UTCTime

decodeCurrent :: Decoder UTCTime

Serialise Void

Defined in Data.Winery

Methods

schemaGen :: Proxy Void -> SchemaGen Schema

toBuilder :: Void -> Builder

extractor :: Extractor Void

decodeCurrent :: Decoder Void

Serialise All

Defined in Data.Winery

Methods

schemaGen :: Proxy All -> SchemaGen Schema

toBuilder :: All -> Builder

extractor :: Extractor All

decodeCurrent :: Decoder All

Serialise Any

Defined in Data.Winery

Methods

schemaGen :: Proxy Any -> SchemaGen Schema

toBuilder :: Any -> Builder

extractor :: Extractor Any

decodeCurrent :: Decoder Any

Serialise IntSet

Defined in Data.Winery

Methods

schemaGen :: Proxy IntSet -> SchemaGen Schema

toBuilder :: IntSet -> Builder

extractor :: Extractor IntSet

decodeCurrent :: Decoder IntSet

Serialise NominalDiffTime

Defined in Data.Winery

Methods

schemaGen :: Proxy NominalDiffTime -> SchemaGen Schema

toBuilder :: NominalDiffTime -> Builder

extractor :: Extractor NominalDiffTime

decodeCurrent :: Decoder NominalDiffTime

Serialise Schema

Defined in Data.Winery

Methods

schemaGen :: Proxy Schema -> SchemaGen Schema

toBuilder :: Schema -> Builder

extractor :: Extractor Schema

decodeCurrent :: Decoder Schema

Serialise Tag

Defined in Data.Winery

Methods

schemaGen :: Proxy Tag -> SchemaGen Schema

toBuilder :: Tag -> Builder

extractor :: Extractor Tag

decodeCurrent :: Decoder Tag

Serialise a => Serialise [a]

Defined in Data.Winery

Methods

schemaGen :: Proxy [a] -> SchemaGen Schema

toBuilder :: [a] -> Builder

extractor :: Extractor [a]

decodeCurrent :: Decoder [a]

Serialise a => Serialise (Maybe a)

Defined in Data.Winery

Methods

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

toBuilder :: Maybe a -> Builder

extractor :: Extractor (Maybe a)

decodeCurrent :: Decoder (Maybe a)

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

Defined in Data.Winery

Methods

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

toBuilder :: Ratio a -> Builder

extractor :: Extractor (Ratio a)

decodeCurrent :: Decoder (Ratio a)

Serialise a => Serialise (Complex a)

Defined in Data.Winery

Methods

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

toBuilder :: Complex a -> Builder

extractor :: Extractor (Complex a)

decodeCurrent :: Decoder (Complex a)

Serialise a => Serialise (Min a)

Defined in Data.Winery

Methods

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

toBuilder :: Min a -> Builder

extractor :: Extractor (Min a)

decodeCurrent :: Decoder (Min a)

Serialise a => Serialise (Max a)

Defined in Data.Winery

Methods

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

toBuilder :: Max a -> Builder

extractor :: Extractor (Max a)

decodeCurrent :: Decoder (Max a)

Serialise a => Serialise (First a)

Defined in Data.Winery

Methods

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

toBuilder :: First a -> Builder

extractor :: Extractor (First a)

decodeCurrent :: Decoder (First a)

Serialise a => Serialise (Last a)

Defined in Data.Winery

Methods

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

toBuilder :: Last a -> Builder

extractor :: Extractor (Last a)

decodeCurrent :: Decoder (Last a)

Serialise a => Serialise (Option a)

Defined in Data.Winery

Methods

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

toBuilder :: Option a -> Builder

extractor :: Extractor (Option a)

decodeCurrent :: Decoder (Option a)

Serialise a => Serialise (ZipList a)

Defined in Data.Winery

Methods

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

toBuilder :: ZipList a -> Builder

extractor :: Extractor (ZipList a)

decodeCurrent :: Decoder (ZipList a)

Serialise a => Serialise (Identity a)

Defined in Data.Winery

Methods

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

toBuilder :: Identity a -> Builder

extractor :: Extractor (Identity a)

decodeCurrent :: Decoder (Identity a)

Serialise a => Serialise (First a)

Defined in Data.Winery

Methods

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

toBuilder :: First a -> Builder

extractor :: Extractor (First a)

decodeCurrent :: Decoder (First a)

Serialise a => Serialise (Last a)

Defined in Data.Winery

Methods

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

toBuilder :: Last a -> Builder

extractor :: Extractor (Last a)

decodeCurrent :: Decoder (Last a)

Serialise a => Serialise (Dual a)

Defined in Data.Winery

Methods

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

toBuilder :: Dual a -> Builder

extractor :: Extractor (Dual a)

decodeCurrent :: Decoder (Dual a)

Serialise a => Serialise (Sum a)

Defined in Data.Winery

Methods

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

toBuilder :: Sum a -> Builder

extractor :: Extractor (Sum a)

decodeCurrent :: Decoder (Sum a)

Serialise a => Serialise (Product a)

Defined in Data.Winery

Methods

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

toBuilder :: Product a -> Builder

extractor :: Extractor (Product a)

decodeCurrent :: Decoder (Product a)

Serialise a => Serialise (Down a)

Defined in Data.Winery

Methods

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

toBuilder :: Down a -> Builder

extractor :: Extractor (Down a)

decodeCurrent :: Decoder (Down a)

Serialise v => Serialise (IntMap v)

Defined in Data.Winery

Methods

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

toBuilder :: IntMap v -> Builder

extractor :: Extractor (IntMap v)

decodeCurrent :: Decoder (IntMap v)

Serialise a => Serialise (Seq a)

Defined in Data.Winery

Methods

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

toBuilder :: Seq a -> Builder

extractor :: Extractor (Seq a)

decodeCurrent :: Decoder (Seq a)

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

Defined in Data.Winery

Methods

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

toBuilder :: Set a -> Builder

extractor :: Extractor (Set a)

decodeCurrent :: Decoder (Set a)

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

Defined in Data.Winery

Methods

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

toBuilder :: Vector a -> Builder

extractor :: Extractor (Vector a)

decodeCurrent :: Decoder (Vector a)

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

Defined in Data.Winery

Methods

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

toBuilder :: Vector a -> Builder

extractor :: Extractor (Vector a)

decodeCurrent :: Decoder (Vector a)

Serialise a => Serialise (Vector a)

Defined in Data.Winery

Methods

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

toBuilder :: Vector a -> Builder

extractor :: Extractor (Vector a)

decodeCurrent :: Decoder (Vector a)

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

Defined in Data.Winery

Methods

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

toBuilder :: WineryVariant a -> Builder

extractor :: Extractor (WineryVariant a)

decodeCurrent :: Decoder (WineryVariant a)

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

Defined in Data.Winery

Methods

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

toBuilder :: WineryProduct a -> Builder

extractor :: Extractor (WineryProduct a)

decodeCurrent :: Decoder (WineryProduct a)

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

Defined in Data.Winery

Methods

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

toBuilder :: WineryRecord a -> Builder

extractor :: Extractor (WineryRecord a)

decodeCurrent :: Decoder (WineryRecord a)

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

Defined in Data.Winery

Methods

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

toBuilder :: VarInt a -> Builder

extractor :: Extractor (VarInt a)

decodeCurrent :: Decoder (VarInt a)

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

Defined in Data.Winery

Methods

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

toBuilder :: Either a b -> Builder

extractor :: Extractor (Either a b)

decodeCurrent :: Decoder (Either a b)

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

Defined in Data.Winery

Methods

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

toBuilder :: (a, b) -> Builder

extractor :: Extractor (a, b)

decodeCurrent :: Decoder (a, b)

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

Defined in Data.Winery

Methods

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

toBuilder :: HashMap k v -> Builder

extractor :: Extractor (HashMap k v)

decodeCurrent :: Decoder (HashMap k v)

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

Defined in Data.Winery

Methods

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

toBuilder :: Map k v -> Builder

extractor :: Extractor (Map k v)

decodeCurrent :: Decoder (Map k v)

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

Defined in Data.Winery

Methods

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

toBuilder :: Arg a b -> Builder

extractor :: Extractor (Arg a b)

decodeCurrent :: Decoder (Arg a b)

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

Defined in Data.Winery

Methods

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

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

extractor :: Extractor (a, b, c)

decodeCurrent :: Decoder (a, b, c)

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

Defined in Data.Winery

Methods

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

toBuilder :: Const a b -> Builder

extractor :: Extractor (Const a b)

decodeCurrent :: Decoder (Const a b)

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

Defined in Data.Winery

Methods

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

toBuilder :: Ap f a -> Builder

extractor :: Extractor (Ap f a)

decodeCurrent :: Decoder (Ap f a)

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

Defined in Data.Winery

Methods

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

toBuilder :: Alt f a -> Builder

extractor :: Extractor (Alt f a)

decodeCurrent :: Decoder (Alt f a)

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

Defined in Data.Winery

Methods

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

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

extractor :: Extractor (a :~: b)

decodeCurrent :: Decoder (a :~: b)

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

Defined in Data.Winery

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)

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

Defined in Data.Winery

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)

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

Defined in Data.Winery

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)

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

Defined in Data.Winery

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)

testSerialise :: forall a. (Eq a, Show a, Serialise a) => a -> Property

Check the integrity of a Serialise instance.

"No tears in the writer, no tears in the reader. No surprise in the writer, no surprise in the reader."

data DecodeException

Constructors

InsufficientInput

IntegerOverflow

InvalidTag

Instances

Eq DecodeException

Defined in Data.Winery.Internal

Methods

(==) :: DecodeException -> DecodeException -> Bool

(/=) :: DecodeException -> DecodeException -> Bool

Read DecodeException

Defined in Data.Winery.Internal

Methods

readsPrec :: Int -> ReadS DecodeException

readList :: ReadS [DecodeException]

readPrec :: ReadPrec DecodeException

readListPrec :: ReadPrec [DecodeException]

Show DecodeException

Defined in Data.Winery.Internal

Methods

showsPrec :: Int -> DecodeException -> ShowS

show :: DecodeException -> String

showList :: [DecodeException] -> ShowS

Exception DecodeException

Defined in Data.Winery.Internal

Methods

toException :: DecodeException -> SomeException

fromException :: SomeException -> Maybe DecodeException

displayException :: DecodeException -> String

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

Standalone serialisation

toBuilderWithSchema :: forall a. Serialise a => a -> Builder

serialise :: Serialise a => a -> ByteString

Serialise a value along with its schema.

"Write the vision, and make it plain upon tables, that he may run that readeth it."

deserialise :: Serialise a => ByteString -> Either WineryException a

Deserialise a serialised Bytestring.

"Old wood to burn! Old wine to drink! Old friends to trust! Old authors to read!"

deserialiseBy :: Extractor a -> ByteString -> Either WineryException a

Deserialise a serialised Bytestring using an Extractor.

deserialiseTerm :: ByteString -> Either WineryException (Schema, Term)

Deserialise a serialised Bytestring.

splitSchema :: ByteString -> Either WineryException (Schema, ByteString)

writeFileSerialise :: Serialise a => FilePath -> a -> IO ()

Serialise a value along with its schema.

Separate serialisation

serialiseSchema :: Schema -> ByteString

Serialise a schema.

deserialiseSchema :: ByteString -> Either WineryException Schema

Serialise a schema.

newtype Extractor a

Extractor is a Plan that creates a function to extract a value from Term.

The Applicative instance can be used to build a user-defined extractor. This is also Alternative, meaning that fallback plans may be added.

"Don't get set into one form, adapt it and build your own, and let it grow, be like water."

Constructors

Extractor

Fields

• getExtractor :: Plan (Term -> a)

Instances

Functor Extractor

Defined in Data.Winery.Base

Methods

fmap :: (a -> b) -> Extractor a -> Extractor b

(<$) :: a -> Extractor b -> Extractor a

Applicative Extractor

Defined in Data.Winery.Base

Methods

pure :: a -> Extractor a

(<*>) :: Extractor (a -> b) -> Extractor a -> Extractor b

liftA2 :: (a -> b -> c) -> Extractor a -> Extractor b -> Extractor c

(*>) :: Extractor a -> Extractor b -> Extractor b

(<*) :: Extractor a -> Extractor b -> Extractor a

Alternative Extractor

Defined in Data.Winery.Base

Methods

empty :: Extractor a

(<|>) :: Extractor a -> Extractor a -> Extractor a

some :: Extractor a -> Extractor [a]

many :: Extractor a -> Extractor [a]

unwrapExtractor :: Extractor a -> Schema -> Strategy' (Term -> a)

type Decoder = State ByteString

evalDecoder :: Decoder a -> ByteString -> a

serialiseOnly :: Serialise a => a -> ByteString

Serialise a value without its schema.

"Any unsaved progress will be lost."

getDecoder :: forall a. Serialise a => Schema -> Either WineryException (Decoder a)

Obtain a decoder from a schema.

"A reader lives a thousand lives before he dies... The man who never reads lives only one."

getDecoderBy :: Extractor a -> Schema -> Either WineryException (Decoder a)

Get a decoder from a Extractor and a schema.

Decoding combinators

data Term

Common representation for any winery data. Handy for prettyprinting winery-serialised data.

Constructors

TBool !Bool

TChar !Char

TWord8 !Word8

TWord16 !Word16

TWord32 !Word32

TWord64 !Word64

TInt8 !Int8

TInt16 !Int16

TInt32 !Int32

TInt64 !Int64

TInteger !Integer

TFloat !Float

TDouble !Double

TBytes !ByteString

TText !Text

TUTCTime !UTCTime

TVector !(Vector Term)

TProduct !(Vector Term)

TRecord !(Vector (Text, Term))

TVariant !Int !Text Term

Instances

Show Term

Defined in Data.Winery.Base

Methods

showsPrec :: Int -> Term -> ShowS

show :: Term -> String

showList :: [Term] -> ShowS

ToJSON Term

Defined in Data.Winery.Base

Methods

toJSON :: Term -> Value

toEncoding :: Term -> Encoding

toJSONList :: [Term] -> Value

toEncodingList :: [Term] -> Encoding

Pretty Term

Defined in Data.Winery.Base

Methods

pretty :: Term -> Doc ann

prettyList :: [Term] -> Doc ann

newtype Subextractor a

Constructors

Subextractor

Fields

• unSubextractor :: Extractor a

Instances

Functor Subextractor

Defined in Data.Winery

Methods

fmap :: (a -> b) -> Subextractor a -> Subextractor b

(<$) :: a -> Subextractor b -> Subextractor a

Applicative Subextractor

Defined in Data.Winery

Methods

pure :: a -> Subextractor a

(<*>) :: Subextractor (a -> b) -> Subextractor a -> Subextractor b

liftA2 :: (a -> b -> c) -> Subextractor a -> Subextractor b -> Subextractor c

(*>) :: Subextractor a -> Subextractor b -> Subextractor b

(<*) :: Subextractor a -> Subextractor b -> Subextractor a

Alternative Subextractor

Defined in Data.Winery

Methods

empty :: Subextractor a

(<|>) :: Subextractor a -> Subextractor a -> Subextractor a

some :: Subextractor a -> Subextractor [a]

many :: Subextractor a -> Subextractor [a]

buildExtractor :: Typeable a => Subextractor a -> Extractor a

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

Extract a list or an array of values.

extractField :: Serialise a => Text -> Subextractor a

Extract a field of a record.

extractFieldBy :: Extractor a -> Text -> Subextractor a

Extract a field using the supplied Extractor.

extractConstructor :: Serialise a => (Text, a -> r) -> Subextractor r -> Subextractor r infixr 1

Tries to match on a constructor. If it doesn't match (or constructor doesn't exist at all), leave it to the successor.

extractor = (Just, Just) extractConstructor (Nothing, () -> Nothing) extractConstructor extractVoid

extractConstructorBy :: Typeable a => (Extractor a, Text, a -> r) -> Subextractor r -> Subextractor r infixr 1

Tries to extract a specific constructor of a variant. Useful for implementing backward-compatible extractors.

extractVoid :: Typeable r => Subextractor r

data ExtractException

This may be thrown if illegal Term is passed to an extractor.

Constructors

InvalidTerm !Term

Instances

Show ExtractException

Defined in Data.Winery

Methods

showsPrec :: Int -> ExtractException -> ShowS

show :: ExtractException -> String

showList :: [ExtractException] -> ShowS

Exception ExtractException

Defined in Data.Winery

Methods

toException :: ExtractException -> SomeException

fromException :: SomeException -> Maybe ExtractException

displayException :: ExtractException -> String

Variable-length quantity

newtype VarInt a

Encoded in variable-length quantity.

Constructors

VarInt

Fields

• getVarInt :: a

Instances

Bounded a => Bounded (VarInt a)

Defined in Data.Winery

Methods

minBound :: VarInt a

maxBound :: VarInt a

Enum a => Enum (VarInt a)

Defined in Data.Winery

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 Data.Winery

Methods

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

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

Integral a => Integral (VarInt a)

Defined in Data.Winery

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 Data.Winery

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 Data.Winery

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 Data.Winery

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 Data.Winery

Methods

toRational :: VarInt a -> Rational

Show a => Show (VarInt a)

Defined in Data.Winery

Methods

showsPrec :: Int -> VarInt a -> ShowS

show :: VarInt a -> String

showList :: [VarInt a] -> ShowS

Bits a => Bits (VarInt a)

Defined in Data.Winery

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 Data.Winery

Methods

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

toBuilder :: VarInt a -> Builder

extractor :: Extractor (VarInt a)

decodeCurrent :: Decoder (VarInt a)

Internal

data WineryException

Constructors

UnexpectedSchema !(Doc AnsiStyle) !(Doc AnsiStyle) !Schema

FieldNotFound !(Doc AnsiStyle) !Text ![Text]

TypeMismatch !Int !TypeRep !TypeRep

ProductTooSmall !Int

UnboundVariable !Int

EmptyInput

WineryMessage !(Doc AnsiStyle)

Instances

Show WineryException

Defined in Data.Winery.Base

Methods

showsPrec :: Int -> WineryException -> ShowS

show :: WineryException -> String

showList :: [WineryException] -> ShowS

IsString WineryException

Defined in Data.Winery.Base

Methods

fromString :: String -> WineryException

Exception WineryException

Defined in Data.Winery.Base

Methods

toException :: WineryException -> SomeException

fromException :: SomeException -> Maybe WineryException

displayException :: WineryException -> String

prettyWineryException :: WineryException -> Doc AnsiStyle

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

data SchemaGen a

Schema generator

Instances

Functor SchemaGen

Defined in Data.Winery

Methods

fmap :: (a -> b) -> SchemaGen a -> SchemaGen b

(<$) :: a -> SchemaGen b -> SchemaGen a

Applicative SchemaGen

Defined in Data.Winery

Methods

pure :: a -> SchemaGen a

(<*>) :: SchemaGen (a -> b) -> SchemaGen a -> SchemaGen b

liftA2 :: (a -> b -> c) -> SchemaGen a -> SchemaGen b -> SchemaGen c

(*>) :: SchemaGen a -> SchemaGen b -> SchemaGen b

(<*) :: SchemaGen a -> SchemaGen b -> SchemaGen a

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.

newtype Plan a

Plan is a monad for computations which interpret Schema.

Constructors

Plan

Fields

• unPlan :: Schema -> Strategy' a

Instances

Monad Plan

Defined in Data.Winery.Base

Methods

(>>=) :: Plan a -> (a -> Plan b) -> Plan b

(>>) :: Plan a -> Plan b -> Plan b

return :: a -> Plan a

fail :: String -> Plan a

Functor Plan

Defined in Data.Winery.Base

Methods

fmap :: (a -> b) -> Plan a -> Plan b

(<$) :: a -> Plan b -> Plan a

Applicative Plan

Defined in Data.Winery.Base

Methods

pure :: a -> Plan a

(<*>) :: Plan (a -> b) -> Plan a -> Plan b

liftA2 :: (a -> b -> c) -> Plan a -> Plan b -> Plan c

(*>) :: Plan a -> Plan b -> Plan b

(<*) :: Plan a -> Plan b -> Plan a

Alternative Plan

Defined in Data.Winery.Base

Methods

empty :: Plan a

(<|>) :: Plan a -> Plan a -> Plan a

some :: Plan a -> Plan [a]

many :: Plan a -> Plan [a]

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

Construct a plan, expanding fixpoints and let bindings.

DerivingVia

newtype WineryRecord a

The Serialise instance is generically defined for records.

/"Remember thee! Yea, from the table of my memory I'll wipe away all trivial fond records."/

Constructors

WineryRecord

Fields

• unWineryRecord :: a

Instances

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

Defined in Data.Winery

Methods

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

toBuilder :: WineryRecord a -> Builder

extractor :: Extractor (WineryRecord a)

decodeCurrent :: Decoder (WineryRecord a)

newtype WineryVariant a

The Serialise instance is generically defined for variants.

"The one so like the other as could not be distinguish'd but by names."

Constructors

WineryVariant

Fields

• unWineryVariant :: a

Instances

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

Defined in Data.Winery

Methods

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

toBuilder :: WineryVariant a -> Builder

extractor :: Extractor (WineryVariant a)

decodeCurrent :: Decoder (WineryVariant a)

newtype WineryProduct a

Serialise a value as a product (omits field names).

"I get ideas about what's essential when packing my suitcase."

Constructors

WineryProduct

Fields

• unWineryProduct :: a

Instances

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

Defined in Data.Winery

Methods

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

toBuilder :: WineryProduct a -> Builder

extractor :: Extractor (WineryProduct a)

decodeCurrent :: Decoder (WineryProduct a)

Generic implementations (for old GHC / custom instances)

class GSerialiseRecord f

Minimal complete definition

recordSchema, recordExtractor, recordDecoder

Instances

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

Defined in Data.Winery

Methods

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

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

recordDecoder :: Decoder (D1 c f x)

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

Defined in Data.Winery

Methods

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

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

recordDecoder :: Decoder (C1 c f x)

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

Defined in Data.Winery

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)

recordDecoder :: Decoder (S1 c (K1 i a) x)

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

Defined in Data.Winery

Methods

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

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

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

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

Generic implementation of schemaGen for a record.

class GEncodeProduct f

Minimal complete definition

productEncoder

Instances

GEncodeProduct (U1 :: k -> Type)

Defined in Data.Winery

Methods

productEncoder :: U1 x -> Builder

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

Defined in Data.Winery

Methods

productEncoder :: D1 c f x -> Builder

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

Defined in Data.Winery

Methods

productEncoder :: C1 c f x -> Builder

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

Defined in Data.Winery

Methods

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

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

Defined in Data.Winery

Methods

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

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.

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

class GSerialiseVariant f

Minimal complete definition

variantCount, variantSchema, variantEncoder, variantExtractor, variantDecoder

Instances

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

Defined in Data.Winery

Methods

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

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

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

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

variantDecoder :: [Decoder (D1 c f x)]

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

Defined in Data.Winery

Methods

variantCount :: proxy (S1 c f) -> Int

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

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

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

variantDecoder :: [Decoder (S1 c f x)]

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

Defined in Data.Winery

Methods

variantCount :: proxy (C1 (MetaCons name fixity True) f) -> Int

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

variantEncoder :: Int -> C1 (MetaCons name fixity True) f x -> Builder

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

variantDecoder :: [Decoder (C1 (MetaCons name fixity True) f x)]

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

Defined in Data.Winery

Methods

variantCount :: proxy (C1 (MetaCons name fixity False) f) -> Int

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

variantEncoder :: Int -> C1 (MetaCons name fixity False) f x -> Builder

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

variantDecoder :: [Decoder (C1 (MetaCons name fixity False) f x)]

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

Defined in Data.Winery

Methods

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

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

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

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

variantDecoder :: [Decoder ((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 :: (GSerialiseVariant (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.

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

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

gdecodeCurrentVariant :: (GSerialiseVariant (Rep a), Generic a) => Decoder a

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

Generic implementation of extractor for a record.

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

Generic implementation of extractor for a record.

Preset schema

bootstrapSchema :: Word8 -> Schema