Module

Codec.Json.Unidirectional.Value

Package: purescript-json-codecs
Repository: jordanmartinez/purescript-json-codecs

Unidirectional, value-based JSON codecs. This module should be imported using a qualified J or Json alias:

import Codec.Json.Unidirectional.Value as J
import Codec.Json.Unidirectional.Value as Json

thereby causing to* and from* code to read like so:

J.fromInt/Json.fromInt, which reads "encode an Int to Json"
J.toInt/Json.toInt, which reads "decode JSON to an Int"

#DecodeError Source

data DecodeError

An error type that

includes path-to-json information
allows for custom decode messages
can accumulate errors at the same path location

Constructors

AtKey String DecodeError
AtIndex Int DecodeError
DecodeError String
AccumulateError (NonEmptyList DecodeError)
Stores a reversed list of errors that happened at the same path. The error at head happened AFTER the errors in tail.

Instances

#accumulateErrors Source

accumulateErrors :: DecodeError -> DecodeError -> DecodeError

Prefer to use altAccumulate or altAccumulateLazy. The first error arg is assumed to have happened before the second error arg.

#altAccumulate Source

altAccumulate :: forall a. (Json -> Either DecodeError a) -> (Json -> Either DecodeError a) -> Json -> Either DecodeError a

Tries the first codec. If it fails, tries the second codec. If it fails, errors from both are accumulated. Succeeds if either of the two codecs succeed.

#altAccumulateLazy Source

altAccumulateLazy :: forall a. Either DecodeError a -> (Unit -> Either DecodeError a) -> Either DecodeError a

Tries the first codec. If it fails, tries the second codec. If it fails, errors from both are accumulated. Succeeds if either of the two codecs succeed.

#printDecodeError Source

printDecodeError :: DecodeError -> String

Pretty-prints the decode error over a multi-line string. Assumes that all keys, hints, and decode error messages are single-line Strings. Indents using two spaces.

#unsafePrintDecodeError Source

unsafePrintDecodeError :: Boolean -> Int -> String -> String -> DecodeError -> String

Unsafe because no checking is done on the Int arg to determine if it's >=1 nor whether applyIndent makes sense in the given context.

Fully control whether we should apply the indent to the next line of content, how much to indent each error in AccumulateError, and what to use as a "tab"-like string sequence. Assumes that all keys, hints, and decode error messages are single-line Strings.

#coerce1 Source

coerce1 :: forall n a. Coercible n a => (a -> n) -> Either DecodeError a -> Either DecodeError n

#FromPrimitive Source

class FromPrimitive a  where

Indicates which values are primitive JSON values that can be encoded via unsafeCoerce.

Members

fromPrimitive :: a -> Json
Shortcut encoder for encoding primitive JSON values.

Instances

FromPrimitive Boolean
FromPrimitive Number
FromPrimitive String
(FromPrimitive a) => FromPrimitive (Array a)
(FromPrimitive a) => FromPrimitive (Object a)
(RowToList rows rl, AllPrimitive rl) => FromPrimitive (Record rows)
(Fail (Beside (Text "Expected a primitive JSON type but got type: ") (Quote a))) => FromPrimitive a

#AllPrimitive Source

class AllPrimitive :: RowList Type -> Constraintclass AllPrimitive rl

Utility class that distinguishes which records are primitive and which are not. Used in FromPrimitive.

Instances

AllPrimitive Nil
(AllPrimitive tail, FromPrimitive a) => AllPrimitive (Cons sym a tail)

#fromVoid Source

fromVoid :: Void -> Json

#toVoid Source

toVoid :: Json -> Either DecodeError Void

#fromJNull Source

fromJNull :: Json

#fromNull Source

fromNull :: forall a. a -> Json

#toJNull Source

toJNull :: Json -> Either DecodeError Unit

#fromUnit Source

fromUnit :: Unit -> Json

#toNullDefaultOrA Source

toNullDefaultOrA :: forall a. a -> (Json -> Either DecodeError a) -> Json -> Either DecodeError a

#fromNullNothingOrJust Source

fromNullNothingOrJust :: forall a. (a -> Json) -> Maybe a -> Json

#toNullNothingOrJust Source

