Encoding

Encoding Builtin.Encoding :: # (opaque)

FieldName

Builtin.Encoding.FieldName(_shape) :: # (opaque)

name : FieldName(_shape) -> Str

FieldNames

Builtin.Encoding.FieldName.FieldNames(_shape) :: # (opaque)

rename_fields : FieldNames(_shape), (Str -> Str) -> FieldNames(_shape)

shortest_name : FieldNames(_shape) -> U64

longest_name : FieldNames(_shape) -> U64

iter : FieldNames(_shape) -> Iter(FieldName(_shape))

for_size : FieldNames(_shape), U64 -> Iter(FieldName(_shape))

ParseTagUnionSpec

Builtin.Encoding.ParseTagUnionSpec(_shape) :: # (opaque)

parse : ParseTagUnionSpec(_shape), {
    tag : Str,
    encoding : _encoding,
    state : _state,
    start_payloads : _state, U64 -> Try(_state, _err),
    next_payload : _state, U64, U64 -> Try(_state, _err),
    finish_payloads : _state, U64 -> Try(_state, _err),
    missing : _err,
} -> Try({ value : _shape, rest : _state }, _err)

After a format reads the tag name, the generated parser calls start_payloads once, next_payload before each payload after the first (with its zero-based index and the total count), and finish_payloads once after the final payload.

JsonState

Builtin.Encoding.JsonState :: # (opaque)

JsonEncodeState

Builtin.Encoding.JsonEncodeState :: # (opaque)

JsonContainerEncodeState

Builtin.Encoding.JsonContainerEncodeState :: # (opaque)

Json

Builtin.Encoding.Json :: # (opaque)

parse_str : JsonEncoding, JsonState -> Try({ value : Str, rest : JsonState }, [InvalidJson(Str)])

parse_bool : JsonEncoding, JsonState -> Try({ value : Bool, rest : JsonState }, [InvalidJson(Str)])

parse_u8 : JsonEncoding, JsonState -> Try({ value : U8, rest : JsonState }, [InvalidJson(Str)])

parse_i8 : JsonEncoding, JsonState -> Try({ value : I8, rest : JsonState }, [InvalidJson(Str)])

parse_u16 : JsonEncoding, JsonState -> Try({ value : U16, rest : JsonState }, [InvalidJson(Str)])

parse_i16 : JsonEncoding, JsonState -> Try({ value : I16, rest : JsonState }, [InvalidJson(Str)])

parse_u32 : JsonEncoding, JsonState -> Try({ value : U32, rest : JsonState }, [InvalidJson(Str)])

parse_i32 : JsonEncoding, JsonState -> Try({ value : I32, rest : JsonState }, [InvalidJson(Str)])

parse_u64 : JsonEncoding, JsonState -> Try({ value : U64, rest : JsonState }, [InvalidJson(Str)])

parse_i64 : JsonEncoding, JsonState -> Try({ value : I64, rest : JsonState }, [InvalidJson(Str)])

parse_u128 : JsonEncoding, JsonState -> Try({ value : U128, rest : JsonState }, [InvalidJson(Str)])

parse_i128 : JsonEncoding, JsonState -> Try({ value : I128, rest : JsonState }, [InvalidJson(Str)])

parse_dec : JsonEncoding, JsonState -> Try({ value : Dec, rest : JsonState }, [InvalidJson(Str)])

parse_f32 : JsonEncoding, JsonState -> Try({ value : F32, rest : JsonState }, [InvalidJson(Str)])

parse_f64 : JsonEncoding, JsonState -> Try({ value : F64, rest : JsonState }, [InvalidJson(Str)])

parse_null : JsonEncoding, JsonState -> Try(JsonState, [InvalidJson(Str)])

parse_list_start : JsonEncoding, JsonState -> Try([Counted({ len : U64, rest : JsonState }), Uncounted(JsonState)], [InvalidJson(Str)])

parse_list_next : JsonEncoding, JsonState -> Try([Item(JsonState), Done(JsonState)], [InvalidJson(Str)])

parse_list_after_item : JsonEncoding, JsonState -> Try([Continue(JsonState), Done(JsonState)], [InvalidJson(Str)])

