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.

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.Encodable([])]
to_str_try : a -> Try(Str, err) where [a.Encodable(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.Parseable([InvalidJson(Str), ..errs])]
parse_trailing_commas : Str -> Try(a, [InvalidJson(Str), ..errs]) where [a.Parseable([InvalidJson(Str), ..errs])]
parser_camel : () -> (Str -> Try(a, [InvalidJson(Str), ..errs])) where [a.Parseable([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.

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

Names the requirement that a value can be written as JSON, so a signature can say "JSON-encodable" without naming the encoder's internal format and output-state types.

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

Names the requirement that a value can be read from JSON, so a signature can say "JSON-parseable" without naming the parser's internal format and cursor types.

HttpHeader

Builtin.Encoding.HttpHeader :: # (opaque)
parser_for : () -> (Str -> Try(output, [BadHeader, ..errs])) where [output.Parseable([BadHeader, ..errs])]
parse : Str -> Try(output, [BadHeader, ..errs]) where [output.Parseable([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
Parseable : output
    where [
        output.parser_for : HttpHeaderEncoding -> (HttpHeaderState -> Try({ value : output, rest : HttpHeaderState }, errs)),
    ]

Names the requirement that a value can be read from HTTP headers, so a signature can say "header-parseable" without naming the parser's internal format and cursor types.