A Node is a reprentation of part of a JSON document, along with everything that is inside of it, along with its "key path", which is its location within a JSON document.

This means that the output of the parser will always be a single Node; but depending on the input, that Node's JValue may have other Nodes inside of it.

A JValue represents a typed value within a JSON document.

A JProp represents the type of a scalar property within a JSON document. These are regarded separately from the JValue type for a few important reasons:

• Since this package is concerned with parsing an arbitrary JSON document and lifting it into a type that allows it to be used within an Elm program, this means that the JSON schema is derived ad-hoc from user input.
• And so, an ad-hoc JSON schema cannot exist without values.
• However, if we are going to to store references to locations within that ad-hoc JSON schema, we are likely doing so because we would like to retrieve some value at a given location from a JSON document that is different from the original input.

In order to create a distinction between "a parsed JSON value" and "a reference to a location within a JSON document", it must be the case that we have another way to represent the concept of "the expected type of a value at a location within a JSON document" that is separate from "a value at a location within a JSON document, from which the type is derived".

Creating a second type was the most straightforward way to implement this behavior.

A JStructure represents a property that has a structural type (i.e., a list or an object) within a JSON document.

A Keypath is a data structure that stores the JSON path to a value of a given key.

Elements in a Keypath are either the name of a field, or the index of an array.

Use the functions in the Json.InElm.Keypath module to work with Keypath values.

A JTag is a "tag" that is used to store the type of a given property (scalar or structural) in a JSON document.

Json.InElm doesn't actually need to store this information in order to parse a JSON document, since it can be inferred directly from incoming data; however, it can be helpful to store this information for later retrieval and evaluation, so a type JTag that unions JProps and JStructures is provided.

A Schema describes the type of, and path to, a given Node.

Parse a Json.Decode.Value to a Node.

Parse a Json.Decode.Value to a Node, at a given KeyPath.

Parse a raw JSON string to a Node.

Create a decoder to a Node, given a Keypath.

From a Node, get all possible Nodes.

Try to get a String from a JValue.

Try to get a Int from a JValue.

Try to get a Float from a JValue.

Try to get a Bool from a JValue.

Try to get a Time from a JValue.

Try to get a List Node from a JValue.

Try to get a List (String, Node) from a JValue, where the String value is the name of the field in the object.

Try to see if a JValue contains a JSON null.

Combinator that allows you to build a view function that renders a Node; i.e., if you can provide all of the functions to destructure a Node, we can display it for you!