parse_tuple_start : JsonEncoding, JsonState, U64 -> Try(JsonState, [InvalidJson(Str)])

parse_tuple_next : JsonEncoding, JsonState, U64, U64 -> Try(JsonState, [InvalidJson(Str)])

parse_tuple_end : JsonEncoding, JsonState, U64 -> Try(JsonState, [InvalidJson(Str)])

encode_str : JsonEncoding, Str, JsonEncodeState -> Try(JsonEncodeState, _never_fails)

encode_bool : JsonEncoding, Bool, JsonEncodeState -> Try(JsonEncodeState, _never_fails)

encode_u8 : JsonEncoding, U8, JsonEncodeState -> Try(JsonEncodeState, _never_fails)

encode_i8 : JsonEncoding, I8, JsonEncodeState -> Try(JsonEncodeState, _never_fails)

encode_u16 : JsonEncoding, U16, JsonEncodeState -> Try(JsonEncodeState, _never_fails)

encode_i16 : JsonEncoding, I16, JsonEncodeState -> Try(JsonEncodeState, _never_fails)

encode_u32 : JsonEncoding, U32, JsonEncodeState -> Try(JsonEncodeState, _never_fails)

encode_i32 : JsonEncoding, I32, JsonEncodeState -> Try(JsonEncodeState, _never_fails)

encode_u64 : JsonEncoding, U64, JsonEncodeState -> Try(JsonEncodeState, _never_fails)

encode_i64 : JsonEncoding, I64, JsonEncodeState -> Try(JsonEncodeState, _never_fails)

encode_u128 : JsonEncoding, U128, JsonEncodeState -> Try(JsonEncodeState, _never_fails)

encode_i128 : JsonEncoding, I128, JsonEncodeState -> Try(JsonEncodeState, _never_fails)

encode_dec : JsonEncoding, Dec, JsonEncodeState -> Try(JsonEncodeState, _never_fails)

encode_f32 : JsonEncoding, F32, JsonEncodeState -> Try(JsonEncodeState, [Infinity, NaN, NegativeInfinity])

encode_f64 : JsonEncoding, F64, JsonEncodeState -> Try(JsonEncodeState, [Infinity, NaN, NegativeInfinity])

encode_null : JsonEncoding, JsonEncodeState -> Try(JsonEncodeState, _never_fails)

encode_tag : JsonEncoding, JsonEncodeState, Str, U64, (JsonContainerEncodeState, (JsonContainerEncodeState, (JsonEncodeState -> Try(JsonEncodeState, err)) -> Try(JsonContainerEncodeState, err)) -> Try(JsonContainerEncodeState, err)) -> Try(JsonEncodeState, err)

write_payloads supplies each tag payload in source order.

encode_record : JsonEncoding, JsonEncodeState, U64, (JsonContainerEncodeState, (JsonContainerEncodeState, Str, (JsonEncodeState -> Try(JsonEncodeState, err)) -> Try(JsonContainerEncodeState, err)) -> Try(JsonContainerEncodeState, err)) -> Try(JsonEncodeState, err)

encode_tuple : JsonEncoding, JsonEncodeState, U64, (JsonContainerEncodeState, (JsonContainerEncodeState, (JsonEncodeState -> Try(JsonEncodeState, err)) -> Try(JsonContainerEncodeState, err)) -> Try(JsonContainerEncodeState, err)) -> Try(JsonEncodeState, err)

encode_list : JsonEncoding, JsonEncodeState, U64, (JsonContainerEncodeState, (JsonContainerEncodeState, (JsonEncodeState -> Try(JsonEncodeState, err)) -> Try(JsonContainerEncodeState, err)) -> Try(JsonContainerEncodeState, err)) -> Try(JsonEncodeState, err)

encode_dict : JsonEncoding, JsonEncodeState, U64, (JsonContainerEncodeState, (JsonContainerEncodeState, (JsonEncodeState -> Try(JsonEncodeState, err)), (JsonEncodeState -> Try(JsonEncodeState, err)) -> Try(JsonContainerEncodeState, err)) -> Try(JsonContainerEncodeState, err)) -> Try(JsonEncodeState, err)