toNullNothingOrJust :: forall a. (Json -> Either DecodeError a) -> Json -> Either DecodeError (Maybe a)

#fromNullable Source

fromNullable :: forall a. (a -> Json) -> Nullable a -> Json

#toNullable Source

toNullable :: forall a. (Json -> Either DecodeError a) -> Json -> Either DecodeError (Nullable a)

#fromBoolean Source

fromBoolean :: Boolean -> Json

#toBoolean Source

toBoolean :: Json -> Either DecodeError Boolean

#fromNumber Source

fromNumber :: Number -> Json

#toNumber Source

toNumber :: Json -> Either DecodeError Number

#fromInt Source

fromInt :: Int -> Json

#toInt Source

toInt :: Json -> Either DecodeError Int

#fromString Source

fromString :: String -> Json

#toString Source

toString :: Json -> Either DecodeError String

#fromChar Source

fromChar :: Char -> Json

#toChar Source

toChar :: Json -> Either DecodeError Char

#fromCodePoint Source

fromCodePoint :: CodePoint -> Json

#toCodePoint Source

toCodePoint :: Json -> Either DecodeError CodePoint

#fromNonEmptyString Source

fromNonEmptyString :: NonEmptyString -> Json

#toNonEmptyString Source

toNonEmptyString :: Json -> Either DecodeError NonEmptyString

#fromJArray Source

fromJArray :: Array Json -> Json

#toJArray Source

toJArray :: Json -> Either DecodeError (Array Json)

#underIndex Source

underIndex :: forall a. Int -> (Json -> Either DecodeError a) -> Array Json -> Either DecodeError a

#fromArray Source

fromArray :: forall a. (a -> Json) -> Array a -> Json

#toArray Source

toArray :: forall a. (Json -> Either DecodeError a) -> Json -> Either DecodeError (Array a)

#fromArray2 Source

fromArray2 :: Json -> Json -> Json

#toArray2 Source

toArray2 :: forall a b x. (Json -> Either DecodeError a) -> (Json -> Either DecodeError b) -> (a -> b -> x) -> Json -> Either DecodeError x

#fromArray3 Source

fromArray3 :: Json -> Json -> Json -> Json

#toArray3 Source

toArray3 :: forall a b c x. (Json -> Either DecodeError a) -> (Json -> Either DecodeError b) -> (Json -> Either DecodeError c) -> (a -> b -> c -> x) -> Json -> Either DecodeError x

#fromArray4 Source

fromArray4 :: Json -> Json -> Json -> Json -> Json

#toArray4 Source

toArray4 :: forall a b c d x. (Json -> Either DecodeError a) -> (Json -> Either DecodeError b) -> (Json -> Either DecodeError c) -> (Json -> Either DecodeError d) -> (a -> b -> c -> d -> x) -> Json -> Either DecodeError x

#fromArray5 Source

fromArray5 :: Json -> Json -> Json -> Json -> Json -> Json

#toArray5 Source

toArray5 :: forall a b c d e x. (Json -> Either DecodeError a) -> (Json -> Either DecodeError b) -> (Json -> Either DecodeError c) -> (Json -> Either DecodeError d) -> (Json -> Either DecodeError e) -> (a -> b -> c -> d -> e -> x) -> Json -> Either DecodeError x

#fromNonEmptyArray Source

fromNonEmptyArray :: forall a. (a -> Json) -> NonEmptyArray a -> Json

#toNonEmptyArray Source

toNonEmptyArray :: forall a. (Json -> Either DecodeError a) -> Json -> Either DecodeError (NonEmptyArray a)

#fromJObject Source

fromJObject :: Object Json -> Json

#toJObject Source

toJObject :: Json -> Either DecodeError (Object Json)

#underKey Source

underKey :: forall a. String -> (Json -> Either DecodeError a) -> Object Json -> Either DecodeError a

#fromObject Source

fromObject :: forall a. (a -> Json) -> Object a -> Json

#toObject Source

toObject :: forall a. (Json -> Either DecodeError a) -> Json -> Either DecodeError (Object a)

#fromObjSingleton Source

fromObjSingleton :: String -> Json -> Json

#toObjSingleton Source

