Codec.Winery

Maintainer : Fumiaki Kinoshita [e-mail]

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

The basic schema datatype

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 Codec.Winery.Base

Methods

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

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

Foldable SchemaP

Defined in Codec.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 Codec.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 Codec.Winery

Methods

schemaGen :: Proxy Schema -> SchemaGen Schema

toBuilder :: Schema -> Builder

extractor :: Extractor Schema

decodeCurrent :: Decoder Schema

bundleSerialise :: BundleSerialise Schema

Eq a => Eq (SchemaP a)

Defined in Codec.Winery.Base

Methods

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

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

Read a => Read (SchemaP a)

Defined in Codec.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 Codec.Winery.Base

Methods

showsPrec :: Int -> SchemaP a -> ShowS

show :: SchemaP a -> String

showList :: [SchemaP a] -> ShowS

Generic (SchemaP a)

Defined in Codec.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 Codec.Winery.Base

Methods

pretty :: SchemaP a -> Doc ann

prettyList :: [SchemaP a] -> Doc ann

type Rep (SchemaP a)

Defined in Codec.Winery.Base

type Rep (SchemaP a) = D1 (MetaData "SchemaP" "Codec.Winery.Base" "winery-1.1.1-IJNRMEpxwog9H471ljyF0Q" 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 Codec.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 Codec.Winery.Base

Methods

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

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

Read Tag

Defined in Codec.Winery.Base

Methods

readsPrec :: Int -> ReadS Tag

readList :: ReadS [Tag]

readPrec :: ReadPrec Tag

readListPrec :: ReadPrec [Tag]

Show Tag

Defined in Codec.Winery.Base

Methods

showsPrec :: Int -> Tag -> ShowS

show :: Tag -> String

showList :: [Tag] -> ShowS

IsString Tag

Defined in Codec.Winery.Base

Methods

fromString :: String -> Tag

Generic Tag

Defined in Codec.Winery.Base

Associated Types

type Rep Tag :: Type -> Type

Methods

from :: Tag -> Rep Tag x

to :: Rep Tag x -> Tag

Pretty Tag

Defined in Codec.Winery.Base

Methods

pretty :: Tag -> Doc ann

prettyList :: [Tag] -> Doc ann

Serialise Tag

Defined in Codec.Winery

Methods

schemaGen :: Proxy Tag -> SchemaGen Schema

toBuilder :: Tag -> Builder

extractor :: Extractor Tag

decodeCurrent :: Decoder Tag

bundleSerialise :: BundleSerialise Tag

type Rep Tag

Defined in Codec.Winery.Base

type Rep Tag = D1 (MetaData "Tag" "Codec.Winery.Base" "winery-1.1.1-IJNRMEpxwog9H471ljyF0Q" 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 Codec.Winery.Base

type Item Tag = Tag

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

Methods

schemaGen :: Proxy Bool -> SchemaGen Schema

toBuilder :: Bool -> Builder

extractor :: Extractor Bool

decodeCurrent :: Decoder Bool

bundleSerialise :: BundleSerialise Bool

Serialise Char

Defined in Codec.Winery

Methods

schemaGen :: Proxy Char -> SchemaGen Schema

toBuilder :: Char -> Builder

extractor :: Extractor Char

decodeCurrent :: Decoder Char

bundleSerialise :: BundleSerialise Char

Serialise Double

Defined in Codec.Winery

Methods

schemaGen :: Proxy Double -> SchemaGen Schema

toBuilder :: Double -> Builder

extractor :: Extractor Double

decodeCurrent :: Decoder Double

bundleSerialise :: BundleSerialise Double

Serialise Float

Defined in Codec.Winery

Methods

schemaGen :: Proxy Float -> SchemaGen Schema

toBuilder :: Float -> Builder

extractor :: Extractor Float

decodeCurrent :: Decoder Float

bundleSerialise :: BundleSerialise Float

Serialise Int

Defined in Codec.Winery

Methods

schemaGen :: Proxy Int -> SchemaGen Schema

toBuilder :: Int -> Builder

extractor :: Extractor Int

decodeCurrent :: Decoder Int

bundleSerialise :: BundleSerialise Int

Serialise Int8

Defined in Codec.Winery

Methods

schemaGen :: Proxy Int8 -> SchemaGen Schema

toBuilder :: Int8 -> Builder

extractor :: Extractor Int8

decodeCurrent :: Decoder Int8

bundleSerialise :: BundleSerialise Int8

Serialise Int16

Defined in Codec.Winery

Methods

schemaGen :: Proxy Int16 -> SchemaGen Schema

toBuilder :: Int16 -> Builder

extractor :: Extractor Int16

decodeCurrent :: Decoder Int16

bundleSerialise :: BundleSerialise Int16

Serialise Int32

Defined in Codec.Winery

Methods

schemaGen :: Proxy Int32 -> SchemaGen Schema

toBuilder :: Int32 -> Builder

extractor :: Extractor Int32

decodeCurrent :: Decoder Int32

bundleSerialise :: BundleSerialise Int32

Serialise Int64

Defined in Codec.Winery

Methods

schemaGen :: Proxy Int64 -> SchemaGen Schema

toBuilder :: Int64 -> Builder

extractor :: Extractor Int64

decodeCurrent :: Decoder Int64

bundleSerialise :: BundleSerialise Int64

Serialise Integer

Defined in Codec.Winery

Methods

schemaGen :: Proxy Integer -> SchemaGen Schema

toBuilder :: Integer -> Builder

extractor :: Extractor Integer

decodeCurrent :: Decoder Integer

bundleSerialise :: BundleSerialise Integer

Serialise Natural

Defined in Codec.Winery

Methods

schemaGen :: Proxy Natural -> SchemaGen Schema

toBuilder :: Natural -> Builder

extractor :: Extractor Natural

decodeCurrent :: Decoder Natural

bundleSerialise :: BundleSerialise Natural

Serialise Ordering

Defined in Codec.Winery

Methods

schemaGen :: Proxy Ordering -> SchemaGen Schema

toBuilder :: Ordering -> Builder

extractor :: Extractor Ordering

decodeCurrent :: Decoder Ordering

bundleSerialise :: BundleSerialise Ordering

Serialise Word

Defined in Codec.Winery

Methods

schemaGen :: Proxy Word -> SchemaGen Schema

toBuilder :: Word -> Builder

extractor :: Extractor Word

decodeCurrent :: Decoder Word

bundleSerialise :: BundleSerialise Word

Serialise Word8

Defined in Codec.Winery

Methods

schemaGen :: Proxy Word8 -> SchemaGen Schema

toBuilder :: Word8 -> Builder

extractor :: Extractor Word8

decodeCurrent :: Decoder Word8

bundleSerialise :: BundleSerialise Word8

Serialise Word16

Defined in Codec.Winery

Methods

schemaGen :: Proxy Word16 -> SchemaGen Schema

toBuilder :: Word16 -> Builder

extractor :: Extractor Word16

decodeCurrent :: Decoder Word16

bundleSerialise :: BundleSerialise Word16

Serialise Word32

Defined in Codec.Winery

Methods

schemaGen :: Proxy Word32 -> SchemaGen Schema

toBuilder :: Word32 -> Builder

extractor :: Extractor Word32

decodeCurrent :: Decoder Word32

bundleSerialise :: BundleSerialise Word32

Serialise Word64

Defined in Codec.Winery

Methods

schemaGen :: Proxy Word64 -> SchemaGen Schema

toBuilder :: Word64 -> Builder

extractor :: Extractor Word64

decodeCurrent :: Decoder Word64

bundleSerialise :: BundleSerialise Word64

Serialise ()

Defined in Codec.Winery

Methods

schemaGen :: Proxy () -> SchemaGen Schema

toBuilder :: () -> Builder

extractor :: Extractor ()

decodeCurrent :: Decoder ()

bundleSerialise :: BundleSerialise ()

Serialise ByteString

Defined in Codec.Winery

Methods

schemaGen :: Proxy ByteString -> SchemaGen Schema

toBuilder :: ByteString -> Builder

extractor :: Extractor ByteString

decodeCurrent :: Decoder ByteString

bundleSerialise :: BundleSerialise ByteString

Serialise ByteString

Defined in Codec.Winery

Methods

schemaGen :: Proxy ByteString -> SchemaGen Schema

toBuilder :: ByteString -> Builder

extractor :: Extractor ByteString

decodeCurrent :: Decoder ByteString

bundleSerialise :: BundleSerialise ByteString

Serialise Scientific

Defined in Codec.Winery

Methods

schemaGen :: Proxy Scientific -> SchemaGen Schema

toBuilder :: Scientific -> Builder

extractor :: Extractor Scientific

decodeCurrent :: Decoder Scientific

bundleSerialise :: BundleSerialise Scientific

Serialise Text

Defined in Codec.Winery

Methods

schemaGen :: Proxy Text -> SchemaGen Schema

toBuilder :: Text -> Builder

extractor :: Extractor Text

decodeCurrent :: Decoder Text

bundleSerialise :: BundleSerialise Text

Serialise UTCTime

Defined in Codec.Winery

Methods

schemaGen :: Proxy UTCTime -> SchemaGen Schema

toBuilder :: UTCTime -> Builder

extractor :: Extractor UTCTime

decodeCurrent :: Decoder UTCTime

bundleSerialise :: BundleSerialise UTCTime

Serialise Void

Defined in Codec.Winery

Methods

schemaGen :: Proxy Void -> SchemaGen Schema

toBuilder :: Void -> Builder

extractor :: Extractor Void

decodeCurrent :: Decoder Void

bundleSerialise :: BundleSerialise Void

Serialise All

Defined in Codec.Winery

Methods

schemaGen :: Proxy All -> SchemaGen Schema

toBuilder :: All -> Builder

extractor :: Extractor All

decodeCurrent :: Decoder All

bundleSerialise :: BundleSerialise All

Serialise Any

Defined in Codec.Winery

Methods

schemaGen :: Proxy Any -> SchemaGen Schema

toBuilder :: Any -> Builder

extractor :: Extractor Any

decodeCurrent :: Decoder Any

bundleSerialise :: BundleSerialise Any

Serialise IntSet

Defined in Codec.Winery

Methods

schemaGen :: Proxy IntSet -> SchemaGen Schema

toBuilder :: IntSet -> Builder

extractor :: Extractor IntSet

decodeCurrent :: Decoder IntSet

bundleSerialise :: BundleSerialise IntSet

Serialise NominalDiffTime

Defined in Codec.Winery

Methods

schemaGen :: Proxy NominalDiffTime -> SchemaGen Schema

toBuilder :: NominalDiffTime -> Builder

extractor :: Extractor NominalDiffTime

decodeCurrent :: Decoder NominalDiffTime

bundleSerialise :: BundleSerialise NominalDiffTime

Serialise Schema

Defined in Codec.Winery

Methods

schemaGen :: Proxy Schema -> SchemaGen Schema

toBuilder :: Schema -> Builder

extractor :: Extractor Schema

decodeCurrent :: Decoder Schema

bundleSerialise :: BundleSerialise Schema

Serialise Tag

Defined in Codec.Winery

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Methods

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

toBuilder :: Vector a -> Builder

extractor :: Extractor (Vector a)

decodeCurrent :: Decoder (Vector a)

bundleSerialise :: BundleSerialise (Vector 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)

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

Defined in Codec.Winery

Methods

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

toBuilder :: VarInt a -> Builder

extractor :: Extractor (VarInt a)

decodeCurrent :: Decoder (VarInt a)

bundleSerialise :: BundleSerialise (VarInt a)

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

Defined in Codec.Winery

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

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

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

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

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

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

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

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

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

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

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

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

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

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)

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

Exceptions thrown by a Decoder

Constructors

InsufficientInput

IntegerOverflow

InvalidTag

Instances

Eq DecodeException

Defined in Codec.Winery.Internal

Methods

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

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

Read DecodeException

Defined in Codec.Winery.Internal

Methods

readsPrec :: Int -> ReadS DecodeException

readList :: ReadS [DecodeException]

readPrec :: ReadPrec DecodeException

readListPrec :: ReadPrec [DecodeException]

Show DecodeException

Defined in Codec.Winery.Internal

Methods

showsPrec :: Int -> DecodeException -> ShowS

show :: DecodeException -> String

showList :: [DecodeException] -> ShowS

Exception DecodeException

Defined in Codec.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 a value with the schema.

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)