to_str : a -> Str
    where [
        a.encoder_for : JsonEncoding -> a, JsonEncodeState -> Try(JsonEncodeState, []),
    ]

to_str_try : a -> Try(Str, err)
    where [
        a.encoder_for : JsonEncoding -> a, JsonEncodeState -> Try(JsonEncodeState, err),
    ]

Encode a value as JSON text, returning Err when the value cannot be represented in JSON. For example, F32 and F64 values can be finite numbers, NaN, positive infinity, or negative infinity, but JSON can only represent the finite number case.

parse : Str -> Try(a, [InvalidJson(Str), ..errs])
    where [
        a.parser_for : JsonEncoding -> JsonState -> Try({ value : a, rest : JsonState }, [InvalidJson(Str), ..errs]),
    ]

parse_trailing_commas : Str -> Try(a, [InvalidJson(Str), ..errs])
    where [
        a.parser_for : JsonEncoding -> JsonState -> Try({ value : a, rest : JsonState }, [InvalidJson(Str), ..errs]),
    ]

parser_camel : () -> Str -> Try(a, [InvalidJson(Str), ..errs])
    where [
        a.parser_for : JsonEncoding -> JsonState -> Try({ value : a, rest : JsonState }, [InvalidJson(Str), ..errs]),
    ]

invalid_json : [InvalidJson(Str), ..]

parse_json_bool : Str -> Try({ value : Bool, rest : JsonState }, [InvalidJson(Str), ..])

parse_json_null : Str -> Try(JsonState, [InvalidJson(Str), ..])

parse_list_start_from_json : Str -> Try([Counted({ len : U64, rest : JsonState }), Uncounted(JsonState)], [InvalidJson(Str), ..])

A JSON array never declares its item count up front, so list parsing always runs in Uncounted mode.

parse_list_next_from_json : Str -> Try([Item(JsonState), Done(JsonState)], [InvalidJson(Str), ..])

parse_list_after_item_from_json : JsonEncoding, Str -> Try([Continue(JsonState), Done(JsonState)], [InvalidJson(Str), ..])

parse_tuple_start_from_json : Str, U64 -> Try(JsonState, [InvalidJson(Str), ..])

JSON writes tuples as arrays. Because the arity is known, a mismatch is detected here rather than by the driver, so the error can point at the item position that actually disagreed.

parse_tuple_next_from_json : Str -> Try(JsonState, [InvalidJson(Str), ..])

parse_tuple_end_from_json : JsonEncoding, Str, U64 -> Try(JsonState, [InvalidJson(Str), ..])

parse_json_unsigned_int : Str, (Str -> Try(a, [BadNumStr])) -> Try({ value : a, rest : JsonState }, [InvalidJson(Str), ..])

parse_json_signed_int : Str, (Str -> Try(a, [BadNumStr])) -> Try({ value : a, rest : JsonState }, [InvalidJson(Str), ..])

parse_json_number : Str, (Str -> Try(a, [BadNumStr])) -> Try({ value : a, rest : JsonState }, [InvalidJson(Str), ..])

dec_from_json_number : Str -> Try(Dec, [BadNumStr])

split_json_number_exponent : Str -> Try({ mantissa : Str, exponent : Str }, [NotFound])

dec_from_json_exponent_parts : Str, Str -> Try(Dec, [BadNumStr])

json_dec_digits_are_zero : Str -> Bool

trim_json_dec_leading_zeros : Str, I64 -> { digits : Str, point : I64 }

normalize_json_dec_digits : Bool, Str, I64 -> Try(Str, [BadNumStr])

take_json_key : Str -> Try({ value : Str, rest : JsonState }, [InvalidJson(Str), ..])

Read one quoted object key at the cursor, leaving the cursor just past the closing quote.

parse_json_key_unsigned_int : Str, (Str -> Try(a, [BadNumStr])) -> Try({ value : a, rest : JsonState }, [InvalidJson(Str), ..])

parse_json_key_signed_int : Str, (Str -> Try(a, [BadNumStr])) -> Try({ value : a, rest : JsonState }, [InvalidJson(Str), ..])