toObjSingleton :: forall a. String -> (Json -> Either DecodeError a) -> Json -> Either DecodeError a

#fromPropArray Source

fromPropArray :: Array (Tuple String Json) -> Json

#fromIdentity Source

fromIdentity :: forall a. (a -> Json) -> Identity a -> Json

#toIdentity Source

toIdentity :: forall a. (Json -> Either DecodeError a) -> Json -> Either DecodeError (Identity a)

#fromMaybeTagged Source

fromMaybeTagged :: forall a. (a -> Json) -> Maybe a -> Json

#toMaybeTagged Source

toMaybeTagged :: forall a. (Json -> Either DecodeError a) -> Json -> Either DecodeError (Maybe a)

#fromEitherTagged Source

fromEitherTagged :: forall a b. (a -> Json) -> (b -> Json) -> Either a b -> Json

#toEitherTagged Source

toEitherTagged :: forall a b. (Json -> Either DecodeError a) -> (Json -> Either DecodeError b) -> Json -> Either DecodeError (Either a b)

#fromEitherSingle Source

fromEitherSingle :: forall a b. (a -> Json) -> (b -> Json) -> Either a b -> Json

#toEitherSingle Source

toEitherSingle :: forall a b. (Json -> Either DecodeError a) -> (Json -> Either DecodeError b) -> Json -> Either DecodeError (Either a b)

#fromTuple Source

fromTuple :: forall a b. (a -> Json) -> (b -> Json) -> Tuple a b -> Json

#toTuple Source

toTuple :: forall a b. (Json -> Either DecodeError a) -> (Json -> Either DecodeError b) -> Json -> Either DecodeError (Tuple a b)

#fromThese Source

fromThese :: forall a b. (a -> Json) -> (b -> Json) -> These a b -> Json

#toThese Source

toThese :: forall a b. (Json -> Either DecodeError a) -> (Json -> Either DecodeError b) -> Json -> Either DecodeError (These a b)

#fromNonEmpty Source

fromNonEmpty :: forall f a. (a -> Json) -> (f a -> Json) -> NonEmpty f a -> Json

#toNonEmpty Source

toNonEmpty :: forall g a. (Json -> Either DecodeError a) -> (Json -> Either DecodeError (g a)) -> (Json -> Either DecodeError (NonEmpty g a))

#fromList Source

fromList :: forall a. (a -> Json) -> List a -> Json

#toList Source

toList :: forall a. (Json -> Either DecodeError a) -> Json -> Either DecodeError (List a)

#fromNonEmptyList Source

fromNonEmptyList :: forall a. (a -> Json) -> (NonEmptyList a -> Json)

#toNonEmptyList Source

toNonEmptyList :: forall a. (Json -> Either DecodeError a) -> Json -> Either DecodeError (NonEmptyList a)

#fromMap Source

fromMap :: forall k v. (k -> Json) -> (v -> Json) -> Map k v -> Json

#toMap Source

toMap :: forall k v. Ord k => (Json -> Either DecodeError k) -> (Json -> Either DecodeError v) -> Json -> Either DecodeError (Map k v)

#fromSet Source

fromSet :: forall a. (a -> Json) -> Set a -> Json

#toSet Source

toSet :: forall a. Ord a => (Json -> Either DecodeError a) -> Json -> Either DecodeError (Set a)

#fromNonEmptySet Source

fromNonEmptySet :: forall a. (a -> Json) -> NonEmptySet a -> Json

#toNonEmptySet Source

toNonEmptySet :: forall a. Ord a => (Json -> Either DecodeError a) -> Json -> Either DecodeError (NonEmptySet a)

#fromRecord Source

fromRecord :: forall codecs values codecsRL. RowToList codecs codecsRL => FromRecordPropArray codecsRL (Record codecs) (Record values) => Record codecs -> Record values -> Json

All labels must have a value of type FromProp a, which can be obtained via functions like fromRequired* and fromOption* or by defining a value yourself. Otherwise, you will get a compiler error:

fromRecord
  { label: fromRequired $ fromInt 
  , psName: fromRequiredRename "jsonName" fromInt
  , optionalDisappears: fromOption $ fromInt
  , optionalStillThere: fromOption $ fromInt
  }
  { label: 1
  , psName: Just 2
  , optionalDisappears: Nothing
  , optionalStillThere: Just 3
  }

