Waargonaut.Encode

Types and functions to encode your data types to Json.

Encoder type

newtype Encoder f a

Define an "encoder" as a function from some a to some Json with the allowance for some context f.

Constructors

Encoder (a -> f Json)

Instances

Contravariant (Encoder f)

Defined in Waargonaut.Encode

Methods

contramap :: (a -> b) -> Encoder f b -> Encoder f a

(>$) :: b -> Encoder f b -> Encoder f a

MFunctor Encoder

Defined in Waargonaut.Encode

Methods

hoist :: Monad m => (forall a. m a -> n a) -> Encoder m b -> Encoder n b

Wrapped (Encoder f a)

Defined in Waargonaut.Encode

Associated Types

type Unwrapped (Encoder f a) :: *

Methods

_Wrapped' :: Iso' (Encoder f a) (Unwrapped (Encoder f a))

Encoder f a ~ t => Rewrapped (Encoder f a) t

Defined in Waargonaut.Encode

type Unwrapped (Encoder f a)

Defined in Waargonaut.Encode

type Unwrapped (Encoder f a) = a -> f Json

type Encoder' = Encoder Identity

As a convenience, this type is a pure Encoder over Identity in place of the f.

Creation

encodeA :: (a -> f Json) -> Encoder f a

Create an Encoder' for a by providing a function from 'a -> f Json'.

encodePureA :: (a -> Json) -> Encoder' a

As encodeA but specialised to Identity when the additional flexibility isn't needed.

Runners

runPureEncoder :: Encoder' a -> a -> Json

Run the given Encoder to produce a lazy ByteString.

runEncoder :: Encoder f a -> a -> f Json

Run this Encoder to convert the a to Json

simpleEncodeNoSpaces :: Applicative f => Encoder f a -> a -> f ByteString

Encode an a directly to a ByteString using the provided Encoder.

simplePureEncodeNoSpaces :: Encoder' a -> a -> ByteString

As per simpleEncodeNoSpaces but specialised the f to Identity and remove it.

Provided encoders

int :: Applicative f => Encoder f Int

Encode an Int

integral :: (Applicative f, Integral n) => Encoder f n

Encode a numeric value of the typeclass Integral

scientific :: Applicative f => Encoder f Scientific

Encode an Scientific

bool :: Applicative f => Encoder f Bool

Encode a Bool

text :: Applicative f => Encoder f Text

Encode a Text

null :: Applicative f => Encoder f ()

Encode an explicit null.

either :: Encoder f a -> Encoder f b -> Encoder f (Either a b)

Encode an Either value using the given Encoders

maybe :: Encoder f () -> Encoder f a -> Encoder f (Maybe a)

Encode a Maybe value, using the provided Encoder's to handle the different choices.

maybeOrNull :: Applicative f => Encoder f a -> Encoder f (Maybe a)

Encode a 'Maybe a' to either 'Encoder a' or null

traversable :: (Applicative f, Traversable t) => Encoder f a -> Encoder f (t a)

Encode some Traversable of a into a JSON array.

list :: Applicative f => Encoder f a -> Encoder f [a]

Encode a list

nonempty :: Applicative f => Encoder f a -> Encoder f (NonEmpty a)

Encode a NonEmpty list

mapToObj :: Applicative f => Encoder f a -> (k -> Text) -> Encoder f (Map k a)

Encode a Map in a JSON object.

json :: Applicative f => Encoder f Json

Encoder' for a Waargonaut Json data structure

prismE :: Prism' a b -> Encoder f a -> Encoder f b

Build an Encoder using a Prism'

Object encoder helpers

mapLikeObj :: (AsJType Json ws a, Monoid ws, Semigroup ws, Applicative f) => (i -> MapLikeObj ws a -> MapLikeObj ws a) -> Encoder f i

Apply a function to update a MapLikeObj and encode that as a JSON object.

For example, given the following data type:

data Image = Image
  { _imageW        :: Int
  , _imageH        :: Int
  , _imageTitle    :: Text
  , _imageAnimated :: Bool
  , _imageIDs      :: [Int]
  }

We can use this function to create an encoder, composing the individual update functions to set the keys and values as desired.

encodeImage :: Applicative f => Encoder f Image
encodeImage = mapLikeObj $ \img ->
  intAt "Width" (_imageW img) .           -- ^ Set an Int value at the "Width" key.
  intAt "Height" (_imageH img) .
  textAt "Title" (_imageTitle img) .
  boolAt "Animated" (_imageAnimated img) .
  arrayAt int "IDs" (_imageIDs img) -- ^ Set an [Int] value at the "IDs" key.