Split a Schema from a ByteString.

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

serialise then write it to a file.

Separate serialisation

serialiseSchema :: Schema -> ByteString

Serialise a schema.

deserialiseSchema :: ByteString -> Either WineryException Schema

Deserialise 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 Codec.Winery.Base

Methods

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

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

Applicative Extractor

Defined in Codec.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 Codec.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)

Run an Extractor.

data Decoder a

The Decoder monad

Instances

Monad Decoder

Defined in Codec.Winery.Internal

Methods

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

(>>) :: Decoder a -> Decoder b -> Decoder b

return :: a -> Decoder a

fail :: String -> Decoder a

Functor Decoder

Defined in Codec.Winery.Internal

Methods

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

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

Applicative Decoder

Defined in Codec.Winery.Internal

Methods

pure :: a -> Decoder a

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

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

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

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

evalDecoder :: Decoder a -> ByteString -> a

Run a Decoder

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 Codec.Winery.Base

Methods

showsPrec :: Int -> Term -> ShowS

show :: Term -> String

showList :: [Term] -> ShowS

ToJSON Term

Defined in Codec.Winery.Base

Methods

toJSON :: Term -> Value

toEncoding :: Term -> Encoding

toJSONList :: [Term] -> Value

toEncodingList :: [Term] -> Encoding