parse_json_key_number : Str, (Str -> Try(a, [BadNumStr])) -> Try({ value : a, rest : JsonState }, [InvalidJson(Str), ..])

encode_json_number : Str, JsonEncodeState -> Try(JsonEncodeState, _never_fails)

write_record_field : JsonContainerEncodeState, Str, (JsonEncodeState -> Try(JsonEncodeState, err)) -> Try(JsonContainerEncodeState, err)

write_dict_entry : JsonContainerEncodeState, (JsonEncodeState -> Try(JsonEncodeState, err)), (JsonEncodeState -> Try(JsonEncodeState, err)) -> Try(JsonContainerEncodeState, err)

write_sequence_item : JsonContainerEncodeState, (JsonEncodeState -> Try(JsonEncodeState, err)) -> Try(JsonContainerEncodeState, err)

append_json_string_bytes : List(U8), Str -> List(U8)

append_json_quoted_string : List(U8), Str -> List(U8)

append_json_string_byte : List(U8), U8 -> List(U8)

append_json_unicode_escape : List(U8), U8 -> List(U8)

hex_digit_byte : U8 -> U8

parse_record_start_from_json : Str -> Try([Counted({ len : U64, rest : JsonState }), Uncounted(JsonState)], [InvalidJson(Str), ..])

parse_record_field_from_json : Str -> Try(
    [
        Field({ field : FieldName(_shape), rest : JsonState }),
        TryField({ name : Str, rest : JsonState }),
        TryFieldCaseless({ name : Str, rest : JsonState }),
        Continue(JsonState),
        Done(JsonState),
    ],
    [InvalidJson(Str), ..],
)

Called with the input at an entry boundary: either at a field name or at the closing brace.

parse_record_after_field_from_json : JsonEncoding, Str -> Try([Continue(JsonState), Done(JsonState)], [InvalidJson(Str), ..])

parse_json_object_key : Str -> Try({ name : Str, rest : JsonState }, [InvalidJson(Str), ..])

snake_to_camel : Str -> Str

upper_first_ascii : Str -> Str

skip_json_value : JsonEncoding, JsonState -> Try(JsonState, [InvalidJson(Str), ..])

skip_json_object : JsonEncoding, Str -> Try(JsonState, [InvalidJson(Str), ..])

skip_json_array : JsonEncoding, Str -> Try(JsonState, [InvalidJson(Str), ..])

parse_tag_union_from_json : Str, JsonEncoding, ParseTagUnionSpec(a) -> Try({ value : a, rest : JsonState }, [InvalidJson(Str), ..])

start_string_tag_payloads : JsonState, U64 -> Try(JsonState, [InvalidJson(Str), ..])

next_string_tag_payload : JsonState, U64, U64 -> Try(JsonState, [InvalidJson(Str), ..])

finish_string_tag_payloads : JsonState, U64 -> Try(JsonState, [InvalidJson(Str), ..])

start_object_tag_payloads : JsonEncoding, JsonState, U64 -> Try(JsonState, [InvalidJson(Str), ..])

A multi-payload tag writes its payloads as a JSON array, which is a fixed-arity sequence, so it reads back through the tuple methods. A single payload is written bare, and a payload-free tag is written as an empty object.

next_object_tag_payload : JsonEncoding, JsonState, U64, U64 -> Try(JsonState, [InvalidJson(Str), ..])

finish_object_tag_payloads : JsonEncoding, JsonState, U64 -> Try(JsonState, [InvalidJson(Str), ..])

finish_tag_payload : JsonEncoding, a, Str -> Try({ value : a, rest : JsonState }, [InvalidJson(Str), ..])

consume_empty_json_object : Str -> Try({ after : Str }, [InvalidJson(Str), ..])

is_json_scalar : Str -> Bool

is_json_number : Str -> Bool

is_json_u64_literal : Str -> Bool

is_json_unsigned_int_literal : Str -> Bool

is_json_signed_int_literal : Str -> Bool

is_json_digit : U8 -> Bool

is_json_digit_one_to_nine : U8 -> Bool

is_json_exponent_marker : U8 -> Bool

is_json_sign : U8 -> Bool

split_json_string_tail : Str -> Try({ value : Str, after : Str }, [InvalidJson(Str), ..])

