Json.Enc

Documentation

newtype Enc

A JSON encoder.

It is faster than going through Value, because Encoding is just a wrapper around a Bytes.Builder. But the aeson interface for Encoding is extremely bad, so let’s build a better one.

Constructors

Enc

Fields

• unEnc :: Encoding

Instances

IsString Enc

You can create an Enc any that renders an String value with OverloadedStrings.

Defined in Json.Enc

Methods

fromString :: String -> Enc

Num Enc

Defined in Json.Enc

Methods

(+) :: Enc -> Enc -> Enc

(-) :: Enc -> Enc -> Enc

(*) :: Enc -> Enc -> Enc

negate :: Enc -> Enc

abs :: Enc -> Enc

signum :: Enc -> Enc

fromInteger :: Integer -> Enc

Fractional Enc

Defined in Json.Enc

Methods

(/) :: Enc -> Enc -> Enc

recip :: Enc -> Enc

fromRational :: Rational -> Enc

IntegerLiteral Enc

You can create an Enc any that renders an Number value with an integer literal.

Defined in Json.Enc

Methods

integerLiteral :: Integer -> Enc

RationalLiteral Enc

You can create an Enc any that renders an Number value with an floating point literal.

ATTN: Bear in mind that this will crash on repeating rationals, so only use for literals in code!

Defined in Json.Enc

Methods

rationalLiteral :: Rational -> Enc

encoding :: Encoding -> Enc

Embed an Encoding verbatim (it’s a valid JSON value)

value :: Value -> Enc

Encode a Value verbatim (it’s a valid JSON value)

emptyArray :: Enc

Encode an empty Array

emptyObject :: Enc

Encode an empty Object

text :: Text -> Enc

Encode a ErrorMessage

lazyText :: Text -> Enc

Encode a lazy Text

string :: String -> Enc

Encode a Value

nullOr :: (a -> Enc) -> Maybe a -> Enc

Encode as Null if Nothing, else use the given encoder for Just a

list :: (a -> Enc) -> [a] -> Enc

Encode a list as Array

nonEmpty :: (a -> Enc) -> NonEmpty a -> Enc

Encode a NonEmpty as an Array.

object :: Foldable t => t (Text, Enc) -> Enc

Encode the given list of keys and their encoders as Object.

Like with fromList, if the list contains the same key multiple times, the last value in the list is retained:

(object [ ("foo", 42), ("foo", 23) ])
~= "{"foo":23}"

data Choice

A tag/value encoder; See choice

Constructors

Choice Text Enc

choice :: (from -> Choice) -> from -> Enc

Encode a sum type as a Choice, an object with a tag/value pair, which is the conventional json sum type representation in our codebase.

foo :: Maybe Text -> Enc
foo = choice $ case
  Nothing -> Choice "no" emptyObject ()
  Just t -> Choice "yes" text t

ex = foo Nothing == "{"tag": "no", "value": {}}"
ex2 = foo (Just "hi") == "{"tag": "yes", "value": "hi"}"

singleChoice :: Text -> Enc -> Enc

Like choice, but simply encode a single possibility into a tag/value object. This can be useful, but if you want to match on an enum, use choice instead.

map :: forall k v. Coercible k Text => (v -> Enc) -> Map k v -> Enc

Encode a Map.

We can’t really set the key to anything but text (We don’t keep the tag of Encoding) so instead we allow anything that’s coercible from text as map key (i.e. newtypes).

keyMap :: (v -> Enc) -> KeyMap v -> Enc

Encode a KeyMap

null :: Enc

Encode Null

bool :: Bool -> Enc

Encode Value

integer :: Integer -> Enc

Encode an Integer as Number. TODO: is it okay to just encode an arbitrarily-sized integer into json?

scientific :: Scientific -> Enc

Encode a Scientific as Number.

natural :: Natural -> Enc

Encode a Natural as Number.

int :: Int -> Enc

Encode an Int as Number.

int64 :: Int64 -> Enc

Encode an Int64 as Number.

utcTime :: UTCTime -> Enc

Encode UTCTime as Value, as an ISO8601 timestamp with timezone (yyyy-mm-ddThh:mm:ss[.sss]Z)

class IntegerLiteral a where

Implement this class if you want your type to only implement the part of Num that allows creating them from Integer-literals, then derive Num via NumLiteralOnly:

data Foo = Foo Integer
  deriving (Num) via (NumLiteralOnly Foo Foo)

instance IntegerLiteral Foo where
 integerLiteral i = Foo i

Methods

integerLiteral :: Integer -> a

Instances

IntegerLiteral Enc

You can create an Enc any that renders an Number value with an integer literal.

Defined in Json.Enc

Methods

integerLiteral :: Integer -> Enc

class RationalLiteral a where

The same as IntegerLiteral but for floating point literals.

Methods

rationalLiteral :: Rational -> a

Instances

RationalLiteral Enc

You can create an Enc any that renders an Number value with an floating point literal.

ATTN: Bear in mind that this will crash on repeating rationals, so only use for literals in code!

Defined in Json.Enc

Methods

rationalLiteral :: Rational -> Enc

newtype NumLiteralOnly (sym :: Symbol) num

Helper class for deriving (Num) via …, implements only literal syntax for integer and floating point numbers, and throws descriptive runtime errors for any other methods in Num.

See IntegerLiteral and RationalLiteral for examples.

Constructors

NumLiteralOnly num

Instances

(IntegerLiteral num, KnownSymbol sym) => Num (NumLiteralOnly sym num)

Defined in Json.Enc

Methods

(+) :: NumLiteralOnly sym num -> NumLiteralOnly sym num -> NumLiteralOnly sym num

(-) :: NumLiteralOnly sym num -> NumLiteralOnly sym num -> NumLiteralOnly sym num

(*) :: NumLiteralOnly sym num -> NumLiteralOnly sym num -> NumLiteralOnly sym num

negate :: NumLiteralOnly sym num -> NumLiteralOnly sym num

abs :: NumLiteralOnly sym num -> NumLiteralOnly sym num

signum :: NumLiteralOnly sym num -> NumLiteralOnly sym num

fromInteger :: Integer -> NumLiteralOnly sym num

(IntegerLiteral num, RationalLiteral num, KnownSymbol sym) => Fractional (NumLiteralOnly sym num)

Defined in Json.Enc

Methods

(/) :: NumLiteralOnly sym num -> NumLiteralOnly sym num -> NumLiteralOnly sym num

recip :: NumLiteralOnly sym num -> NumLiteralOnly sym num

fromRational :: Rational -> NumLiteralOnly sym num