atKey :: (At t, IxValue t ~ Json, Applicative f) => Index t -> Encoder f a -> a -> t -> f t

When encoding a MapLikeObj, this function lets you encode a value at a specific key

intAt :: Text -> Int -> MapLikeObj WS Json -> MapLikeObj WS Json

Encode an Int at the given Text key.

textAt :: Text -> Text -> MapLikeObj WS Json -> MapLikeObj WS Json

Encode a Text value at the given Text key.

boolAt :: Text -> Bool -> MapLikeObj WS Json -> MapLikeObj WS Json

Encode a Bool at the given Text key.

traversableAt :: (At t, Traversable f, IxValue t ~ Json) => Encoder' a -> Index t -> f a -> t -> t

Encode a Foldable of a at the given index on a JSON object.

listAt :: (At t, IxValue t ~ Json) => Encoder' a -> Index t -> [a] -> t -> t

Encode a standard Haskell list at the given index on a JSON object.

nonemptyAt :: (At t, IxValue t ~ Json) => Encoder' a -> Index t -> NonEmpty a -> t -> t

Encode a NonEmpty list at the given index on a JSON object.

encAt :: Applicative f => Encoder f b -> Text -> (a -> b) -> a -> JObject WS Json -> f (JObject WS Json)

Using a given Encoder, encode a key value pair on the JSON object, using the accessor function to retrieve the value.

keyValuesAsObj :: (Foldable g, Monad f) => g (a -> JObject WS Json -> f (JObject WS Json)) -> Encoder f a

Encode key value pairs as a JSON object, allowing duplicate keys.

onObj :: Applicative f => Text -> b -> Encoder f b -> JObject WS Json -> f (JObject WS Json)

When encoding a JSON object that may contain duplicate keys, this function works the same as the atKey function for MapLikeObj.

keyValueTupleFoldable :: (Monad f, Foldable g) => Encoder f a -> Encoder f (g (Text, a))

Encode some Foldable of (Text, a) as a JSON object. This permits duplicate keys.

Encoders specialised to Identity

int' :: Encoder' Int

As per int but with the f specialised to Identity.

integral' :: Integral n => Encoder' n

As per integral but with the f specialised to Identity.

scientific' :: Encoder' Scientific

As per scientific but with the f specialised to Identity.

bool' :: Encoder' Bool

As per bool but with the f specialised to Identity.

text' :: Encoder' Text

As per text but with the f specialised to Identity.

null' :: Encoder' ()

As per null but with the f specialised to Identity.

either' :: Encoder' a -> Encoder' b -> Encoder' (Either a b)

As per either but with the f specialised to Identity.

maybe' :: Encoder' () -> Encoder' a -> Encoder' (Maybe a)

As per maybe but with the f specialised to Identity.

maybeOrNull' :: Encoder' a -> Encoder' (Maybe a)

As per maybeOrNull but with the f specialised to Identity.

traversable' :: Traversable t => Encoder' a -> Encoder' (t a)

As per traversable but with the f specialised to Identity.

nonempty' :: Encoder' a -> Encoder' (NonEmpty a)

As per nonempty but with the f specialised to Identity.

list' :: Encoder' a -> Encoder' [a]

As per list but with the f specialised to Identity.

atKey' :: (At t, IxValue t ~ Json) => Index t -> Encoder' a -> a -> t -> t

Encode an a at the given index on the JSON object.

mapLikeObj' :: (AsJType Json ws a, Semigroup ws, Monoid ws) => (i -> MapLikeObj ws a -> MapLikeObj ws a) -> Encoder' i

As per mapLikeObj but specialised for Identity as the Applicative.

mapToObj' :: Encoder' a -> (k -> Text) -> Encoder' (Map k a)

Using the given function to convert the k type keys to a Text value, encode a Map as a JSON object.

keyValuesAsObj' :: (Foldable g, Functor g) => g (a -> JObject WS Json -> JObject WS Json) -> Encoder' a

As per keyValuesAsObj but with the f specialised to Identity.

json' :: Encoder' Json

As per json but with the f specialised to Identity.

generaliseEncoder' :: Monad f => Encoder' a -> Encoder f a

Generalise an Encoder a' to 'Encoder f a'