Pretty Term

Defined in Codec.Winery.Base

Methods

pretty :: Term -> Doc ann

prettyList :: [Term] -> Doc ann

newtype Subextractor a

An extractor for individual fields. This distinction is required for handling recursions correctly.

Recommended extension: ApplicativeDo

Constructors

Subextractor

Fields

• unSubextractor :: Extractor a

Instances

Functor Subextractor

Defined in Codec.Winery

Methods

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

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

Applicative Subextractor

Defined in Codec.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 Codec.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

Build an extractor from a Subextractor.

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

No constructors remaining.

data ExtractException

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

Constructors

InvalidTerm !Term

Instances

Show ExtractException

Defined in Codec.Winery

Methods

showsPrec :: Int -> ExtractException -> ShowS

show :: ExtractException -> String

showList :: [ExtractException] -> ShowS

Exception ExtractException

Defined in Codec.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 Codec.Winery

Methods

minBound :: VarInt a

maxBound :: VarInt a

Enum a => Enum (VarInt a)

Defined in Codec.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 Codec.Winery

Methods

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

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

Integral a => Integral (VarInt a)

Defined in Codec.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 Codec.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 Codec.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 Codec.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 Codec.Winery

Methods

toRational :: VarInt a -> Rational

Show a => Show (VarInt a)