Split a JSON string body into its decoded value and the text after the closing quote. Decodes the escape sequences JSON allows inside strings: \" \\ \/ \b \f \n \r \t and \uXXXX (with surrogate pairs combined into one code point). Unknown escapes, incomplete escapes, and unpaired surrogates are invalid JSON. Strings without escapes return zero-copy slices.

split_json_scalar_tail : Str -> Try({ value : Str, after : Str }, [InvalidJson(Str), ..])

Split a JSON scalar (number, boolean, or null) from the text after it. The scalar ends at the first ,, }, ], or JSON whitespace; after keeps that delimiter. Both results are zero-copy slices.

JsonEncoding

Builtin.Encoding.JsonEncoding :: # (opaque)

rename_field : JsonEncoding, Str -> Str

allows_trailing_commas : JsonEncoding -> Bool

parse_str : JsonEncoding, JsonState -> Try({ value : Str, rest : JsonState }, [InvalidJson(Str), ..])

parse_bool : JsonEncoding, JsonState -> Try({ value : Bool, rest : JsonState }, [InvalidJson(Str), ..])

parse_u8 : JsonEncoding, JsonState -> Try({ value : U8, rest : JsonState }, [InvalidJson(Str), ..])

parse_i8 : JsonEncoding, JsonState -> Try({ value : I8, rest : JsonState }, [InvalidJson(Str), ..])

parse_u16 : JsonEncoding, JsonState -> Try({ value : U16, rest : JsonState }, [InvalidJson(Str), ..])

parse_i16 : JsonEncoding, JsonState -> Try({ value : I16, rest : JsonState }, [InvalidJson(Str), ..])

parse_u32 : JsonEncoding, JsonState -> Try({ value : U32, rest : JsonState }, [InvalidJson(Str), ..])

parse_i32 : JsonEncoding, JsonState -> Try({ value : I32, rest : JsonState }, [InvalidJson(Str), ..])

parse_u64 : JsonEncoding, JsonState -> Try({ value : U64, rest : JsonState }, [InvalidJson(Str), ..])

parse_i64 : JsonEncoding, JsonState -> Try({ value : I64, rest : JsonState }, [InvalidJson(Str), ..])

parse_u128 : JsonEncoding, JsonState -> Try({ value : U128, rest : JsonState }, [InvalidJson(Str), ..])

parse_i128 : JsonEncoding, JsonState -> Try({ value : I128, rest : JsonState }, [InvalidJson(Str), ..])

parse_dec : JsonEncoding, JsonState -> Try({ value : Dec, rest : JsonState }, [InvalidJson(Str), ..])

parse_f32 : JsonEncoding, JsonState -> Try({ value : F32, rest : JsonState }, [InvalidJson(Str), ..])

parse_f64 : JsonEncoding, JsonState -> Try({ value : F64, rest : JsonState }, [InvalidJson(Str), ..])

parse_null : JsonEncoding, JsonState -> Try(JsonState, [InvalidJson(Str), ..])

parse_list_start : JsonEncoding, JsonState -> Try([Counted({ len : U64, rest : JsonState }), Uncounted(JsonState)], [InvalidJson(Str), ..])

parse_list_next : JsonEncoding, JsonState -> Try([Item(JsonState), Done(JsonState)], [InvalidJson(Str), ..])

parse_list_after_item : JsonEncoding, JsonState -> Try([Continue(JsonState), Done(JsonState)], [InvalidJson(Str), ..])

parse_tuple_start : JsonEncoding, JsonState, U64 -> Try(JsonState, [InvalidJson(Str), ..])

parse_tuple_next : JsonEncoding, JsonState, U64, U64 -> Try(JsonState, [InvalidJson(Str), ..])

parse_tuple_end : JsonEncoding, JsonState, U64 -> Try(JsonState, [InvalidJson(Str), ..])

parse_record_start : JsonEncoding, JsonState -> Try([Counted({ len : U64, rest : JsonState }), Uncounted(JsonState)], [InvalidJson(Str), ..])

A JSON object never declares its entry count up front, so record parsing always runs in Uncounted mode: the driver learns the end of the record from parse_record_field or parse_record_after_field.

