Data.Codec.Argonaut.Common

either :: forall a b. JsonCodec a -> JsonCodec b -> JsonCodec (Either a b)

A codec for Either values.

foreignObject :: forall a. JsonCodec a -> JsonCodec (Object a)

A codec for StrMap values.

Encodes as an array of two-element key/value arrays in JSON.

list :: forall a. JsonCodec a -> JsonCodec (List a)

A codec for List values.

Encodes as an array in JSON.

map :: forall a b. Ord a => JsonCodec a -> JsonCodec b -> JsonCodec (Map a b)

A codec for Map values.

Encodes as an array of two-element key/value arrays in JSON.

maybe :: forall a. JsonCodec a -> JsonCodec (Maybe a)

A codec for Maybe values.

NOTE: This is not suitable to en/decode null values. If you need these kinds of codecs, look into Data.Codec.Argonaut.Compat

tuple :: forall a b. JsonCodec a -> JsonCodec b -> JsonCodec (Tuple a b)

A codec for Tuple values.

Encodes as a two-element array in JSON.

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

type JsonCodec a = BasicCodec (Either JsonDecodeError) Json a

Codec type for Json values.

type JPropCodec a = Codec (Either JsonDecodeError) (Object Json) (List (Tuple String Json)) a a

Codec type for JObject prop/value pairs.

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

Codec type for specifically indexed JArray elements.

string :: JsonCodec String

A codec for String values in Json.

recordProp :: forall proxy p a r r'. IsSymbol p => Cons p a r r' => proxy 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.

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, to encode a record as the JSON object { "name": "Karl", "age": 25 } we would define a codec like this:

import Data.Codec.Argonaut as CA
import Type.Proxy (Proxy(..))

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

codecPerson ∷ CA.JsonCodec Person
codecPerson =
  CA.object "Person" $ CA.record
    # CA.recordProp (Proxy :: _ "name") CA.string
    # CA.recordProp (Proxy :: _ "age") CA.int

See also Data.Codec.Argonaut.Record.object for a more commonly useful version of this function.

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

A codec for a property of an object.

printJsonDecodeError :: JsonDecodeError -> String

Prints a JsonDecodeError as a somewhat readable error message.

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

A codec for objects that are encoded with specific properties.

See also Data.Codec.Argonaut.Record.object for a more commonly useful version of this function.

number :: JsonCodec Number

A codec for Number values in Json.

null :: JsonCodec Unit

A codec for null values in Json.

json :: JsonCodec Json

The "identity codec" for Json values.

jobject :: JsonCodec (Object Json)

A codec for JObject values in Json.

jarray :: JsonCodec (Array Json)

A codec for Array Json 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.

int :: JsonCodec Int

A codec for Int values in Json.

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

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

For example, if we'd like to encode a Person as a 2-element array, like ["Rashida", 37], we could write the following codec:

import Data.Codec ((~))
import Data.Codec.Argonaut as CA

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

codecPerson ∷ CA.JsonCodec Person
codecPerson = CA.indexedArray "Test Object" $
  { name: _, age: _ }
    <$> _.name ~ CA.index 0 CA.string
    <*> _.age ~ CA.index 1 CA.int

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

A codec for an item in an indexedArray.

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

Helper function for defining recursive codecs in situations where the codec definition causes a "The value of <codec> is undefined here" error.

import Data.Codec.Argonaut as CA
import Data.Codec.Argonaut.Common as CAC
import Data.Codec.Argonaut.Record as CAR
import Data.Maybe (Maybe)
import Data.Newtype (class Newtype)
import Data.Profunctor (wrapIso)

newtype IntList = IntList { cell ∷ Int, rest ∷ Maybe IntList }

derive instance newtypeLoopyList ∷ Newtype IntList _

codecIntList ∷ CA.JsonCodec IntList
codecIntList =
  CA.fix \codec →
    wrapIso IntList $
      CAR.object "IntList" { cell: CA.int, rest: CAC.maybe codec }

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

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

char :: JsonCodec Char

A codec for Char values in Json.

boolean :: JsonCodec Boolean

A codec for Boolean values in Json.

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

A codec for arbitrary length Arrays where every item in the array shares the same type.

import Data.Codec.Argonaut as CA

codecIntArray ∷ CA.JsonCodec (Array Int)
codecIntArray = CA.array CA.int

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

GCodec is defined as a Profunctor so that lcmap 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)