produces the following JSON

{ "label": 1
, "jsonName": 2
, "optionalStillThere": 3
}

#toRecord Source

toRecord :: forall codecs values codecsRL. RowToList codecs codecsRL => ToRecordObj codecsRL (Record codecs) (Record values) => Record codecs -> Json -> Either DecodeError (Record values)

All labels must have a value of type ToProp a, which can be obtained via functions like toRequired* and toOption* or by defining a value yourself. Otherwise, you will get a compiler error:

The following JSON and codec...

toRecord
  { label: toRequired toInt 
  , psName: toRequiredRename "jsonName" toInt
  , optionalAppears: toOption toInt
  , optionalAlwaysThere: toOption toInt
  }
  $ either (\_ -> unsafeCrashWith "error") identity
  $ jsonParser
  """{ "label": 1
     , "jsonName": 2
     , "optionalAlwaysThere": 3
     }"""

...produces the following value

  { label: 1
  , psName: Just 2
  , optionalAppears: Nothing
  , optionalAlwaysThere: Just 3
  }

#fromRecordN Source

fromRecordN :: forall n codecs values codecsRL. RowToList codecs codecsRL => FromRecordPropArray codecsRL (Record codecs) (Record values) => Newtype n (Record values) => (Record values -> n) -> Record codecs -> n -> Json

Same as fromRecord but handles the Newtype for you so you don't need to add a type annotation to help type inference.

#toRecordN Source

toRecordN :: forall n codecs values codecsRL. RowToList codecs codecsRL => ToRecordObj codecsRL (Record codecs) (Record values) => Newtype n (Record values) => (Record values -> n) -> Record codecs -> Json -> Either DecodeError n

Same as toRecord but handles the Newtype for you.

#FromProp Source

newtype FromProp a

Converts a value associated with the record label into a JSON value associated with the given label in the JSON object.

On Nothing, the key-value pair is not added to the JSON object. On Just, both the JSON-encoded value and the key to use in the JSON object is provided.

key: on Nothing, the label associated with the record is used; on Just, the provided key is used
insertionOrder: controls the order of the keys' appearance in the JSON object with lower values (e.g. 1) appearing before larger values (e.g. 100). When order is the same, reverts to alphabetical ordering. Key order is computed via fromMaybe top insertionOrder.
value: the JSON value to use for the key

Constructors

FromProp (a -> Maybe { insertionOrder :: Maybe Int, key :: Maybe String, value :: Json })

Instances

(FromRecordPropArray codecTail (Record cRest) (Record vRest), IsSymbol sym, Cons sym (FromProp a) cRest codecs, Cons sym a vRest values) => FromRecordPropArray (Cons sym (FromProp a) codecTail) (Record codecs) (Record values)

#ToProp Source

newtype ToProp a

Converts a value in a JSON object into a value associated with the record label.

Explanation of arguments

String -> Maybe Json: Looks up the provided key in the object. Implemented via \str -> Object.lookup str obj
String -> the label of the record

Constructors

ToProp (Fn2 (String -> Maybe Json) String (Either DecodeError a))

Instances

(ToRecordObj codecTail (Record cRest) (Record vRest), IsSymbol sym, Cons sym (ToProp a) cRest codecs, Cons sym a vRest values, Lacks sym vRest) => ToRecordObj (Cons sym (ToProp a) codecTail) (Record codecs) (Record values)

#toStatic Source

toStatic :: forall a. a -> ToProp a

#fromRequired Source

fromRequired :: forall a. (a -> Json) -> FromProp a

#fromRequired' Source

fromRequired' :: forall a. Int -> (a -> Json) -> FromProp a

#toRequired Source

toRequired :: forall a. (Json -> Either DecodeError a) -> ToProp a

#fromRequiredRename Source

fromRequiredRename :: forall a. String -> (a -> Json) -> FromProp a

#fromRequiredRename' Source

fromRequiredRename' :: forall a. Int -> String -> (a -> Json) -> FromProp a

#toRequiredRename Source

toRequiredRename :: forall a. String -> (Json -> Either DecodeError a) -> ToProp a