parse_record_field : JsonEncoding, FieldNames(_shape), JsonState -> Try(
    [
        Field({ field : FieldName(_shape), rest : JsonState }),
        TryField({ name : Str, rest : JsonState }),
        TryFieldCaseless({ name : Str, rest : JsonState }),
        Continue(JsonState),
        Done(JsonState),
    ],
    [InvalidJson(Str), ..],
)

parse_record_after_field : JsonEncoding, JsonState -> Try([Continue(JsonState), Done(JsonState)], [InvalidJson(Str), ..])

parse_dict_start : JsonEncoding, JsonState -> Try([Counted({ len : U64, rest : JsonState }), Uncounted(JsonState)], [InvalidJson(Str), ..])

A JSON object never declares its entry count up front, so dict parsing always runs in Uncounted mode.

parse_dict_next : JsonEncoding, JsonState -> Try([Entry(JsonState), Done(JsonState)], [InvalidJson(Str), ..])

parse_dict_after_key : JsonEncoding, JsonState -> Try(JsonState, [InvalidJson(Str), ..])

parse_dict_after_entry : JsonEncoding, JsonState -> Try([Continue(JsonState), Done(JsonState)], [InvalidJson(Str), ..])

skip_record_field : JsonEncoding, JsonState -> Try(JsonState, [InvalidJson(Str), ..])

invalid_value : JsonEncoding, JsonState -> [InvalidJson(Str), ..]

parse_tag_union : JsonEncoding, ParseTagUnionSpec(a), JsonState -> Try({ value : a, rest : JsonState }, [InvalidJson(Str), ..])

encode_tag : JsonEncodeState, Str, U64, (JsonContainerEncodeState, (JsonContainerEncodeState, (JsonEncodeState -> Try(JsonEncodeState, err)) -> Try(JsonContainerEncodeState, err)) -> Try(JsonContainerEncodeState, err)) -> Try(JsonEncodeState, err)

encode_record : JsonEncodeState, U64, (JsonContainerEncodeState, (JsonContainerEncodeState, Str, (JsonEncodeState -> Try(JsonEncodeState, err)) -> Try(JsonContainerEncodeState, err)) -> Try(JsonContainerEncodeState, err)) -> Try(JsonEncodeState, err)

encode_tuple : JsonEncodeState, U64, (JsonContainerEncodeState, (JsonContainerEncodeState, (JsonEncodeState -> Try(JsonEncodeState, err)) -> Try(JsonContainerEncodeState, err)) -> Try(JsonContainerEncodeState, err)) -> Try(JsonEncodeState, err)

encode_list : JsonEncodeState, U64, (JsonContainerEncodeState, (JsonContainerEncodeState, (JsonEncodeState -> Try(JsonEncodeState, err)) -> Try(JsonContainerEncodeState, err)) -> Try(JsonContainerEncodeState, err)) -> Try(JsonEncodeState, err)

encode_dict : JsonEncodeState, U64, (JsonContainerEncodeState, (JsonContainerEncodeState, (JsonEncodeState -> Try(JsonEncodeState, err)), (JsonEncodeState -> Try(JsonEncodeState, err)) -> Try(JsonContainerEncodeState, err)) -> Try(JsonContainerEncodeState, err)) -> Try(JsonEncodeState, err)

A dict writes as a JSON object. The key is written by its own thunk, which the key encoders always render as a quoted string.

encode_str : Str, JsonEncodeState -> Try(JsonEncodeState, _never_fails)

encode_bool : Bool, JsonEncodeState -> Try(JsonEncodeState, _never_fails)

encode_u8 : U8, JsonEncodeState -> Try(JsonEncodeState, _never_fails)

encode_i8 : I8, JsonEncodeState -> Try(JsonEncodeState, _never_fails)

encode_u16 : U16, JsonEncodeState -> Try(JsonEncodeState, _never_fails)

encode_i16 : I16, JsonEncodeState -> Try(JsonEncodeState, _never_fails)

encode_u32 : U32, JsonEncodeState -> Try(JsonEncodeState, _never_fails)

encode_i32 : I32, JsonEncodeState -> Try(JsonEncodeState, _never_fails)

