The type of parsers: things which consume JSON values and produce either detailed errors or successfully parsed values (of other types).

The err type parameter is for custom validation errors; for parsers that don't produce any custom validation errors, I recommend you just stick a type variable in for full generality:

    asTuple :: Parse e (Int, Int)
    asTuple = (,) <$> nth 0 asIntegral <*> nth 1 asIntegral

The m parameter allows you to run the parser within an abitrary underlying Monad. You may want to use Parse in most cases instead, and all functions in this module work on either.

This is the standard version of ParseT over the Identity Monad, for running pure parsers.

The type of parsers which never produce custom validation errors.

Transform the error of a parser according to the given function.

An infix version of mapError.

First try the left parser, if that fails try the right. | If both fail, the error will come from the right one.

Return the current JSON Value as is. This does no error checking and thus always succeeds. You probably don't want this parser unless the JSON at the current part of your structure is truly arbitrary. You should prefer to use more specific parsers, like asText or asIntegral, where possible.

Parse a single JSON string as Text.

Parse a single JSON string as a String.

Parse a single JSON number as a Scientific.

Parse a single JSON number as any Integral type.

Parse a single JSON number as any RealFloat type.

Parse a single JSON boolean as a Bool.

Parse a single JSON null value. Useful if you want to throw an error in the case where something is not null.

Parse a JSON object, as an Object. You should prefer functions like eachInObject where possible, since they will usually generate better error messages.

Parse a JSON array, as an Array. You should prefer functions like eachInArray where possible, since they will usually generate better error messages.

Given a parser, transform it into a parser which returns Nothing when supplied with a JSON null, and otherwise, attempts to parse with the original parser; if this succeeds, the result becomes a Just value.

Take the value corresponding to a given key in the current object.

Take the value corresponding to a given key in the current object, or if no property exists with that key, use the supplied default.

Take the value corresponding to a given key in the current object, or if no property exists with that key, return Nothing .

Take the nth value of the current array.

Take the nth value of the current array, or if no value exists with that index, use the supplied default.

Take the nth value of the current array, or if no value exists with that index, return Nothing.

Attempt to parse each value in the array with the given parser, and collect the results.

Parse each property in an object with the given parser, given the key as an argument, and collect the results.

Attempt to parse each property value in the object with the given parser, and collect the results.

Attempt to parse each property in the object: parse the key with the given validation function, parse the value with the given parser, and collect the results.

Lifts a function attempting to validate an arbitrary JSON value into a parser. You should only use this if absolutely necessary; the other functions in this module will generally give better error reporting.

Prefer to use functions like key or eachInObject to this one where possible, as they will generate better error messages.

Prefer to use functions like nth or eachInArray to this one where possible, as they will generate better error messages.

Throw a custom validation error.

Prefer to use functions like key or eachInObject to this one where possible, as they will generate better error messages.

Prefer to use functions like nth or eachInArray to this one where possible, as they will generate better error messages.

Run a parser with a lazy ByteString containing JSON data. Note that the normal caveat applies: the JSON supplied must contain either an object or an array for this to work.

Run a parser with a strict ByteString containing JSON data. Note that the normal caveat applies: the JSON supplied must contain either an object or an array for this to work.

Run a parser with a pre-parsed JSON Value.

Like parse but runs the parser on an arbitrary underlying Monad.

Like parseStrict but runs the parser on an arbitrary underlying Monad.

Like parseValue but runs the parser on an arbitrary underlying Monad.

A value indicating that the JSON could not be decoded successfully.

The type of parse errors which never involve custom validation errors.

A piece of a path leading to a specific part of the JSON data. Internally, a list of these is maintained as the parser traverses the JSON data. This list is included in the error if one occurs.

Detailed information in the case where a value could be parsed as JSON, but a value of the required type could not be constructed from it, for some reason.

The type of error specifics which never involve custom validation errors.

Turn a ParseError into a human-readable list of Text values. They will be in a sensible order. For example, you can feed the result to mapM putStrLn, or unlines.

A version of displayError for parsers which do not produce custom validation errors.

A version of displaySpecifics for parsers which do not produce custom validation errors.

This function is useful when you have a Parse err a and you want to obtain an instance for FromJSON a. Simply define:

   parseJSON = toAesonParser showMyCustomError myParser

Take a parser which never produces custom validation errors and turn it into an Aeson parser. Note that in this case, there is no need to provide a display function.

Create a parser for any type, using its FromJSON instance. Generally, you should prefer to write parsers using the other functions in this module; key, asString, etc, since they will usually generate better error messages. However this function is also useful occasionally.

An enumeration of the different types that JSON values may take.

Get the type of a JSON value.