#fromOption Source

fromOption :: forall a. (a -> Json) -> FromProp (Maybe a)

If Nothing, does not add the coressponding key If Just, adds the key and the encoded value to the JObject

#fromOption' Source

fromOption' :: forall a. Int -> (a -> Json) -> FromProp (Maybe a)

#toOption Source

toOption :: forall a. (Json -> Either DecodeError a) -> ToProp (Maybe a)

Succeeds with Nothing if key wasn't found or with Just if key was found and value was succesfully tod.

#fromOptionRename Source

fromOptionRename :: forall a. String -> (a -> Json) -> FromProp (Maybe a)

#fromOptionRename' Source

fromOptionRename' :: forall a. Int -> String -> (a -> Json) -> FromProp (Maybe a)

#toOptionRename Source

toOptionRename :: forall a. String -> (Json -> Either DecodeError a) -> ToProp (Maybe a)

#toOptionDefault Source

toOptionDefault :: forall a. a -> (Json -> Either DecodeError a) -> ToProp a

#toOptionDefaultRename Source

toOptionDefaultRename :: forall a. String -> a -> (Json -> Either DecodeError a) -> ToProp a

#fromOptionArray Source

fromOptionArray :: forall a. (a -> Json) -> FromProp (Array a)

#fromOptionArray' Source

fromOptionArray' :: forall a. Int -> (a -> Json) -> FromProp (Array a)

#toOptionArray Source

toOptionArray :: forall a. (Json -> Either DecodeError a) -> ToProp (Array a)

#fromOptionAssocArray Source

fromOptionAssocArray :: forall a b. (a -> String) -> (b -> Json) -> FromProp (Array (Tuple a b))

#fromOptionAssocArray' Source

fromOptionAssocArray' :: forall a b. Int -> (a -> String) -> (b -> Json) -> FromProp (Array (Tuple a b))

#toOptionAssocArray Source

toOptionAssocArray :: forall a b. (String -> Either DecodeError a) -> (Json -> Either DecodeError b) -> ToProp (Array (Tuple a b))

#ToRecordObj Source

class ToRecordObj :: RowList Type -> Type -> Type -> Constraintclass ToRecordObj codecsRL codecs values | codecsRL -> codecs values where

Members

toRecordObj :: Proxy codecsRL -> codecs -> Object Json -> Either DecodeError values

Instances

ToRecordObj Nil (Record ()) (Record ())
(ToRecordObj codecTail (Record cRest) (Record vRest), IsSymbol sym, Cons sym (ToProp a) cRest codecs, Cons sym a vRest values, Lacks sym vRest) => ToRecordObj (Cons sym (ToProp a) codecTail) (Record codecs) (Record values)
(Fail (Above (Beside (Beside (Text "Expected \'ToProp a\' for label \'") (Text sym)) (Beside (Text "\' but got type: ") (Quote a))) (Above (Text "") (Text "User likely forgot to supply an additional argument or is not using `toRequired*`/`toOption*` variants.")))) => ToRecordObj (Cons sym a codecTail) (Record codecs) (Record values)

#FromRecordPropArray Source

class FromRecordPropArray :: RowList Type -> Type -> Type -> Constraintclass FromRecordPropArray codecsRL codecs values | codecsRL -> codecs values where

Members

fromRecordPropArray :: Proxy codecsRL -> codecs -> values -> Array { insertionOrder :: Int, key :: String, value :: Json }

Instances

FromRecordPropArray Nil (Record ()) (Record ())
(FromRecordPropArray codecTail (Record cRest) (Record vRest), IsSymbol sym, Cons sym (FromProp a) cRest codecs, Cons sym a vRest values) => FromRecordPropArray (Cons sym (FromProp a) codecTail) (Record codecs) (Record values)
(Fail (Above (Beside (Beside (Text "Expected \'FromProp a\' for label \'") (Text sym)) (Beside (Text "\' but got type: ") (Quote a))) (Above (Text "") (Text "User likely forgot to supply an additional argument or is not using `fromRequired*`/`fromOption*` variants.")))) => FromRecordPropArray (Cons sym a codecTail) (Record codecs) (Record values)

Modules: Codec.Json.Unidirectional.Value