Defined in Codec.Winery

Methods

showsPrec :: Int -> VarInt a -> ShowS

show :: VarInt a -> String

showList :: [VarInt a] -> ShowS

Bits a => Bits (VarInt a)

Defined in Codec.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 Codec.Winery

Methods

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

toBuilder :: VarInt a -> Builder

extractor :: Extractor (VarInt a)

decodeCurrent :: Decoder (VarInt a)

bundleSerialise :: BundleSerialise (VarInt a)

Internal

data WineryException

Exceptions thrown when by an extractor

Constructors

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

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

TypeMismatch !Int !TypeRep !TypeRep

ProductTooSmall !Int

UnboundVariable !Int

EmptyInput

WineryMessage !(Doc AnsiStyle)

UnsupportedSchemaVersion !Word8

Instances

Show WineryException

Defined in Codec.Winery.Base

Methods

showsPrec :: Int -> WineryException -> ShowS

show :: WineryException -> String

showList :: [WineryException] -> ShowS

IsString WineryException

Defined in Codec.Winery.Base

Methods

fromString :: String -> WineryException

Exception WineryException

Defined in Codec.Winery.Base

Methods

toException :: WineryException -> SomeException

fromException :: SomeException -> Maybe WineryException

displayException :: WineryException -> String

prettyWineryException :: WineryException -> Doc AnsiStyle