encode_u64 : U64, JsonEncodeState -> Try(JsonEncodeState, _never_fails)

encode_i64 : I64, JsonEncodeState -> Try(JsonEncodeState, _never_fails)

encode_u128 : U128, JsonEncodeState -> Try(JsonEncodeState, _never_fails)

encode_i128 : I128, JsonEncodeState -> Try(JsonEncodeState, _never_fails)

encode_dec : Dec, JsonEncodeState -> Try(JsonEncodeState, _never_fails)

encode_f32 : F32, JsonEncodeState -> Try(JsonEncodeState, [Infinity, NaN, NegativeInfinity])

encode_f64 : F64, JsonEncodeState -> Try(JsonEncodeState, [Infinity, NaN, NegativeInfinity])

encode_null : JsonEncodeState -> Try(JsonEncodeState, _never_fails)

parse_key_str : JsonEncoding, JsonState -> Try({ value : Str, rest : JsonState }, [InvalidJson(Str), ..])

Dict keys arrive as JSON strings, so each key parser reads the quoted text at the cursor and converts it to the key type.

parse_key_bool : JsonEncoding, JsonState -> Try({ value : Bool, rest : JsonState }, [InvalidJson(Str), ..])

parse_key_u8 : JsonEncoding, JsonState -> Try({ value : U8, rest : JsonState }, [InvalidJson(Str), ..])

parse_key_i8 : JsonEncoding, JsonState -> Try({ value : I8, rest : JsonState }, [InvalidJson(Str), ..])

parse_key_u16 : JsonEncoding, JsonState -> Try({ value : U16, rest : JsonState }, [InvalidJson(Str), ..])

parse_key_i16 : JsonEncoding, JsonState -> Try({ value : I16, rest : JsonState }, [InvalidJson(Str), ..])

parse_key_u32 : JsonEncoding, JsonState -> Try({ value : U32, rest : JsonState }, [InvalidJson(Str), ..])

parse_key_i32 : JsonEncoding, JsonState -> Try({ value : I32, rest : JsonState }, [InvalidJson(Str), ..])

parse_key_u64 : JsonEncoding, JsonState -> Try({ value : U64, rest : JsonState }, [InvalidJson(Str), ..])

parse_key_i64 : JsonEncoding, JsonState -> Try({ value : I64, rest : JsonState }, [InvalidJson(Str), ..])

parse_key_u128 : JsonEncoding, JsonState -> Try({ value : U128, rest : JsonState }, [InvalidJson(Str), ..])

parse_key_i128 : JsonEncoding, JsonState -> Try({ value : I128, rest : JsonState }, [InvalidJson(Str), ..])

parse_key_dec : JsonEncoding, JsonState -> Try({ value : Dec, rest : JsonState }, [InvalidJson(Str), ..])

parse_key_f32 : JsonEncoding, JsonState -> Try({ value : F32, rest : JsonState }, [InvalidJson(Str), ..])

parse_key_f64 : JsonEncoding, JsonState -> Try({ value : F64, rest : JsonState }, [InvalidJson(Str), ..])

encode_key_str : JsonEncoding, Str, JsonEncodeState -> Try(JsonEncodeState, _never_fails)

A JSON object key is always quoted text, so each key encoder renders its value and writes it as a JSON string.

encode_key_bool : JsonEncoding, Bool, JsonEncodeState -> Try(JsonEncodeState, _never_fails)

encode_key_u8 : JsonEncoding, U8, JsonEncodeState -> Try(JsonEncodeState, _never_fails)

encode_key_i8 : JsonEncoding, I8, JsonEncodeState -> Try(JsonEncodeState, _never_fails)

encode_key_u16 : JsonEncoding, U16, JsonEncodeState -> Try(JsonEncodeState, _never_fails)

encode_key_i16 : JsonEncoding, I16, JsonEncodeState -> Try(JsonEncodeState, _never_fails)

encode_key_u32 : JsonEncoding, U32, JsonEncodeState -> Try(JsonEncodeState, _never_fails)

encode_key_i32 : JsonEncoding, I32, JsonEncodeState -> Try(JsonEncodeState, _never_fails)

