JsonValue

Compare two JSON values structurally. Numbers compare by their text, so Number("1.0") and Number("1") differ.

Hash a JSON value, so values can be Dict keys and Set members.

Parse a complete document during compilation, reporting its source name and position. It accepts exactly what JsonValue.parse_with accepts with the same options.

expect JsonValue.validate({ source: "{\"a\": [1,]}", name: "list.json" }) == Err(BadQuotedBytes("list.json:1:9: JSON: trailing comma is not allowed"))

expect JsonValue.validate({ source: "{\"a\": [1,]}", options: { trailing_commas: True } }).map_ok(|doc| doc.get_path(["a", "0"])) == Ok(Ok(Number("1")))

Use a strict JSON document as a quoted value.

expect {
    settings : JsonValue
    settings = "{\"port\": 8080}"
    settings.get("port") == Ok(Number("8080"))
}

expect JsonValue.from_quote("{\"a\": 1, \"a\": 1}") == Err(BadQuotedBytes("<literal>:1:10: JSON: duplicate key \"a\""))

Parse one complete, strict RFC 8259 document. Whitespace may surround the value; anything else after it is an error.

expect JsonValue.parse_str("{\"a\": [true, null]}") == Ok(Object([{ key: "a", value: Array([Bool(True), Null]) }]))

expect JsonValue.parse_str("[1,]") == Err(InvalidJsonValue({ line: 1, column: 3, message: "trailing comma is not allowed" }))

Parse one complete document with the given JsonValue.Options.

expect JsonValue.parse_with("{\"a\": 1, \"a\": 2}", { duplicates: KeepLast }) == Ok(Object([{ key: "a", value: Number("2") }]))

A Parser that reads one strict JSON value and the whitespace around it, and leaves the rest of the input for the next parser. A failure is ParseError({ message, offset }) with the byte offset of the problem.

expect Utf8.parse_str_partial(JsonValue.parser, "[1] rest").map_ok(|{ rest, .. }| rest) == Ok("rest")

expect Utf8.parse_str(JsonValue.parser, "[1 2]") == Err(ParseError({ message: "expected ',' or ']' after an array item", offset: 3 }))

Like JsonValue.parser, with the given JsonValue.Options. max_bytes bounds the supplied buffer, including any unconsumed suffix.

expect Utf8.parse_str(JsonValue.parser_with({ comments: True }), "1 // one") == Ok(Number("1"))

The value of the first member named key in an object. Anything else, or an object without that key, is Err(Missing).

expect JsonValue.parse_str("{\"a\": 1}").map_ok(|doc| doc.get("a")) == Ok(Ok(Number("1")))

The item at a zero-based index of an array. Anything else, or an index past the end, is Err(Missing).

expect JsonValue.parse_str("[10, 20]").map_ok(|doc| doc.at(1)) == Ok(Ok(Number("20")))

Follow a path of object keys and array indexes. A segment applied to an array must be a decimal index such as "0", without a sign or leading zeros, as in a JSON Pointer (RFC 6901).

expect JsonValue.parse_str("{\"a\": [{\"b\": true}]}").map_ok(|doc| doc.get_path(["a", "0", "b"])) == Ok(Ok(Bool(True)))

The keys of an object, in order; empty for anything else.

expect JsonValue.parse_str("{\"b\": 1, \"a\": 2}").map_ok(|doc| doc.keys()) == Ok(["b", "a"])

The text of a String value, or Err(WrongType).

expect JsonValue.parse_str("\"caf\\u00e9\"").map_ok(|doc| doc.as_str()) == Ok(Ok("café"))

The boolean of a Bool value, or Err(WrongType).

expect JsonValue.parse_str("false").map_ok(|doc| doc.as_bool()) == Ok(Ok(False))

The items of an Array value, or Err(WrongType).

expect JsonValue.parse_str("[null]").map_ok(|doc| doc.as_list()) == Ok(Ok([Null]))

The members of an Object value in order, or Err(WrongType).

expect JsonValue.parse_str("{\"a\": null}").map_ok(|doc| doc.as_object()) == Ok(Ok([{ key: "a", value: Null }]))

The integer of a Number written as a JSON integer, with no fraction or exponent. Other values, including 1.0 and 1e3, are Err(WrongType); an integer outside the I64 range is Err(OutOfRange).

expect JsonValue.parse_str("-42").map_ok(|doc| doc.as_i64()) == Ok(Ok(-42))

expect JsonValue.parse_str("1e3").map_ok(|doc| doc.as_i64()) == Ok(Err(WrongType))

Like JsonValue.as_i64, for U64. A negative integer other than -0 is Err(OutOfRange).

expect JsonValue.parse_str("18446744073709551615").map_ok(|doc| doc.as_u64()) == Ok(Ok(18446744073709551615))

expect JsonValue.parse_str("-1").map_ok(|doc| doc.as_u64()) == Ok(Err(OutOfRange))

The value of a Number as a Dec. A number outside the Dec range, one that needs more than 18 decimal places (trailing zeros don't count, so 1.50000000000000000000 is 1.5), or NaN or Infinity, is Err(OutOfRange); anything else is Err(WrongType).

expect JsonValue.parse_str("-1.25e+2").map_ok(|doc| doc.as_dec()) == Ok(Ok(-125.0))

Write a value as compact JSON, keeping member order.

A value built by hand can be one that JSON cannot express: a Number whose text is not a JSON number (including NaN and Infinity) is InvalidNumber, a key repeated in one object is DuplicateKey, and more than 128 levels of nesting is TooDeep.

expect JsonValue.to_str(Object([{ key: "a", value: Number("1") }, { key: "b", value: Array([Bool(True), Null]) }])) == Ok("{\"a\":1,\"b\":[true,null]}")

expect JsonValue.to_str(Number("NaN")) == Err(InvalidNumber("NaN"))

Write a value with the given JsonValue.WriteOptions. max_bytes limits UTF-8 output bytes, including escapes and indentation, checked before allocating output. It defaults to unlimited. Exceeding the budget is TooLarge(max_bytes). No final newline is added; reserve space in the budget when the calling protocol appends one.

expect JsonValue.to_str_with(Array([Number("1"), String("two")]), { indent: 4 }) == Ok("[\n    1,\n    \"two\"\n]")