Data.Codec.Argonaut

type JsonCodec a = BasicCodec (Either JsonDecodeError) Json a

Codec type for Json values.

data JsonDecodeError

Error type for failures while decoding.

Constructors

• TypeMismatch String
• UnexpectedValue Json
• AtIndex Int JsonDecodeError
• AtKey String JsonDecodeError
• Named String JsonDecodeError
• MissingValue

Instances

• Eq JsonDecodeError
• Ord JsonDecodeError
• Generic JsonDecodeError _
• Show JsonDecodeError

printJsonDecodeError :: JsonDecodeError -> String

Prints a JsonDecodeError as a somewhat readable error message.

json :: JsonCodec Json

The "identity codec" for Json values.

null :: JsonCodec JNull

A codec for null values in Json.

boolean :: JsonCodec Boolean

A codec for Boolean values in Json.

number :: JsonCodec Number

A codec for Number values in Json.

int :: JsonCodec Int

A codec for Int values in Json.

string :: JsonCodec String

A codec for String values in Json.

char :: JsonCodec Char

A codec for Char values in Json.

void :: JsonCodec Void

A codec for Void values.

jarray :: JsonCodec JArray

A codec for a JArray values in Json. This does not decode the values of the array, for that use array for a general array decoder, or indexedArray with index to decode fixed length array encodings.

jobject :: JsonCodec JObject

A codec for JObject values in Json.

array :: forall a. JsonCodec a -> JsonCodec (Array a)

A codec for Array values.

decodeIntArray ∷ Json → Either JsonDecodeError (Array Int)
decodeIntArray = decode (array int)

type JIndexedCodec a = Codec (Either JsonDecodeError) JArray (List Json) a a

Codec type for specifically indexed JArray elements.

indexedArray :: forall a. String -> JIndexedCodec a -> JsonCodec a

A codec for types that are encoded as an array with a specific layout.

For example, given that we'd like to encode a Person as a 2-element array, like so [ "Karl", 25 ], we could write the following codec:

type Person = { name ∷ String, age ∷ Int }

JA.indexedArray "Test Object" $
  { name: _, age: _ }
    <$> _.name ~ index 0 JA.string
    <*> _.age ~ index 1 JA.int

index :: forall a. Int -> JsonCodec a -> JIndexedCodec a

A codec for an item in an indexedArray.

type JPropCodec a = Codec (Either JsonDecodeError) JObject (List JAssoc) a a

Codec type for JObject prop/value pairs.

object :: forall a. String -> JPropCodec a -> JsonCodec a

A codec for objects that are encoded with specific properties.

prop :: forall a. String -> JsonCodec a -> JPropCodec a

A codec for a property of an object.

record :: JPropCodec (Record ())

The starting value for a object-record codec. Used with recordProp it provides a convenient method for defining codecs for record types that encode into JSON objects of the same shape.

For example:

myRecordCodec =
  object "MyRecord" $ record
    # recordProp (SProxy :: SProxy "tag") tagCodec
    # recordProp (SProxy :: SProxy "value") valueCodec

recordProp :: forall r' r a p. IsSymbol p => RowCons p a r r' => SProxy p -> JsonCodec a -> JPropCodec (Record r) -> JPropCodec (Record r')

Used with record to define codecs for record types that encode into JSON objects of the same shape. See the comment on record for an example.

fix :: forall a. (JsonCodec a -> JsonCodec a) -> JsonCodec a

Helper function for defining recursive codecs.

prismaticCodec :: forall b a. (a -> Maybe b) -> (b -> a) -> JsonCodec a -> JsonCodec b

Adapts an existing codec with a pair of functions to allow a value to be further refined. If the inner decoder fails an UnexpectedValue error will be raised for JSON input.

This function is named as such as the pair of functions it accepts correspond with the preview and view functions of a Prism-style lens.

For example, in order to parse a mapping from an enum to strings, which doesn't match up nicely with Data.Codec.Argonaut.Sum.enumSum we can use prismaticCodec:

data Direction = North | South | West | East

directionCodec :: JsonCodec Direction
directionCodec = prismaticCodec dec enc string
  where
    dec = case _ of
      "N" -> Just North
      "S" -> Just South
      "W" -> Just West
      "E" -> Just East
      _ -> Nothing

    enc = case _ of
      North -> "N"
      South -> "S"
      West -> "W"
      East -> "E"

encode :: forall d c b a m. Codec m a b c d -> c -> b

decode :: forall d c b a m. Codec m a b c d -> a -> m d

Operator alias for Data.Profunctor.lmap (left-associative / precedence 5)

GCodec is defined as a Profunctor so that lmap can be used to target specific fields when defining a codec for a product type. This operator is a convenience for that:

tupleCodec =
  Tuple
    <$> fst ~ fstCodec
    <*> snd ~ sndCodec

Operator alias for Data.Codec.composeCodec (right-associative / precedence 8)