encode_key_u64 : JsonEncoding, U64, JsonEncodeState -> Try(JsonEncodeState, _never_fails)

encode_key_i64 : JsonEncoding, I64, JsonEncodeState -> Try(JsonEncodeState, _never_fails)

encode_key_u128 : JsonEncoding, U128, JsonEncodeState -> Try(JsonEncodeState, _never_fails)

encode_key_i128 : JsonEncoding, I128, JsonEncodeState -> Try(JsonEncodeState, _never_fails)

encode_key_dec : JsonEncoding, Dec, JsonEncodeState -> Try(JsonEncodeState, _never_fails)

encode_key_f32 : JsonEncoding, F32, JsonEncodeState -> Try(JsonEncodeState, [Infinity, NaN, NegativeInfinity])

encode_key_f64 : JsonEncoding, F64, JsonEncodeState -> Try(JsonEncodeState, [Infinity, NaN, NegativeInfinity])

HttpHeaderState

Builtin.Encoding.HttpHeaderState :: # (opaque)

HttpHeaderEncoding

Builtin.Encoding.HttpHeaderEncoding :: # (opaque)

rename_field : HttpHeaderEncoding, Str -> Str

parse_str : HttpHeaderEncoding, HttpHeaderState -> Try({ value : Str, rest : HttpHeaderState }, [BadHeader, ..])

parse_u64 : HttpHeaderEncoding, HttpHeaderState -> Try({ value : U64, rest : HttpHeaderState }, [BadHeader, ..])

parse_record_start : HttpHeaderEncoding, HttpHeaderState -> Try([Counted({ len : U64, rest : HttpHeaderState }), Uncounted(HttpHeaderState)], [BadHeader, ..])

Header sequences have no opening delimiter and no way to declare a header count up front, so parsing always starts in Uncounted mode on the unchanged input.

parse_record_field : HttpHeaderEncoding, FieldNames(_shape), HttpHeaderState -> Try(
    [
        Field({ field : FieldName(_shape), rest : HttpHeaderState }),
        TryField({ name : Str, rest : HttpHeaderState }),
        TryFieldCaseless({ name : Str, rest : HttpHeaderState }),
        Continue(HttpHeaderState),
        Done(HttpHeaderState),
    ],
    [BadHeader, ..],
)

parse_record_after_field : HttpHeaderEncoding, HttpHeaderState -> Try([Continue(HttpHeaderState), Done(HttpHeaderState)], [BadHeader, ..])

Each header value consumes its own CRLF terminator, so the cursor is already at the next entry boundary after every field.

skip_record_field : HttpHeaderEncoding, HttpHeaderState -> Try(HttpHeaderState, [BadHeader, ..])

HttpHeader

Builtin.Encoding.HttpHeader :: # (opaque)

parser_for : () -> Str -> Try(output, [BadHeader, ..errs])
    where [
        output.parser_for : HttpHeaderEncoding -> HttpHeaderState -> Try({ value : output, rest : HttpHeaderState }, [BadHeader, ..errs]),
    ]

parse : Str -> Try(output, [BadHeader, ..errs])
    where [
        output.parser_for : HttpHeaderEncoding -> HttpHeaderState -> Try({ value : output, rest : HttpHeaderState }, [BadHeader, ..errs]),
    ]

parse_str : HttpHeaderEncoding, HttpHeaderState -> Try({ value : Str, rest : HttpHeaderState }, [BadHeader, ..])

parse_u64 : HttpHeaderEncoding, HttpHeaderState -> Try({ value : U64, rest : HttpHeaderState }, [BadHeader, ..])

parse_record_field_from_headers : FieldNames(_shape), Str -> Try(
    [
        Field({ field : FieldName(_shape), rest : HttpHeaderState }),
        TryField({ name : Str, rest : HttpHeaderState }),
        TryFieldCaseless({ name : Str, rest : HttpHeaderState }),
        Continue(HttpHeaderState),
        Done(HttpHeaderState),
    ],
    [BadHeader, ..],
)

take_header_value : Str -> Try({ value : Str, after : Str }, [BadHeader, ..])

underscores_to_dashes : Str -> Str