Pretty-print WineryException

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

data SchemaGen a

Schema generator

Instances

Functor SchemaGen

Defined in Codec.Winery

Methods

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

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

Applicative SchemaGen

Defined in Codec.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 Codec.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 Codec.Winery.Base

Methods

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

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

Applicative Plan

Defined in Codec.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 Codec.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), 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)

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

(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)

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), 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)

Generic implementations (for old GHC / custom instances)

class GSerialiseRecord f

Minimal complete definition

recordSchema, recordExtractor

Instances

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

Defined in Codec.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)

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

Defined in Codec.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)

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

Defined in Codec.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)

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

Defined in Codec.Winery

Methods

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

recordExtractor :: Maybe ((f :*: g) x) -> TransFusion (FieldDecoder Text) ((->) Term) (Term -> (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.

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 :: (GDecodeProduct (Rep a), Generic a) => Decoder a

Synonym for gdecodeCurrentProduct

class GSerialiseVariant f

Minimal complete definition

variantSchema, variantExtractor

Instances

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

Defined in Codec.Winery

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

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

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

Methods

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

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

class GConstructorCount f

Minimal complete definition

variantCount

Instances

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

Defined in Codec.Winery

Methods

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

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

Defined in Codec.Winery

Methods

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

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

Defined in Codec.Winery

Methods

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

class GEncodeVariant f

Minimal complete definition

variantEncoder

Instances

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

Defined in Codec.Winery

Methods

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

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

Defined in Codec.Winery

Methods

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

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

Defined in Codec.Winery

Methods

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

class GDecodeVariant f

Minimal complete definition

variantDecoder

Instances

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

Defined in Codec.Winery

Methods

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

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

Defined in Codec.Winery

Methods

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

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

Defined in Codec.Winery

Methods

variantDecoder :: Int -> Int -> 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 :: 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

class GEncodeProduct f

Encode all the fields

Minimal complete definition

productEncoder

Instances

GEncodeProduct (U1 :: k -> Type)

Defined in Codec.Winery

Methods

productEncoder :: U1 x -> Builder

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

Defined in Codec.Winery

Methods

productEncoder :: D1 c f x -> Builder

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

Defined in Codec.Winery

Methods

productEncoder :: C1 c f x -> Builder

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

Defined in Codec.Winery

Methods

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

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

Defined in Codec.Winery

Methods

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

class GDecodeProduct f

Minimal complete definition

productDecoder

Instances

GDecodeProduct (U1 :: k -> Type)

Defined in Codec.Winery

Methods

productDecoder :: Decoder (U1 x)

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

Defined in Codec.Winery

Methods

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

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

Defined in Codec.Winery

Methods

productDecoder :: Decoder (K1 i a x)

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

Defined in Codec.Winery

Methods

productDecoder :: Decoder (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.

decodeCurrentDefault :: forall a. Serialise a => Decoder a

decodeCurrent in terms of extractor; note that it's very slow.

Bundles

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

Preset schema

bootstrapSchema :: Word8 -> Either WineryException Schema

Obtain the schema of the schema corresponding to the specified version.