A Serializer describes the injective conversion between types a and b. In plain English, this means that you can go from a to b, and you can Maybe go from b back to a. This is often used to serialize events to an event store, and then deserialize them back.

Simple constructor to just use deserialize to construct deserializeEither.

Apply an intermediate Serializer to a serializer to go from type a to c with b in the middle. Note that with deserializing, if the conversion from c to b or from b to a fails, the whole deserialization fails.

Simple "serializer" using id. Useful for when an API requires a serializer but you don't need to actually change types.

A Serializer for aeson Values.

A Serializer to convert JSON to/from lazy text. Useful for Sql event stores that store JSON values as text.

A Serializer for Dynamic values using toDyn and fromDynamic.

Wraps an EventStore and transparently serializes/deserializes events for you. Note that in this implementation deserialization errors when using getEvents are simply ignored (the event is not returned).

Like serializedEventStore except for GloballyOrderedEventStore.

This is a type class for serializing sum types of events to Dynamic without the associated constructor. This is useful when transforming between two sum types of events. A common pattern is to put all the events in an application in one big event sum type, and then have a smaller sum type for each Projection. Then, you can use eventSumTypeSerializer to transform between the two.

It is meant to be derived with Generic. For example:

   data EventA = EventA deriving (Show)
   data EventB = EventB deriving (Show)
   data EventC = EventC deriving (Show)

   data AllEvents
     = AllEventsEventA EventA
     | AllEventsEventB EventB
     | AllEventsEventC EventC
     deriving (Show, Generic)

   instance EventSumType AllEvents

   data MyEvents
     = MyEventsEventA EventA
     | MyEventsEventB EventB
     deriving (Show, Generic)

   instance EventSumType MyEvents

Now we can serialize to Dynamic without a constructor tag:

>>> eventToDyn (MyEventsEventA EventA)
<<EventA>>

We can also go from a MyEvents value to an AllEvents value:

>>> eventFromDyn (eventToDyn (MyEventsEventA EventA)) :: Maybe AllEvents
Just (AllEventsEventA EventA)

A Serializer from one EventSumType instance to another. WARNING: If not all events in the source EventSumType are in the serialized EventSumType, then this function will be partial!