Dictionaries and Sets Docs

Encoding.ParseTagUnionSpec.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)

Encoding.JsonState

Encoding.JsonEncodeState

Encoding.Json

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Encoding.Json.parse_array_start : JsonEncoding, JsonState -> Try(JsonState, [InvalidJson(Str)])

Encoding.Json.parse_array_next : JsonEncoding, JsonState -> Try([Element(JsonState), Done(JsonState)], [InvalidJson(Str)])

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Encoding.Json.encode_null : JsonEncoding, JsonEncodeState -> Try(JsonEncodeState, _never_fails)

Encoding.Json.encode_tag : JsonEncoding, JsonEncodeState, Str, U64, (JsonEncodeState, (JsonEncodeState, (JsonEncodeState -> Try(JsonEncodeState, err)) -> Try(JsonEncodeState, err)) -> Try(JsonEncodeState, err)) -> Try(JsonEncodeState, err)

Encoding.Json.encode_record : JsonEncoding, JsonEncodeState, U64, (JsonEncodeState, (JsonEncodeState, Str, (JsonEncodeState -> Try(JsonEncodeState, err)) -> Try(JsonEncodeState, err)) -> Try(JsonEncodeState, err)) -> Try(JsonEncodeState, err)

Encoding.Json.encode_tuple : JsonEncoding, JsonEncodeState, U64, (JsonEncodeState, (JsonEncodeState, (JsonEncodeState -> Try(JsonEncodeState, err)) -> Try(JsonEncodeState, err)) -> Try(JsonEncodeState, err)) -> Try(JsonEncodeState, err)

Encoding.Json.encode_list : JsonEncoding, JsonEncodeState, U64, (JsonEncodeState, (JsonEncodeState, (JsonEncodeState -> Try(JsonEncodeState, err)) -> Try(JsonEncodeState, err)) -> Try(JsonEncodeState, err)) -> Try(JsonEncodeState, err)

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

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

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

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

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

Encoding.Json.invalid_json : [InvalidJson(Str), ..]

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

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

Encoding.Json.parse_array_start_from_json : Str -> Try(JsonState, [InvalidJson(Str), ..])

Encoding.Json.parse_array_next_from_json : Str -> Try([Element(JsonState), Done(JsonState)], [InvalidJson(Str), ..])

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

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

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

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

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

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

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

Encoding.Json.json_dec_digits_are_zero : Str -> Bool

Encoding.Json.trim_json_dec_leading_zeros : Str, I64 -> { digits : Str, digits_len : U64, point : I64 }

Encoding.Json.normalize_json_dec_digits : Bool, Str, U64, I64 -> Try(Str, [BadNumStr])

Encoding.Json.parse_json_key_unsigned_int : Str, (Str -> Try(a, [BadNumStr])) -> Try(a, [InvalidJson(Str), ..])

Encoding.Json.parse_json_key_signed_int : Str, (Str -> Try(a, [BadNumStr])) -> Try(a, [InvalidJson(Str), ..])

Encoding.Json.parse_json_key_number : Str, (Str -> Try(a, [BadNumStr])) -> Try(a, [InvalidJson(Str), ..])

Encoding.Json.encode_json_number : Str, JsonEncodeState -> Try(JsonEncodeState, _never_fails)

Encoding.Json.container_needs_comma : JsonEncodeState -> Bool

Encoding.Json.mark_container_has_item : List(Bool) -> List(Bool)

Encoding.Json.write_record_start : JsonEncodeState -> Try(JsonEncodeState, _never_fails)

Encoding.Json.write_record_field : JsonEncodeState, Str, (JsonEncodeState -> Try(JsonEncodeState, err)) -> Try(JsonEncodeState, err)

Encoding.Json.write_record_end : JsonEncodeState -> Try(JsonEncodeState, _never_fails)

Encoding.Json.write_sequence_start : JsonEncodeState -> Try(JsonEncodeState, _never_fails)

Encoding.Json.write_sequence_element : JsonEncodeState, (JsonEncodeState -> Try(JsonEncodeState, err)) -> Try(JsonEncodeState, err)

Encoding.Json.write_sequence_end : JsonEncodeState -> Try(JsonEncodeState, _never_fails)

Encoding.Json.append_json_string_bytes : List(U8), Str -> List(U8)

Encoding.Json.append_json_quoted_string : List(U8), Str -> List(U8)

Encoding.Json.append_json_string_byte : List(U8), U8 -> List(U8)

Encoding.Json.append_json_unicode_escape : List(U8), U8 -> List(U8)

Encoding.Json.hex_digit_byte : U8 -> U8

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

Encoding.Json.parse_record_field_after_object_start : a, Str -> Try([Done({ rest : JsonState }), TryField({ name : Str, rest : JsonState })], [InvalidJson(Str), ..])

Encoding.Json.parse_record_field_after_value : JsonEncoding, Str -> Try([Done({ rest : JsonState }), ..[TryField({ name : Str, rest : JsonState })]], [InvalidJson(Str), ..])

Encoding.Json.parse_record_field_start : a, Str -> Try([TryField({ name : Str, rest : JsonState })], [InvalidJson(Str), ..])

Encoding.Json.snake_to_camel : Str -> Str

Encoding.Json.upper_first_ascii : Str -> Str

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

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

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

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

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

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

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

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

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

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

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

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

Encoding.Json.is_json_scalar : Str -> Bool

Encoding.Json.is_json_number : Str -> Bool

Encoding.Json.is_json_u64_literal : Str -> Bool

Encoding.Json.is_json_unsigned_int_literal : Str -> Bool

Encoding.Json.is_json_signed_int_literal : Str -> Bool

Encoding.Json.is_json_digit : U8 -> Bool

Encoding.Json.is_json_digit_one_to_nine : U8 -> Bool

Encoding.Json.is_json_exponent_marker : U8 -> Bool

Encoding.Json.is_json_sign : U8 -> Bool

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

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

Encoding.JsonEncoding

Encoding.JsonEncoding.rename_field : JsonEncoding, Str -> Str

Encoding.JsonEncoding.allows_trailing_commas : JsonEncoding -> Bool

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Encoding.JsonEncoding.parse_array_next : JsonEncoding, JsonState -> Try([Element(JsonState), Done(JsonState)], [InvalidJson(Str), ..])

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

Encoding.JsonEncoding.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({ rest : JsonState }), Done({ rest : JsonState })], [InvalidJson(Str), ..])

Encoding.JsonEncoding.parse_object_next : JsonEncoding, JsonState -> Try([Entry({ key : Str, rest : JsonState }), Done({ rest : JsonState })], [InvalidJson(Str), ..])

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Encoding.JsonEncoding.parse_key_str : JsonEncoding, Str -> Try(Str, [InvalidJson(Str), ..])

Encoding.JsonEncoding.parse_key_bool : JsonEncoding, Str -> Try(Bool, [InvalidJson(Str), ..])

Encoding.JsonEncoding.parse_key_u8 : JsonEncoding, Str -> Try(U8, [InvalidJson(Str), ..])

Encoding.JsonEncoding.parse_key_i8 : JsonEncoding, Str -> Try(I8, [InvalidJson(Str), ..])

Encoding.JsonEncoding.parse_key_u16 : JsonEncoding, Str -> Try(U16, [InvalidJson(Str), ..])

Encoding.JsonEncoding.parse_key_i16 : JsonEncoding, Str -> Try(I16, [InvalidJson(Str), ..])

Encoding.JsonEncoding.parse_key_u32 : JsonEncoding, Str -> Try(U32, [InvalidJson(Str), ..])

Encoding.JsonEncoding.parse_key_i32 : JsonEncoding, Str -> Try(I32, [InvalidJson(Str), ..])

Encoding.JsonEncoding.parse_key_u64 : JsonEncoding, Str -> Try(U64, [InvalidJson(Str), ..])

Encoding.JsonEncoding.parse_key_i64 : JsonEncoding, Str -> Try(I64, [InvalidJson(Str), ..])

Encoding.JsonEncoding.parse_key_u128 : JsonEncoding, Str -> Try(U128, [InvalidJson(Str), ..])

Encoding.JsonEncoding.parse_key_i128 : JsonEncoding, Str -> Try(I128, [InvalidJson(Str), ..])

Encoding.JsonEncoding.parse_key_dec : JsonEncoding, Str -> Try(Dec, [InvalidJson(Str), ..])

Encoding.JsonEncoding.parse_key_f32 : JsonEncoding, Str -> Try(F32, [InvalidJson(Str), ..])

Encoding.JsonEncoding.parse_key_f64 : JsonEncoding, Str -> Try(F64, [InvalidJson(Str), ..])

Encoding.JsonEncoding.encode_key_str : JsonEncoding, Str -> Try(Str, _never_fails)

Encoding.JsonEncoding.encode_key_bool : JsonEncoding, Bool -> Try(Str, _never_fails)

Encoding.JsonEncoding.encode_key_u8 : JsonEncoding, U8 -> Try(Str, _never_fails)

Encoding.JsonEncoding.encode_key_i8 : JsonEncoding, I8 -> Try(Str, _never_fails)

Encoding.JsonEncoding.encode_key_u16 : JsonEncoding, U16 -> Try(Str, _never_fails)

Encoding.JsonEncoding.encode_key_i16 : JsonEncoding, I16 -> Try(Str, _never_fails)

Encoding.JsonEncoding.encode_key_u32 : JsonEncoding, U32 -> Try(Str, _never_fails)

Encoding.JsonEncoding.encode_key_i32 : JsonEncoding, I32 -> Try(Str, _never_fails)

Encoding.JsonEncoding.encode_key_u64 : JsonEncoding, U64 -> Try(Str, _never_fails)

Encoding.JsonEncoding.encode_key_i64 : JsonEncoding, I64 -> Try(Str, _never_fails)

Encoding.JsonEncoding.encode_key_u128 : JsonEncoding, U128 -> Try(Str, _never_fails)

Encoding.JsonEncoding.encode_key_i128 : JsonEncoding, I128 -> Try(Str, _never_fails)

Encoding.JsonEncoding.encode_key_dec : JsonEncoding, Dec -> Try(Str, _never_fails)

Encoding.JsonEncoding.encode_key_f32 : JsonEncoding, F32 -> Try(Str, [Infinity, NaN, NegativeInfinity])

Encoding.JsonEncoding.encode_key_f64 : JsonEncoding, F64 -> Try(Str, [Infinity, NaN, NegativeInfinity])

Encoding.HttpHeaderState

Encoding.HttpHeaderEncoding

Encoding.HttpHeaderEncoding.rename_field : HttpHeaderEncoding, Str -> Str

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

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

Encoding.HttpHeaderEncoding.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({ rest : HttpHeaderState }), Done({ rest : HttpHeaderState })], [BadHeader, ..])

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

Encoding.HttpHeader

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

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

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

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

Encoding.HttpHeader.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({ rest : HttpHeaderState }), Done({ rest : HttpHeaderState })], [BadHeader, ..])

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

Encoding.HttpHeader.underscores_to_dashes : Str -> Str

Hasher.write_bool : Hasher, Bool -> Hasher

Hasher.write_u8 : Hasher, U8 -> Hasher

Hasher.write_u16 : Hasher, U16 -> Hasher

Hasher.write_u32 : Hasher, U32 -> Hasher

Hasher.write_u64 : Hasher, U64 -> Hasher

Hasher.write_u128 : Hasher, U128 -> Hasher

Hasher.write_i8 : Hasher, I8 -> Hasher

Hasher.write_i16 : Hasher, I16 -> Hasher

Hasher.write_i32 : Hasher, I32 -> Hasher

Hasher.write_i64 : Hasher, I64 -> Hasher

Hasher.write_i128 : Hasher, I128 -> Hasher

Hasher.write_f32 : Hasher, F32 -> Hasher

Hasher.write_f64 : Hasher, F64 -> Hasher

Hasher.write_dec : Hasher, Dec -> Hasher

Hasher.write_bytes : Hasher, List(U8) -> Hasher

Hasher.write_str : Hasher, Str -> Hasher

Iter.custom : state, [Known(U64), Unknown], (state -> Try((item, state), [NoMore])) -> Iter(item)

Iter.range_exclusive : num, num -> Iter(num) where [num.range_exclusive : num, num -> Iter(num)]

Iter.range_inclusive : num, num -> Iter(num) where [num.range_inclusive : num, num -> Iter(num)]

Iter.exclusive_range : num, num, [Known(U64), Unknown] -> Iter(num) where [num.is_lt : num, num -> Bool, num.add_try : num, num -> Try(num, [Overflow]), num.from_numeral : Numeral -> Try(num, [InvalidNumeral(Str)])]

Iter.inclusive_range : num, num, [Known(U64), Unknown] -> Iter(num) where [num.is_lte : num, num -> Bool, num.add_try : num, num -> Try(num, [Overflow]), num.from_numeral : Numeral -> Try(num, [InvalidNumeral(Str)])]

Iter.iter : Iter(item) -> Iter(item)

Iter.single : item -> Iter(item)

Iter.prepended : Iter(item), item -> Iter(item)

Iter.concat : Iter(item), Iter(item) -> Iter(item)

Iter.append : Iter(item), item -> Iter(item)

Iter.next : Iter(item) -> [One({ item : item, rest : Iter(item) }), Skip({ rest : Iter(item) }), Done]

Iter.map : Iter(a), (a -> b) -> Iter(b)

Iter.keep_if : Iter(a), (a -> Bool) -> Iter(a)

Iter.drop_if : Iter(a), (a -> Bool) -> Iter(a)

Iter.fold : Iter(a), acc, (acc, a -> acc) -> acc

Iter.size_hint : Iter(item) -> [Known(U64), Unknown]

Iter.collect : Iter(item) -> output where [output.from_iter : Iter(item) -> output]

Iter.stream : Iter(item) -> Stream(item)

Iter.take_first : Iter(item), U64 -> Iter(item)

Iter.drop_first : Iter(item), U64 -> Iter(item)

Iter.take_last : Iter(item), U64 -> Iter(item)

Iter.drop_last : Iter(item), U64 -> Iter(item)

Iter.step_by : Iter(item), U64 -> Iter(item)

Iter.rev : Iter(item) -> Iter(item)

List.parser_for : _

List.len : List(_item) -> U64

List.is_empty : List(_item) -> Bool

List.iter : List(item) -> Iter(item)

List.from_iter : Iter(item) -> List(item)

List.concat : List(item), List(item) -> List(item)

List.join : List(List(item)) -> List(item)

List.with_capacity : U64 -> List(item)

List.reserve : List(item), U64 -> List(item)

List.release_excess_capacity : List(item) -> List(item)

List.sort_with : List(item), (item, item -> [LT, EQ, GT]) -> List(item)

List.is_eq : List(item), List(item) -> Bool where [item.is_eq : item, item -> Bool]

List.to_hash : List(item), Hasher -> Hasher where [item.to_hash : item, Hasher -> Hasher]

List.append : List(a), a -> List(a)

List.append_if_ok : List(a), Try(a, err) -> List(a)

List.prepend : List(a), a -> List(a)

List.first : List(item) -> Try(item, [ListWasEmpty, ..])

List.get : List(item), U64 -> Try(item, [OutOfBounds, ..])

List.subscript : List(item), U64 -> Try(item, [OutOfBounds, ..])

List.set : List(a), U64, a -> Try(List(a), [OutOfBounds, ..])

List.replace : List(a), U64, a -> Try({ list : List(a), prev : a }, [OutOfBounds, ..])

List.update : List(a), U64, (a -> a) -> Try(List(a), [OutOfBounds, ..])

List.swap : List(a), U64, U64 -> Try(List(a), [OutOfBounds, ..])

List.rev : List(item) -> List(item)

List.for_each! : List(item), (item => { }) => { }

List.map : List(a), (a -> b) -> List(b)

List.map_with_index : List(a), (a, U64 -> b) -> List(b)

List.map2 : List(a), List(b), (a, b -> c) -> List(c)

List.keep_if : List(a), (a -> Bool) -> List(a)

List.drop_if : List(a), (a -> Bool) -> List(a)

List.keep_oks : List(before), (before -> Try(after, _err)) -> List(after)

List.keep_errs : List(before), (before -> Try(_ok, after)) -> List(after)

List.count_if : List(a), (a -> Bool) -> U64

List.fold : List(item), state, (state, item -> state) -> state

List.fold_with_index : List(item), state, (state, item, U64 -> state) -> state

List.fold_until : List(item), state, (state, item -> [Continue(state), Break(state)]) -> state

List.fold_with_index_until : List(item), state, (state, item, U64 -> [Continue(state), Break(state)]) -> state

List.fold_rev : List(item), state, (item, state -> state) -> state

List.starts_with : List(a), List(a) -> Bool where [a.is_eq : a, a -> Bool]

List.ends_with : List(a), List(a) -> Bool where [a.is_eq : a, a -> Bool]

List.any : List(a), (a -> Bool) -> Bool

List.contains : List(a), a -> Bool where [a.is_eq : a, a -> Bool]

List.all : List(a), (a -> Bool) -> Bool

List.last : List(item) -> Try(item, [ListWasEmpty, ..])

List.single : item -> List(item)

List.drop_at : List(a), U64 -> List(a)

List.sublist : List(a), { start : U64, len : U64 } -> List(a)

List.take_first : List(a), U64 -> List(a)

List.take_last : List(a), U64 -> List(a)

List.drop_first : List(a), U64 -> List(a)

List.drop_last : List(a), U64 -> List(a)

List.find_first : List(a), (a -> Bool) -> Try(a, [NotFound])

List.find_last : List(a), (a -> Bool) -> Try(a, [NotFound])

List.find_first_index : List(a), (a -> Bool) -> Try(U64, [NotFound])

List.find_last_index : List(a), (a -> Bool) -> Try(U64, [NotFound])

List.split_at : List(a), U64 -> { before : List(a), others : List(a) }

List.split_on : List(a), a -> List(List(a)) where [a.is_eq : a, a -> Bool]

List.split_if : List(a), (a -> Bool) -> List(List(a))

List.split_on_list : List(a), List(a) -> List(List(a)) where [a.is_eq : a, a -> Bool]

List.split_first : List(a), a -> Try({ before : List(a), after : List(a) }, [NotFound]) where [a.is_eq : a, a -> Bool]

List.split_last : List(a), a -> Try({ before : List(a), after : List(a) }, [NotFound]) where [a.is_eq : a, a -> Bool]

List.repeat : a, U64 -> List(a)

List.sum : List(item) -> item where [item.plus : item, item -> item, item.default : () -> item]

List.min : List(a) -> Try(a, [ListWasEmpty]) where [a.min : a, a -> a]

List.max : List(a) -> Try(a, [ListWasEmpty]) where [a.max : a, a -> a]

List.encoder_for : encoding -> List(item), state -> Try(state, err) where [item.encoder_for : encoding -> item, state -> Try(state, err), encoding.encode_list : state, U64, (state, (state, (state -> Try(state, err)) -> Try(state, err)) -> Try(state, err)) -> Try(state, err)]

List.decode : src, fmt -> (Try(List(item), err), src) where [fmt.decode_list : fmt, src, (src, fmt -> (Try(item, err), src)) -> (Try(List(item), err), src), item.decode : src, fmt -> (Try(item, err), src)]

Num.Numeral

Num.Numeral.is_negative : Numeral -> Bool

Num.Numeral.digits_before_pt : Numeral -> List(U8)

Num.Numeral.digits_after_pt : Numeral -> List(U8)

Num.Numeral.digits_after_pt_count : Numeral -> U64

Num.U8

Num.U8.parser_for : _

Num.U8.encoder_for : _

Num.U8.default : () -> U8

Num.U8.highest : U8

Num.U8.lowest : U8

Num.U8.to_str : U8 -> Str

Num.U8.is_zero : U8 -> Bool

Num.U8.is_eq : U8, U8 -> Bool

Num.U8.to_hash : U8, Hasher -> Hasher

Num.U8.is_gt : U8, U8 -> Bool

Num.U8.is_gte : U8, U8 -> Bool

Num.U8.is_lt : U8, U8 -> Bool

Num.U8.is_lte : U8, U8 -> Bool

Num.U8.compare : U8, U8 -> [LT, EQ, GT]

Num.U8.is_even : U8 -> Bool

Num.U8.is_odd : U8 -> Bool

Num.U8.is_multiple_of : U8, U8 -> Bool

Num.U8.max : U8, U8 -> U8

Num.U8.min : U8, U8 -> U8

Num.U8.plus : U8, U8 -> U8

Num.U8.add_try : U8, U8 -> Try(U8, [Overflow, ..])

Num.U8.range_exclusive : U8, U8 -> Iter(U8)

Num.U8.range_inclusive : U8, U8 -> Iter(U8)

Num.U8.plus_saturated : U8, U8 -> U8

Num.U8.minus : U8, U8 -> U8

Num.U8.sub_try : U8, U8 -> Try(U8, [Overflow, ..])

Num.U8.minus_saturated : U8, U8 -> U8

Num.U8.times : U8, U8 -> U8

Num.U8.mul_try : U8, U8 -> Try(U8, [Overflow, ..])

Num.U8.times_saturated : U8, U8 -> U8

Num.U8.pow : U8, U8 -> U8

Num.U8.pow_try : U8, U8 -> Try(U8, [Overflow, ..])

Num.U8.div_by : U8, U8 -> U8

Num.U8.div_try : U8, U8 -> Try(U8, [DivByZero, ..])

Num.U8.div_ceil_by : U8, U8 -> U8

Num.U8.div_ceil_try : U8, U8 -> Try(U8, [DivByZero, ..])

Num.U8.div_floor_by : U8, U8 -> U8

Num.U8.div_trunc_by : U8, U8 -> U8

Num.U8.rem_by : U8, U8 -> U8

Num.U8.mod_by : U8, U8 -> U8

Num.U8.abs_diff : U8, U8 -> U8

Num.U8.shift_left_by : U8, U8 -> U8

Num.U8.shift_right_by : U8, U8 -> U8

Num.U8.shift_right_zf_by : U8, U8 -> U8

Num.U8.bitwise_and : U8, U8 -> U8

Num.U8.bitwise_or : U8, U8 -> U8

Num.U8.bitwise_xor : U8, U8 -> U8

Num.U8.bitwise_not : U8 -> U8

Num.U8.count_leading_zero_bits : U8 -> U8

Num.U8.count_trailing_zero_bits : U8 -> U8

Num.U8.count_one_bits : U8 -> U8

Num.U8.from_int_digits : List(U8) -> Try(U8, [OutOfRange])

Num.U8.from_numeral : Numeral -> Try(U8, [InvalidNumeral(Str)])

Num.U8.from_str : Str -> Try(U8, [BadNumStr, ..])

Num.U8.to : U8, U8 -> Iter(U8)

Num.U8.until : U8, U8 -> Iter(U8)

Num.U8.to_i8_wrap : U8 -> I8

Num.U8.to_i8_try : U8 -> Try(I8, [OutOfRange, ..])

Num.U8.to_i16 : U8 -> I16

Num.U8.to_i32 : U8 -> I32

Num.U8.to_i64 : U8 -> I64

Num.U8.to_i128 : U8 -> I128

Num.U8.to_u8 : U8 -> U8

Num.U8.to_u8_try : U8 -> Try(U8, _never_fails)

Num.U8.to_u8_wrap : U8 -> U8

Num.U8.to_u16 : U8 -> U16

Num.U8.to_u32 : U8 -> U32

Num.U8.to_u64 : U8 -> U64

Num.U8.to_u128 : U8 -> U128

Num.U8.to_f32 : U8 -> F32

Num.U8.to_f64 : U8 -> F64

Num.U8.to_dec : U8 -> Dec

Num.U8.encode : U8, fmt -> Try(encoded, err) where [fmt.encode_u8 : fmt, U8 -> Try(encoded, err)]

Num.U8.decode : src, fmt -> (Try(U8, err), src) where [fmt.decode_u8 : fmt, src -> (Try(U8, err), src)]

Num.I8

Num.I8.parser_for : _

Num.I8.encoder_for : _

Num.I8.default : () -> I8

Num.I8.highest : I8

Num.I8.lowest : I8

Num.I8.to_str : I8 -> Str

Num.I8.is_zero : I8 -> Bool

Num.I8.is_negative : I8 -> Bool

Num.I8.is_positive : I8 -> Bool

Num.I8.is_eq : I8, I8 -> Bool

Num.I8.to_hash : I8, Hasher -> Hasher

Num.I8.is_gt : I8, I8 -> Bool

Num.I8.is_gte : I8, I8 -> Bool

Num.I8.is_lt : I8, I8 -> Bool

Num.I8.is_lte : I8, I8 -> Bool

Num.I8.compare : I8, I8 -> [LT, EQ, GT]

Num.I8.is_even : I8 -> Bool

Num.I8.is_odd : I8 -> Bool

Num.I8.is_multiple_of : I8, I8 -> Bool

Num.I8.max : I8, I8 -> I8

Num.I8.min : I8, I8 -> I8

Num.I8.negate : I8 -> I8

Num.I8.abs : I8 -> I8

Num.I8.plus : I8, I8 -> I8

Num.I8.add_try : I8, I8 -> Try(I8, [Overflow, ..])

Num.I8.range_exclusive : I8, I8 -> Iter(I8)

Num.I8.range_inclusive : I8, I8 -> Iter(I8)

Num.I8.plus_saturated : I8, I8 -> I8

Num.I8.minus : I8, I8 -> I8

Num.I8.sub_try : I8, I8 -> Try(I8, [Overflow, ..])

Num.I8.minus_saturated : I8, I8 -> I8

Num.I8.times : I8, I8 -> I8

Num.I8.mul_try : I8, I8 -> Try(I8, [Overflow, ..])

Num.I8.times_saturated : I8, I8 -> I8

Num.I8.pow : I8, I8 -> I8

Num.I8.pow_try : I8, I8 -> Try(I8, [Overflow, Underflow, ..])

Num.I8.div_by : I8, I8 -> I8

Num.I8.div_try : I8, I8 -> Try(I8, [DivByZero, Overflow, ..])

Num.I8.div_ceil_by : I8, I8 -> I8

Num.I8.div_ceil_try : I8, I8 -> Try(I8, [DivByZero, Overflow, ..])

Num.I8.div_floor_by : I8, I8 -> I8

Num.I8.div_trunc_by : I8, I8 -> I8

Num.I8.rem_by : I8, I8 -> I8

Num.I8.mod_by : I8, I8 -> I8

Num.I8.abs_diff : I8, I8 -> U8

Num.I8.shift_left_by : I8, U8 -> I8

Num.I8.shift_right_by : I8, U8 -> I8

Num.I8.shift_right_zf_by : I8, U8 -> I8

Num.I8.bitwise_and : I8, I8 -> I8

Num.I8.bitwise_or : I8, I8 -> I8

Num.I8.bitwise_xor : I8, I8 -> I8

Num.I8.bitwise_not : I8 -> I8

Num.I8.count_leading_zero_bits : I8 -> U8

Num.I8.count_trailing_zero_bits : I8 -> U8

Num.I8.count_one_bits : I8 -> U8

Num.I8.to : I8, I8 -> Iter(I8)

Num.I8.until : I8, I8 -> Iter(I8)

Num.I8.from_int_digits : List(U8) -> Try(I8, [OutOfRange])

Num.I8.from_numeral : Numeral -> Try(I8, [InvalidNumeral(Str)])

Num.I8.from_str : Str -> Try(I8, [BadNumStr, ..])

Num.I8.to_i8 : I8 -> I8

Num.I8.to_i8_try : I8 -> Try(I8, _never_fails)

Num.I8.to_i8_wrap : I8 -> I8

Num.I8.to_i16 : I8 -> I16

Num.I8.to_i32 : I8 -> I32

Num.I8.to_i64 : I8 -> I64

Num.I8.to_i128 : I8 -> I128

Num.I8.to_u8_wrap : I8 -> U8

Num.I8.to_u8_try : I8 -> Try(U8, [OutOfRange, ..])

Num.I8.to_u16_wrap : I8 -> U16

Num.I8.to_u16_try : I8 -> Try(U16, [OutOfRange, ..])

Num.I8.to_u32_wrap : I8 -> U32

Num.I8.to_u32_try : I8 -> Try(U32, [OutOfRange, ..])

Num.I8.to_u64_wrap : I8 -> U64

Num.I8.to_u64_try : I8 -> Try(U64, [OutOfRange, ..])

Num.I8.to_u128_wrap : I8 -> U128

Num.I8.to_u128_try : I8 -> Try(U128, [OutOfRange, ..])

Num.I8.to_f32 : I8 -> F32

Num.I8.to_f64 : I8 -> F64

Num.I8.to_dec : I8 -> Dec

Num.I8.encode : I8, fmt -> Try(encoded, err) where [fmt.encode_i8 : fmt, I8 -> Try(encoded, err)]

Num.I8.decode : src, fmt -> (Try(I8, err), src) where [fmt.decode_i8 : fmt, src -> (Try(I8, err), src)]

Num.U16

Num.U16.parser_for : _

Num.U16.encoder_for : _

Num.U16.default : () -> U16

Num.U16.highest : U16

Num.U16.lowest : U16

Num.U16.to_str : U16 -> Str

Num.U16.is_zero : U16 -> Bool

Num.U16.is_eq : U16, U16 -> Bool

Num.U16.to_hash : U16, Hasher -> Hasher

Num.U16.is_gt : U16, U16 -> Bool

Num.U16.is_gte : U16, U16 -> Bool

Num.U16.is_lt : U16, U16 -> Bool

Num.U16.is_lte : U16, U16 -> Bool

Num.U16.compare : U16, U16 -> [LT, EQ, GT]

Num.U16.is_even : U16 -> Bool

Num.U16.is_odd : U16 -> Bool

Num.U16.is_multiple_of : U16, U16 -> Bool

Num.U16.max : U16, U16 -> U16

Num.U16.min : U16, U16 -> U16

Num.U16.plus : U16, U16 -> U16

Num.U16.add_try : U16, U16 -> Try(U16, [Overflow, ..])

Num.U16.range_exclusive : U16, U16 -> Iter(U16)

Num.U16.range_inclusive : U16, U16 -> Iter(U16)

Num.U16.plus_saturated : U16, U16 -> U16

Num.U16.minus : U16, U16 -> U16

Num.U16.sub_try : U16, U16 -> Try(U16, [Overflow, ..])

Num.U16.minus_saturated : U16, U16 -> U16

Num.U16.times : U16, U16 -> U16

Num.U16.mul_try : U16, U16 -> Try(U16, [Overflow, ..])

Num.U16.times_saturated : U16, U16 -> U16

Num.U16.pow : U16, U16 -> U16

Num.U16.pow_try : U16, U16 -> Try(U16, [Overflow, ..])

Num.U16.div_by : U16, U16 -> U16

Num.U16.div_try : U16, U16 -> Try(U16, [DivByZero, ..])

Num.U16.div_ceil_by : U16, U16 -> U16

Num.U16.div_ceil_try : U16, U16 -> Try(U16, [DivByZero, ..])

Num.U16.div_floor_by : U16, U16 -> U16

Num.U16.div_trunc_by : U16, U16 -> U16

Num.U16.rem_by : U16, U16 -> U16

Num.U16.mod_by : U16, U16 -> U16

Num.U16.abs_diff : U16, U16 -> U16

Num.U16.shift_left_by : U16, U8 -> U16

Num.U16.shift_right_by : U16, U8 -> U16

Num.U16.shift_right_zf_by : U16, U8 -> U16

Num.U16.bitwise_and : U16, U16 -> U16

Num.U16.bitwise_or : U16, U16 -> U16

Num.U16.bitwise_xor : U16, U16 -> U16

Num.U16.bitwise_not : U16 -> U16

Num.U16.count_leading_zero_bits : U16 -> U8

Num.U16.count_trailing_zero_bits : U16 -> U8

Num.U16.count_one_bits : U16 -> U8

Num.U16.to : U16, U16 -> Iter(U16)

Num.U16.until : U16, U16 -> Iter(U16)

Num.U16.from_int_digits : List(U8) -> Try(U16, [OutOfRange])

Num.U16.from_numeral : Numeral -> Try(U16, [InvalidNumeral(Str)])

Num.U16.from_str : Str -> Try(U16, [BadNumStr, ..])

Num.U16.to_i8_wrap : U16 -> I8

Num.U16.to_i8_try : U16 -> Try(I8, [OutOfRange, ..])

Num.U16.to_i16_wrap : U16 -> I16

Num.U16.to_i16_try : U16 -> Try(I16, [OutOfRange, ..])

Num.U16.to_i32 : U16 -> I32

Num.U16.to_i64 : U16 -> I64

Num.U16.to_i128 : U16 -> I128

Num.U16.to_u8_wrap : U16 -> U8

Num.U16.to_u8_try : U16 -> Try(U8, [OutOfRange, ..])

Num.U16.to_u16 : U16 -> U16

Num.U16.to_u16_try : U16 -> Try(U16, _never_fails)

Num.U16.to_u16_wrap : U16 -> U16

Num.U16.to_u32 : U16 -> U32

Num.U16.to_u64 : U16 -> U64

Num.U16.to_u128 : U16 -> U128

Num.U16.to_f32 : U16 -> F32

Num.U16.to_f64 : U16 -> F64

Num.U16.to_dec : U16 -> Dec

Num.U16.encode : U16, fmt -> Try(encoded, err) where [fmt.encode_u16 : fmt, U16 -> Try(encoded, err)]

Num.U16.decode : src, fmt -> (Try(U16, err), src) where [fmt.decode_u16 : fmt, src -> (Try(U16, err), src)]

Num.I16

Num.I16.parser_for : _

Num.I16.encoder_for : _

Num.I16.default : () -> I16

Num.I16.highest : I16

Num.I16.lowest : I16

Num.I16.to_str : I16 -> Str

Num.I16.is_zero : I16 -> Bool

Num.I16.is_negative : I16 -> Bool

Num.I16.is_positive : I16 -> Bool

Num.I16.is_eq : I16, I16 -> Bool

Num.I16.to_hash : I16, Hasher -> Hasher

Num.I16.is_gt : I16, I16 -> Bool

Num.I16.is_gte : I16, I16 -> Bool

Num.I16.is_lt : I16, I16 -> Bool

Num.I16.is_lte : I16, I16 -> Bool

Num.I16.compare : I16, I16 -> [LT, EQ, GT]

Num.I16.is_even : I16 -> Bool

Num.I16.is_odd : I16 -> Bool

Num.I16.is_multiple_of : I16, I16 -> Bool

Num.I16.max : I16, I16 -> I16

Num.I16.min : I16, I16 -> I16

Num.I16.negate : I16 -> I16

Num.I16.abs : I16 -> I16

Num.I16.plus : I16, I16 -> I16

Num.I16.add_try : I16, I16 -> Try(I16, [Overflow, ..])

Num.I16.range_exclusive : I16, I16 -> Iter(I16)

Num.I16.range_inclusive : I16, I16 -> Iter(I16)

Num.I16.plus_saturated : I16, I16 -> I16

Num.I16.minus : I16, I16 -> I16

Num.I16.sub_try : I16, I16 -> Try(I16, [Overflow, ..])

Num.I16.minus_saturated : I16, I16 -> I16

Num.I16.times : I16, I16 -> I16

Num.I16.mul_try : I16, I16 -> Try(I16, [Overflow, ..])

Num.I16.times_saturated : I16, I16 -> I16

Num.I16.pow : I16, I16 -> I16

Num.I16.pow_try : I16, I16 -> Try(I16, [Overflow, Underflow, ..])

Num.I16.div_by : I16, I16 -> I16

Num.I16.div_try : I16, I16 -> Try(I16, [DivByZero, Overflow, ..])

Num.I16.div_ceil_by : I16, I16 -> I16

Num.I16.div_ceil_try : I16, I16 -> Try(I16, [DivByZero, Overflow, ..])

Num.I16.div_floor_by : I16, I16 -> I16

Num.I16.div_trunc_by : I16, I16 -> I16

Num.I16.rem_by : I16, I16 -> I16

Num.I16.mod_by : I16, I16 -> I16

Num.I16.abs_diff : I16, I16 -> U16

Num.I16.shift_left_by : I16, U8 -> I16

Num.I16.shift_right_by : I16, U8 -> I16

Num.I16.shift_right_zf_by : I16, U8 -> I16

Num.I16.bitwise_and : I16, I16 -> I16

Num.I16.bitwise_or : I16, I16 -> I16

Num.I16.bitwise_xor : I16, I16 -> I16

Num.I16.bitwise_not : I16 -> I16

Num.I16.count_leading_zero_bits : I16 -> U8

Num.I16.count_trailing_zero_bits : I16 -> U8

Num.I16.count_one_bits : I16 -> U8

Num.I16.to : I16, I16 -> Iter(I16)

Num.I16.until : I16, I16 -> Iter(I16)

Num.I16.from_int_digits : List(U8) -> Try(I16, [OutOfRange])

Num.I16.from_numeral : Numeral -> Try(I16, [InvalidNumeral(Str)])

Num.I16.from_str : Str -> Try(I16, [BadNumStr, ..])

Num.I16.to_i8_wrap : I16 -> I8

Num.I16.to_i8_try : I16 -> Try(I8, [OutOfRange, ..])

Num.I16.to_i16 : I16 -> I16

Num.I16.to_i16_try : I16 -> Try(I16, _never_fails)

Num.I16.to_i16_wrap : I16 -> I16

Num.I16.to_i32 : I16 -> I32

Num.I16.to_i64 : I16 -> I64

Num.I16.to_i128 : I16 -> I128

Num.I16.to_u8_wrap : I16 -> U8

Num.I16.to_u8_try : I16 -> Try(U8, [OutOfRange, ..])

Num.I16.to_u16_wrap : I16 -> U16

Num.I16.to_u16_try : I16 -> Try(U16, [OutOfRange, ..])

Num.I16.to_u32_wrap : I16 -> U32

Num.I16.to_u32_try : I16 -> Try(U32, [OutOfRange, ..])

Num.I16.to_u64_wrap : I16 -> U64

Num.I16.to_u64_try : I16 -> Try(U64, [OutOfRange, ..])

Num.I16.to_u128_wrap : I16 -> U128

Num.I16.to_u128_try : I16 -> Try(U128, [OutOfRange, ..])

Num.I16.to_f32 : I16 -> F32

Num.I16.to_f64 : I16 -> F64

Num.I16.to_dec : I16 -> Dec

Num.I16.encode : I16, fmt -> Try(encoded, err) where [fmt.encode_i16 : fmt, I16 -> Try(encoded, err)]

Num.I16.decode : src, fmt -> (Try(I16, err), src) where [fmt.decode_i16 : fmt, src -> (Try(I16, err), src)]

Num.U32

Num.U32.parser_for : _

Num.U32.encoder_for : _

Num.U32.default : () -> U32

Num.U32.highest : U32

Num.U32.lowest : U32

Num.U32.to_str : U32 -> Str

Num.U32.is_zero : U32 -> Bool

Num.U32.is_eq : U32, U32 -> Bool

Num.U32.to_hash : U32, Hasher -> Hasher

Num.U32.is_gt : U32, U32 -> Bool

Num.U32.is_gte : U32, U32 -> Bool

Num.U32.is_lt : U32, U32 -> Bool

Num.U32.is_lte : U32, U32 -> Bool

Num.U32.compare : U32, U32 -> [LT, EQ, GT]

Num.U32.is_even : U32 -> Bool

Num.U32.is_odd : U32 -> Bool

Num.U32.is_multiple_of : U32, U32 -> Bool

Num.U32.max : U32, U32 -> U32

Num.U32.min : U32, U32 -> U32

Num.U32.plus : U32, U32 -> U32

Num.U32.add_try : U32, U32 -> Try(U32, [Overflow, ..])

Num.U32.range_exclusive : U32, U32 -> Iter(U32)

Num.U32.range_inclusive : U32, U32 -> Iter(U32)

Num.U32.plus_saturated : U32, U32 -> U32

Num.U32.minus : U32, U32 -> U32

Num.U32.sub_try : U32, U32 -> Try(U32, [Overflow, ..])

Num.U32.minus_saturated : U32, U32 -> U32

Num.U32.times : U32, U32 -> U32

Num.U32.mul_try : U32, U32 -> Try(U32, [Overflow, ..])

Num.U32.times_saturated : U32, U32 -> U32

Num.U32.pow : U32, U32 -> U32

Num.U32.pow_try : U32, U32 -> Try(U32, [Overflow, ..])

Num.U32.div_by : U32, U32 -> U32

Num.U32.div_try : U32, U32 -> Try(U32, [DivByZero, ..])

Num.U32.div_ceil_by : U32, U32 -> U32

Num.U32.div_ceil_try : U32, U32 -> Try(U32, [DivByZero, ..])

Num.U32.div_floor_by : U32, U32 -> U32

Num.U32.div_trunc_by : U32, U32 -> U32

Num.U32.rem_by : U32, U32 -> U32

Num.U32.mod_by : U32, U32 -> U32

Num.U32.abs_diff : U32, U32 -> U32

Num.U32.shift_left_by : U32, U8 -> U32

Num.U32.shift_right_by : U32, U8 -> U32

Num.U32.shift_right_zf_by : U32, U8 -> U32

Num.U32.bitwise_and : U32, U32 -> U32

Num.U32.bitwise_or : U32, U32 -> U32

Num.U32.bitwise_xor : U32, U32 -> U32

Num.U32.bitwise_not : U32 -> U32

Num.U32.count_leading_zero_bits : U32 -> U8

Num.U32.count_trailing_zero_bits : U32 -> U8

Num.U32.count_one_bits : U32 -> U8

Num.U32.to : U32, U32 -> Iter(U32)

Num.U32.until : U32, U32 -> Iter(U32)

Num.U32.from_int_digits : List(U8) -> Try(U32, [OutOfRange])

Num.U32.from_numeral : Numeral -> Try(U32, [InvalidNumeral(Str)])

Num.U32.from_str : Str -> Try(U32, [BadNumStr, ..])

Num.U32.to_i8_wrap : U32 -> I8

Num.U32.to_i8_try : U32 -> Try(I8, [OutOfRange, ..])

Num.U32.to_i16_wrap : U32 -> I16

Num.U32.to_i16_try : U32 -> Try(I16, [OutOfRange, ..])

Num.U32.to_i32_wrap : U32 -> I32

Num.U32.to_i32_try : U32 -> Try(I32, [OutOfRange, ..])

Num.U32.to_i64 : U32 -> I64

Num.U32.to_i128 : U32 -> I128

Num.U32.to_u8_wrap : U32 -> U8

Num.U32.to_u8_try : U32 -> Try(U8, [OutOfRange, ..])

Num.U32.to_u16_wrap : U32 -> U16

Num.U32.to_u16_try : U32 -> Try(U16, [OutOfRange, ..])

Num.U32.to_u32 : U32 -> U32

Num.U32.to_u32_try : U32 -> Try(U32, _never_fails)

Num.U32.to_u32_wrap : U32 -> U32

Num.U32.to_u64 : U32 -> U64

Num.U32.to_u128 : U32 -> U128

Num.U32.to_f32 : U32 -> F32

Num.U32.to_f64 : U32 -> F64

Num.U32.to_dec : U32 -> Dec

Num.U32.encode : U32, fmt -> Try(encoded, err) where [fmt.encode_u32 : fmt, U32 -> Try(encoded, err)]

Num.U32.decode : src, fmt -> (Try(U32, err), src) where [fmt.decode_u32 : fmt, src -> (Try(U32, err), src)]

Num.I32

Num.I32.parser_for : _

Num.I32.encoder_for : _

Num.I32.default : () -> I32

Num.I32.highest : I32

Num.I32.lowest : I32

Num.I32.to_str : I32 -> Str

Num.I32.is_zero : I32 -> Bool

Num.I32.is_negative : I32 -> Bool

Num.I32.is_positive : I32 -> Bool

Num.I32.is_eq : I32, I32 -> Bool

Num.I32.to_hash : I32, Hasher -> Hasher

Num.I32.is_gt : I32, I32 -> Bool

Num.I32.is_gte : I32, I32 -> Bool

Num.I32.is_lt : I32, I32 -> Bool

Num.I32.is_lte : I32, I32 -> Bool

Num.I32.compare : I32, I32 -> [LT, EQ, GT]

Num.I32.is_even : I32 -> Bool

Num.I32.is_odd : I32 -> Bool

Num.I32.is_multiple_of : I32, I32 -> Bool

Num.I32.max : I32, I32 -> I32

Num.I32.min : I32, I32 -> I32

Num.I32.negate : I32 -> I32

Num.I32.abs : I32 -> I32

Num.I32.plus : I32, I32 -> I32

Num.I32.add_try : I32, I32 -> Try(I32, [Overflow, ..])

Num.I32.range_exclusive : I32, I32 -> Iter(I32)

Num.I32.range_inclusive : I32, I32 -> Iter(I32)

Num.I32.plus_saturated : I32, I32 -> I32

Num.I32.minus : I32, I32 -> I32

Num.I32.sub_try : I32, I32 -> Try(I32, [Overflow, ..])

Num.I32.minus_saturated : I32, I32 -> I32

Num.I32.times : I32, I32 -> I32

Num.I32.mul_try : I32, I32 -> Try(I32, [Overflow, ..])

Num.I32.times_saturated : I32, I32 -> I32

Num.I32.pow : I32, I32 -> I32

Num.I32.pow_try : I32, I32 -> Try(I32, [Overflow, Underflow, ..])

Num.I32.div_by : I32, I32 -> I32

Num.I32.div_try : I32, I32 -> Try(I32, [DivByZero, Overflow, ..])

Num.I32.div_ceil_by : I32, I32 -> I32

Num.I32.div_ceil_try : I32, I32 -> Try(I32, [DivByZero, Overflow, ..])

Num.I32.div_floor_by : I32, I32 -> I32

Num.I32.div_trunc_by : I32, I32 -> I32

Num.I32.rem_by : I32, I32 -> I32

Num.I32.mod_by : I32, I32 -> I32

Num.I32.abs_diff : I32, I32 -> U32

Num.I32.shift_left_by : I32, U8 -> I32

Num.I32.shift_right_by : I32, U8 -> I32

Num.I32.shift_right_zf_by : I32, U8 -> I32

Num.I32.bitwise_and : I32, I32 -> I32

Num.I32.bitwise_or : I32, I32 -> I32

Num.I32.bitwise_xor : I32, I32 -> I32

Num.I32.bitwise_not : I32 -> I32

Num.I32.count_leading_zero_bits : I32 -> U8

Num.I32.count_trailing_zero_bits : I32 -> U8

Num.I32.count_one_bits : I32 -> U8

Num.I32.to : I32, I32 -> Iter(I32)

Num.I32.until : I32, I32 -> Iter(I32)

Num.I32.from_int_digits : List(U8) -> Try(I32, [OutOfRange])

Num.I32.from_numeral : Numeral -> Try(I32, [InvalidNumeral(Str)])

Num.I32.from_str : Str -> Try(I32, [BadNumStr, ..])

Num.I32.to_i8_wrap : I32 -> I8

Num.I32.to_i8_try : I32 -> Try(I8, [OutOfRange, ..])

Num.I32.to_i16_wrap : I32 -> I16

Num.I32.to_i16_try : I32 -> Try(I16, [OutOfRange, ..])

Num.I32.to_i32 : I32 -> I32

Num.I32.to_i32_try : I32 -> Try(I32, _never_fails)

Num.I32.to_i32_wrap : I32 -> I32

Num.I32.to_i64 : I32 -> I64

Num.I32.to_i128 : I32 -> I128

Num.I32.to_u8_wrap : I32 -> U8

Num.I32.to_u8_try : I32 -> Try(U8, [OutOfRange, ..])

Num.I32.to_u16_wrap : I32 -> U16

Num.I32.to_u16_try : I32 -> Try(U16, [OutOfRange, ..])

Num.I32.to_u32_wrap : I32 -> U32

Num.I32.to_u32_try : I32 -> Try(U32, [OutOfRange, ..])

Num.I32.to_u64_wrap : I32 -> U64

Num.I32.to_u64_try : I32 -> Try(U64, [OutOfRange, ..])

Num.I32.to_u128_wrap : I32 -> U128

Num.I32.to_u128_try : I32 -> Try(U128, [OutOfRange, ..])

Num.I32.to_f32 : I32 -> F32

Num.I32.to_f64 : I32 -> F64

Num.I32.to_dec : I32 -> Dec

Num.I32.encode : I32, fmt -> Try(encoded, err) where [fmt.encode_i32 : fmt, I32 -> Try(encoded, err)]

Num.I32.decode : src, fmt -> (Try(I32, err), src) where [fmt.decode_i32 : fmt, src -> (Try(I32, err), src)]

Num.U64

Num.U64.parser_for : _

Num.U64.encoder_for : _

Num.U64.default : () -> U64

Num.U64.highest : U64

Num.U64.lowest : U64

Num.U64.to_str : U64 -> Str

Num.U64.is_zero : U64 -> Bool

Num.U64.is_eq : U64, U64 -> Bool

Num.U64.to_hash : U64, Hasher -> Hasher

Num.U64.is_gt : U64, U64 -> Bool

Num.U64.is_gte : U64, U64 -> Bool

Num.U64.is_lt : U64, U64 -> Bool

Num.U64.is_lte : U64, U64 -> Bool

Num.U64.compare : U64, U64 -> [LT, EQ, GT]

Num.U64.is_even : U64 -> Bool

Num.U64.is_odd : U64 -> Bool

Num.U64.is_multiple_of : U64, U64 -> Bool

Num.U64.max : U64, U64 -> U64

Num.U64.min : U64, U64 -> U64

Num.U64.plus : U64, U64 -> U64

Num.U64.add_try : U64, U64 -> Try(U64, [Overflow, ..])

Num.U64.range_exclusive : U64, U64 -> Iter(U64)

Num.U64.range_inclusive : U64, U64 -> Iter(U64)

Num.U64.plus_saturated : U64, U64 -> U64

Num.U64.minus : U64, U64 -> U64

Num.U64.sub_try : U64, U64 -> Try(U64, [Overflow, ..])

Num.U64.minus_saturated : U64, U64 -> U64

Num.U64.times : U64, U64 -> U64

Num.U64.mul_try : U64, U64 -> Try(U64, [Overflow, ..])

Num.U64.times_saturated : U64, U64 -> U64

Num.U64.pow : U64, U64 -> U64

Num.U64.pow_try : U64, U64 -> Try(U64, [Overflow, ..])

Num.U64.div_by : U64, U64 -> U64

Num.U64.div_try : U64, U64 -> Try(U64, [DivByZero, ..])

Num.U64.div_ceil_by : U64, U64 -> U64

Num.U64.div_ceil_try : U64, U64 -> Try(U64, [DivByZero, ..])

Num.U64.div_floor_by : U64, U64 -> U64

Num.U64.div_trunc_by : U64, U64 -> U64

Num.U64.rem_by : U64, U64 -> U64

Num.U64.mod_by : U64, U64 -> U64

Num.U64.abs_diff : U64, U64 -> U64

Num.U64.shift_left_by : U64, U8 -> U64

Num.U64.shift_right_by : U64, U8 -> U64

Num.U64.shift_right_zf_by : U64, U8 -> U64

Num.U64.bitwise_and : U64, U64 -> U64

Num.U64.bitwise_or : U64, U64 -> U64

Num.U64.bitwise_xor : U64, U64 -> U64

Num.U64.bitwise_not : U64 -> U64

Num.U64.count_leading_zero_bits : U64 -> U8

Num.U64.count_trailing_zero_bits : U64 -> U8

Num.U64.count_one_bits : U64 -> U8

Num.U64.to : U64, U64 -> Iter(U64)

Num.U64.until : U64, U64 -> Iter(U64)

Num.U64.from_int_digits : List(U8) -> Try(U64, [OutOfRange])

Num.U64.from_numeral : Numeral -> Try(U64, [InvalidNumeral(Str)])

Num.U64.from_str : Str -> Try(U64, [BadNumStr, ..])

Num.U64.to_i8_wrap : U64 -> I8

Num.U64.to_i8_try : U64 -> Try(I8, [OutOfRange, ..])

Num.U64.to_i16_wrap : U64 -> I16

Num.U64.to_i16_try : U64 -> Try(I16, [OutOfRange, ..])

Num.U64.to_i32_wrap : U64 -> I32

Num.U64.to_i32_try : U64 -> Try(I32, [OutOfRange, ..])

Num.U64.to_i64_wrap : U64 -> I64

Num.U64.to_i64_try : U64 -> Try(I64, [OutOfRange, ..])

Num.U64.to_i128 : U64 -> I128

Num.U64.to_u8_wrap : U64 -> U8

Num.U64.to_u8_try : U64 -> Try(U8, [OutOfRange, ..])

Num.U64.to_u16_wrap : U64 -> U16

Num.U64.to_u16_try : U64 -> Try(U16, [OutOfRange, ..])

Num.U64.to_u32_wrap : U64 -> U32

Num.U64.to_u32_try : U64 -> Try(U32, [OutOfRange, ..])

Num.U64.to_u64 : U64 -> U64

Num.U64.to_u64_try : U64 -> Try(U64, _never_fails)

Num.U64.to_u64_wrap : U64 -> U64

Num.U64.to_u128 : U64 -> U128

Num.U64.to_f32 : U64 -> F32

Num.U64.to_f64 : U64 -> F64

Num.U64.to_dec : U64 -> Dec

Num.U64.encode : U64, fmt -> Try(encoded, err) where [fmt.encode_u64 : fmt, U64 -> Try(encoded, err)]

Num.U64.decode : src, fmt -> (Try(U64, err), src) where [fmt.decode_u64 : fmt, src -> (Try(U64, err), src)]

Num.I64

Num.I64.parser_for : _

Num.I64.encoder_for : _

Num.I64.default : () -> I64

Num.I64.highest : I64

Num.I64.lowest : I64

Num.I64.to_str : I64 -> Str

Num.I64.is_zero : I64 -> Bool

Num.I64.is_negative : I64 -> Bool

Num.I64.is_positive : I64 -> Bool

Num.I64.is_eq : I64, I64 -> Bool

Num.I64.to_hash : I64, Hasher -> Hasher

Num.I64.is_gt : I64, I64 -> Bool

Num.I64.is_gte : I64, I64 -> Bool

Num.I64.is_lt : I64, I64 -> Bool

Num.I64.is_lte : I64, I64 -> Bool

Num.I64.compare : I64, I64 -> [LT, EQ, GT]

Num.I64.is_even : I64 -> Bool

Num.I64.is_odd : I64 -> Bool

Num.I64.is_multiple_of : I64, I64 -> Bool

Num.I64.max : I64, I64 -> I64

Num.I64.min : I64, I64 -> I64

Num.I64.negate : I64 -> I64

Num.I64.abs : I64 -> I64

Num.I64.plus : I64, I64 -> I64

Num.I64.add_try : I64, I64 -> Try(I64, [Overflow, ..])

Num.I64.range_exclusive : I64, I64 -> Iter(I64)

Num.I64.range_inclusive : I64, I64 -> Iter(I64)

Num.I64.plus_saturated : I64, I64 -> I64

Num.I64.minus : I64, I64 -> I64

Num.I64.sub_try : I64, I64 -> Try(I64, [Overflow, ..])

Num.I64.minus_saturated : I64, I64 -> I64

Num.I64.times : I64, I64 -> I64

Num.I64.mul_try : I64, I64 -> Try(I64, [Overflow, ..])

Num.I64.times_saturated : I64, I64 -> I64

Num.I64.pow : I64, I64 -> I64

Num.I64.pow_try : I64, I64 -> Try(I64, [Overflow, Underflow, ..])

Num.I64.div_by : I64, I64 -> I64

Num.I64.div_try : I64, I64 -> Try(I64, [DivByZero, Overflow, ..])

Num.I64.div_ceil_by : I64, I64 -> I64

Num.I64.div_ceil_try : I64, I64 -> Try(I64, [DivByZero, Overflow, ..])

Num.I64.div_floor_by : I64, I64 -> I64

Num.I64.div_trunc_by : I64, I64 -> I64

Num.I64.rem_by : I64, I64 -> I64

Num.I64.mod_by : I64, I64 -> I64

Num.I64.abs_diff : I64, I64 -> U64

Num.I64.shift_left_by : I64, U8 -> I64

Num.I64.shift_right_by : I64, U8 -> I64

Num.I64.shift_right_zf_by : I64, U8 -> I64

Num.I64.bitwise_and : I64, I64 -> I64

Num.I64.bitwise_or : I64, I64 -> I64

Num.I64.bitwise_xor : I64, I64 -> I64

Num.I64.bitwise_not : I64 -> I64

Num.I64.count_leading_zero_bits : I64 -> U8

Num.I64.count_trailing_zero_bits : I64 -> U8

Num.I64.count_one_bits : I64 -> U8

Num.I64.to : I64, I64 -> Iter(I64)

Num.I64.until : I64, I64 -> Iter(I64)

Num.I64.from_int_digits : List(U8) -> Try(I64, [OutOfRange])

Num.I64.from_numeral : Numeral -> Try(I64, [InvalidNumeral(Str)])

Num.I64.from_str : Str -> Try(I64, [BadNumStr, ..])

Num.I64.to_i8_wrap : I64 -> I8

Num.I64.to_i8_try : I64 -> Try(I8, [OutOfRange, ..])

Num.I64.to_i16_wrap : I64 -> I16

Num.I64.to_i16_try : I64 -> Try(I16, [OutOfRange, ..])

Num.I64.to_i32_wrap : I64 -> I32

Num.I64.to_i32_try : I64 -> Try(I32, [OutOfRange, ..])

Num.I64.to_i64 : I64 -> I64

Num.I64.to_i64_try : I64 -> Try(I64, _never_fails)

Num.I64.to_i64_wrap : I64 -> I64

Num.I64.to_i128 : I64 -> I128

Num.I64.to_u8_wrap : I64 -> U8

Num.I64.to_u8_try : I64 -> Try(U8, [OutOfRange, ..])

Num.I64.to_u16_wrap : I64 -> U16

Num.I64.to_u16_try : I64 -> Try(U16, [OutOfRange, ..])

Num.I64.to_u32_wrap : I64 -> U32

Num.I64.to_u32_try : I64 -> Try(U32, [OutOfRange, ..])

Num.I64.to_u64_wrap : I64 -> U64

Num.I64.to_u64_try : I64 -> Try(U64, [OutOfRange, ..])

Num.I64.to_u128_wrap : I64 -> U128

Num.I64.to_u128_try : I64 -> Try(U128, [OutOfRange, ..])

Num.I64.to_f32 : I64 -> F32

Num.I64.to_f64 : I64 -> F64

Num.I64.to_dec : I64 -> Dec

Num.I64.encode : I64, fmt -> Try(encoded, err) where [fmt.encode_i64 : fmt, I64 -> Try(encoded, err)]

Num.I64.decode : src, fmt -> (Try(I64, err), src) where [fmt.decode_i64 : fmt, src -> (Try(I64, err), src)]

Num.U128

Num.U128.parser_for : _

Num.U128.encoder_for : _

Num.U128.default : () -> U128

Num.U128.highest : U128

Num.U128.lowest : U128

Num.U128.to_str : U128 -> Str

Num.U128.is_zero : U128 -> Bool

Num.U128.is_eq : U128, U128 -> Bool

Num.U128.to_hash : U128, Hasher -> Hasher

Num.U128.is_gt : U128, U128 -> Bool

Num.U128.is_gte : U128, U128 -> Bool

Num.U128.is_lt : U128, U128 -> Bool

Num.U128.is_lte : U128, U128 -> Bool

Num.U128.compare : U128, U128 -> [LT, EQ, GT]

Num.U128.is_even : U128 -> Bool

Num.U128.is_odd : U128 -> Bool

Num.U128.is_multiple_of : U128, U128 -> Bool

Num.U128.max : U128, U128 -> U128

Num.U128.min : U128, U128 -> U128

Num.U128.plus : U128, U128 -> U128

Num.U128.add_try : U128, U128 -> Try(U128, [Overflow, ..])

Num.U128.range_exclusive : U128, U128 -> Iter(U128)

Num.U128.range_inclusive : U128, U128 -> Iter(U128)

Num.U128.plus_saturated : U128, U128 -> U128

Num.U128.minus : U128, U128 -> U128

Num.U128.sub_try : U128, U128 -> Try(U128, [Overflow, ..])

Num.U128.minus_saturated : U128, U128 -> U128

Num.U128.times : U128, U128 -> U128

Num.U128.mul_try : U128, U128 -> Try(U128, [Overflow, ..])

Num.U128.times_saturated : U128, U128 -> U128

Num.U128.pow : U128, U128 -> U128

Num.U128.pow_try : U128, U128 -> Try(U128, [Overflow, ..])

Num.U128.div_by : U128, U128 -> U128

Num.U128.div_try : U128, U128 -> Try(U128, [DivByZero, ..])

Num.U128.div_ceil_by : U128, U128 -> U128

Num.U128.div_ceil_try : U128, U128 -> Try(U128, [DivByZero, ..])

Num.U128.div_floor_by : U128, U128 -> U128

Num.U128.div_trunc_by : U128, U128 -> U128

Num.U128.rem_by : U128, U128 -> U128

Num.U128.mod_by : U128, U128 -> U128

Num.U128.abs_diff : U128, U128 -> U128

Num.U128.shift_left_by : U128, U8 -> U128

Num.U128.shift_right_by : U128, U8 -> U128

Num.U128.shift_right_zf_by : U128, U8 -> U128

Num.U128.bitwise_and : U128, U128 -> U128

Num.U128.bitwise_or : U128, U128 -> U128

Num.U128.bitwise_xor : U128, U128 -> U128

Num.U128.bitwise_not : U128 -> U128

Num.U128.count_leading_zero_bits : U128 -> U8

Num.U128.count_trailing_zero_bits : U128 -> U8

Num.U128.count_one_bits : U128 -> U8

Num.U128.to : U128, U128 -> Iter(U128)

Num.U128.until : U128, U128 -> Iter(U128)

Num.U128.from_int_digits : List(U8) -> Try(U128, [OutOfRange])

Num.U128.from_numeral : Numeral -> Try(U128, [InvalidNumeral(Str)])

Num.U128.from_str : Str -> Try(U128, [BadNumStr, ..])

Num.U128.to_i8_wrap : U128 -> I8

Num.U128.to_i8_try : U128 -> Try(I8, [OutOfRange, ..])

Num.U128.to_i16_wrap : U128 -> I16

Num.U128.to_i16_try : U128 -> Try(I16, [OutOfRange, ..])

Num.U128.to_i32_wrap : U128 -> I32

Num.U128.to_i32_try : U128 -> Try(I32, [OutOfRange, ..])

Num.U128.to_i64_wrap : U128 -> I64

Num.U128.to_i64_try : U128 -> Try(I64, [OutOfRange, ..])

Num.U128.to_i128_wrap : U128 -> I128

Num.U128.to_i128_try : U128 -> Try(I128, [OutOfRange, ..])

Num.U128.to_u8_wrap : U128 -> U8

Num.U128.to_u8_try : U128 -> Try(U8, [OutOfRange, ..])

Num.U128.to_u16_wrap : U128 -> U16

Num.U128.to_u16_try : U128 -> Try(U16, [OutOfRange, ..])

Num.U128.to_u32_wrap : U128 -> U32

Num.U128.to_u32_try : U128 -> Try(U32, [OutOfRange, ..])

Num.U128.to_u64_wrap : U128 -> U64

Num.U128.to_u64_try : U128 -> Try(U64, [OutOfRange, ..])

Num.U128.to_u128 : U128 -> U128

Num.U128.to_u128_try : U128 -> Try(U128, _never_fails)

Num.U128.to_u128_wrap : U128 -> U128

Num.U128.to_f32 : U128 -> F32

Num.U128.to_f64 : U128 -> F64

Num.U128.to_dec_try : U128 -> Try(Dec, [OutOfRange])

Num.U128.encode : U128, fmt -> Try(encoded, err) where [fmt.encode_u128 : fmt, U128 -> Try(encoded, err)]

Num.U128.decode : src, fmt -> (Try(U128, err), src) where [fmt.decode_u128 : fmt, src -> (Try(U128, err), src)]

Num.I128

Num.I128.parser_for : _

Num.I128.encoder_for : _

Num.I128.default : () -> I128

Num.I128.highest : I128

Num.I128.lowest : I128

Num.I128.to_str : I128 -> Str

Num.I128.is_zero : I128 -> Bool

Num.I128.is_negative : I128 -> Bool

Num.I128.is_positive : I128 -> Bool

Num.I128.is_eq : I128, I128 -> Bool

Num.I128.to_hash : I128, Hasher -> Hasher

Num.I128.is_gt : I128, I128 -> Bool

Num.I128.is_gte : I128, I128 -> Bool

Num.I128.is_lt : I128, I128 -> Bool

Num.I128.is_lte : I128, I128 -> Bool

Num.I128.compare : I128, I128 -> [LT, EQ, GT]

Num.I128.is_even : I128 -> Bool

Num.I128.is_odd : I128 -> Bool

Num.I128.is_multiple_of : I128, I128 -> Bool

Num.I128.max : I128, I128 -> I128

Num.I128.min : I128, I128 -> I128

Num.I128.negate : I128 -> I128

Num.I128.abs : I128 -> I128

Num.I128.plus : I128, I128 -> I128

Num.I128.add_try : I128, I128 -> Try(I128, [Overflow, ..])

Num.I128.range_exclusive : I128, I128 -> Iter(I128)

Num.I128.range_inclusive : I128, I128 -> Iter(I128)

Num.I128.plus_saturated : I128, I128 -> I128

Num.I128.minus : I128, I128 -> I128

Num.I128.sub_try : I128, I128 -> Try(I128, [Overflow, ..])

Num.I128.minus_saturated : I128, I128 -> I128

Num.I128.times : I128, I128 -> I128

Num.I128.mul_try : I128, I128 -> Try(I128, [Overflow, ..])

Num.I128.times_saturated : I128, I128 -> I128

Num.I128.pow : I128, I128 -> I128

Num.I128.pow_try : I128, I128 -> Try(I128, [Overflow, Underflow, ..])

Num.I128.div_by : I128, I128 -> I128

Num.I128.div_try : I128, I128 -> Try(I128, [DivByZero, Overflow, ..])

Num.I128.div_ceil_by : I128, I128 -> I128

Num.I128.div_ceil_try : I128, I128 -> Try(I128, [DivByZero, Overflow, ..])

Num.I128.div_floor_by : I128, I128 -> I128

Num.I128.div_trunc_by : I128, I128 -> I128

Num.I128.rem_by : I128, I128 -> I128

Num.I128.mod_by : I128, I128 -> I128

Num.I128.abs_diff : I128, I128 -> U128

Num.I128.shift_left_by : I128, U8 -> I128

Num.I128.shift_right_by : I128, U8 -> I128

Num.I128.shift_right_zf_by : I128, U8 -> I128

Num.I128.bitwise_and : I128, I128 -> I128

Num.I128.bitwise_or : I128, I128 -> I128

Num.I128.bitwise_xor : I128, I128 -> I128

Num.I128.bitwise_not : I128 -> I128

Num.I128.count_leading_zero_bits : I128 -> U8

Num.I128.count_trailing_zero_bits : I128 -> U8

Num.I128.count_one_bits : I128 -> U8

Num.I128.to : I128, I128 -> Iter(I128)

Num.I128.until : I128, I128 -> Iter(I128)

Num.I128.from_int_digits : List(U8) -> Try(I128, [OutOfRange])

Num.I128.from_numeral : Numeral -> Try(I128, [InvalidNumeral(Str)])

Num.I128.from_str : Str -> Try(I128, [BadNumStr, ..])

Num.I128.to_i8_wrap : I128 -> I8

Num.I128.to_i8_try : I128 -> Try(I8, [OutOfRange, ..])

Num.I128.to_i16_wrap : I128 -> I16

Num.I128.to_i16_try : I128 -> Try(I16, [OutOfRange, ..])

Num.I128.to_i32_wrap : I128 -> I32

Num.I128.to_i32_try : I128 -> Try(I32, [OutOfRange, ..])

Num.I128.to_i64_wrap : I128 -> I64

Num.I128.to_i64_try : I128 -> Try(I64, [OutOfRange, ..])

Num.I128.to_i128 : I128 -> I128

Num.I128.to_i128_try : I128 -> Try(I128, _never_fails)

Num.I128.to_i128_wrap : I128 -> I128

Num.I128.to_u8_wrap : I128 -> U8

Num.I128.to_u8_try : I128 -> Try(U8, [OutOfRange, ..])

Num.I128.to_u16_wrap : I128 -> U16

Num.I128.to_u16_try : I128 -> Try(U16, [OutOfRange, ..])

Num.I128.to_u32_wrap : I128 -> U32

Num.I128.to_u32_try : I128 -> Try(U32, [OutOfRange, ..])

Num.I128.to_u64_wrap : I128 -> U64

Num.I128.to_u64_try : I128 -> Try(U64, [OutOfRange, ..])

Num.I128.to_u128_wrap : I128 -> U128

Num.I128.to_u128_try : I128 -> Try(U128, [OutOfRange, ..])

Num.I128.to_f32 : I128 -> F32

Num.I128.to_f64 : I128 -> F64

Num.I128.to_dec_try : I128 -> Try(Dec, [OutOfRange])

Num.I128.encode : I128, fmt -> Try(encoded, err) where [fmt.encode_i128 : fmt, I128 -> Try(encoded, err)]

Num.I128.decode : src, fmt -> (Try(I128, err), src) where [fmt.decode_i128 : fmt, src -> (Try(I128, err), src)]

Num.Dec

Num.Dec.parser_for : _

Num.Dec.encoder_for : _

Num.Dec.default : () -> Dec

Num.Dec.highest : Dec

Num.Dec.to_str : Dec -> Str

Num.Dec.is_zero : Dec -> Bool

Num.Dec.is_negative : Dec -> Bool

Num.Dec.is_positive : Dec -> Bool

Num.Dec.is_eq : Dec, Dec -> Bool

Num.Dec.to_hash : Dec, Hasher -> Hasher

Num.Dec.is_gt : Dec, Dec -> Bool

Num.Dec.is_gte : Dec, Dec -> Bool

Num.Dec.is_lt : Dec, Dec -> Bool

Num.Dec.is_lte : Dec, Dec -> Bool

Num.Dec.compare : Dec, Dec -> [LT, EQ, GT]

Num.Dec.max : Dec, Dec -> Dec

Num.Dec.min : Dec, Dec -> Dec

Num.Dec.negate : Dec -> Dec

Num.Dec.abs : Dec -> Dec

Num.Dec.plus : Dec, Dec -> Dec

Num.Dec.add_try : Dec, Dec -> Try(Dec, [Overflow, ..])

Num.Dec.range_exclusive : Dec, Dec -> Iter(Dec)

Num.Dec.range_inclusive : Dec, Dec -> Iter(Dec)

Num.Dec.plus_saturated : Dec, Dec -> Dec

Num.Dec.minus : Dec, Dec -> Dec

Num.Dec.sub_try : Dec, Dec -> Try(Dec, [Overflow, ..])

Num.Dec.minus_saturated : Dec, Dec -> Dec

Num.Dec.times : Dec, Dec -> Dec

Num.Dec.times_saturated : Dec, Dec -> Dec

Num.Dec.pow : Dec, Dec -> Dec

Num.Dec.sqrt : Dec -> Dec

Num.Dec.sqrt_try : Dec -> Try(Dec, [SqrtOfNegative, ..])

Num.Dec.sin : Dec -> Dec

Num.Dec.cos : Dec -> Dec

Num.Dec.tan : Dec -> Dec

Num.Dec.asin : Dec -> Dec

Num.Dec.acos : Dec -> Dec

Num.Dec.atan : Dec -> Dec

Num.Dec.div_by : Dec, Dec -> Dec

Num.Dec.div_trunc_by : Dec, Dec -> Dec

Num.Dec.div_floor_by : Dec, Dec -> Dec

Num.Dec.rem_by : Dec, Dec -> Dec

Num.Dec.abs_diff : Dec, Dec -> Dec

Num.Dec.round_to_i8 : Dec -> I8

Num.Dec.round_to_i16 : Dec -> I16

Num.Dec.round_to_i32 : Dec -> I32

Num.Dec.round_to_i64 : Dec -> I64

Num.Dec.round_to_i128 : Dec -> I128

Num.Dec.round_to_u8 : Dec -> U8

Num.Dec.round_to_u16 : Dec -> U16

Num.Dec.round_to_u32 : Dec -> U32

Num.Dec.round_to_u64 : Dec -> U64

Num.Dec.round_to_u128 : Dec -> U128

Num.Dec.floor_to_i8 : Dec -> I8

Num.Dec.floor_to_i16 : Dec -> I16

Num.Dec.floor_to_i32 : Dec -> I32

Num.Dec.floor_to_i64 : Dec -> I64

Num.Dec.floor_to_i128 : Dec -> I128

Num.Dec.floor_to_u8 : Dec -> U8

Num.Dec.floor_to_u16 : Dec -> U16

Num.Dec.floor_to_u32 : Dec -> U32

Num.Dec.floor_to_u64 : Dec -> U64

Num.Dec.floor_to_u128 : Dec -> U128

Num.Dec.ceiling_to_i8 : Dec -> I8

Num.Dec.ceiling_to_i16 : Dec -> I16

Num.Dec.ceiling_to_i32 : Dec -> I32

Num.Dec.ceiling_to_i64 : Dec -> I64

Num.Dec.ceiling_to_i128 : Dec -> I128

Num.Dec.ceiling_to_u8 : Dec -> U8

Num.Dec.ceiling_to_u16 : Dec -> U16

Num.Dec.ceiling_to_u32 : Dec -> U32

Num.Dec.ceiling_to_u64 : Dec -> U64

Num.Dec.ceiling_to_u128 : Dec -> U128

Num.Dec.from_int_digits : List(U8) -> Try(Dec, [OutOfRange])

Num.Dec.from_dec_digits : (List(U8), List(U8)) -> Try(Dec, [OutOfRange])

Num.Dec.from_numeral : Numeral -> Try(Dec, [InvalidNumeral(Str)])

Num.Dec.from_str : Str -> Try(Dec, [BadNumStr, ..])

Num.Dec.to_i8_wrap : Dec -> I8

Num.Dec.to_i8_try : Dec -> Try(I8, [OutOfRange])

Num.Dec.to_i16_wrap : Dec -> I16

Num.Dec.to_i16_try : Dec -> Try(I16, [OutOfRange])

Num.Dec.to_i32_wrap : Dec -> I32

Num.Dec.to_i32_try : Dec -> Try(I32, [OutOfRange])

Num.Dec.to_i64_wrap : Dec -> I64

Num.Dec.to_i64_try : Dec -> Try(I64, [OutOfRange])

Num.Dec.to_i128_wrap : Dec -> I128

Num.Dec.to_i128_try : Dec -> Try(I128, [OutOfRange])

Num.Dec.to_u8_wrap : Dec -> U8

Num.Dec.to_u8_try : Dec -> Try(U8, [OutOfRange])

Num.Dec.to_u16_wrap : Dec -> U16

Num.Dec.to_u16_try : Dec -> Try(U16, [OutOfRange])

Num.Dec.to_u32_wrap : Dec -> U32

Num.Dec.to_u32_try : Dec -> Try(U32, [OutOfRange])

Num.Dec.to_u64_wrap : Dec -> U64

Num.Dec.to_u64_try : Dec -> Try(U64, [OutOfRange])

Num.Dec.to_u128_wrap : Dec -> U128

Num.Dec.to_u128_try : Dec -> Try(U128, [OutOfRange])

Num.Dec.to_f32_wrap : Dec -> F32

Num.Dec.to_f32_try : Dec -> Try(F32, [OutOfRange])

Num.Dec.to_f64 : Dec -> F64

Num.Dec.to_dec : Dec -> Dec

Num.Dec.to_dec_try : Dec -> Try(Dec, _never_fails)

Num.Dec.to : Dec, Dec -> Iter(Dec)

Num.Dec.until : Dec, Dec -> Iter(Dec)

Num.Dec.encode : Dec, fmt -> Try(encoded, err) where [fmt.encode_dec : fmt, Dec -> Try(encoded, err)]

Num.Dec.decode : src, fmt -> (Try(Dec, err), src) where [fmt.decode_dec : fmt, src -> (Try(Dec, err), src)]

Num.F32

Num.F32.parser_for : _

Num.F32.encoder_for : _

Num.F32.default : () -> F32

Num.F32.highest : F32

Num.F32.lowest : F32

Num.F32.nan : F32

Num.F32.infinity : F32

Num.F32.e : F32

Num.F32.pi : F32

Num.F32.tau : F32

Num.F32.to_str : F32 -> Str

Num.F32.to_bits : F32 -> U32

Num.F32.from_bits : U32 -> F32

Num.F32.is_nan : F32 -> Bool

Num.F32.is_infinite : F32 -> Bool

Num.F32.is_finite : F32 -> Bool

Num.F32.is_zero : F32 -> Bool

Num.F32.is_float_eq : F32, F32 -> Bool

Num.F32.is_eq : _

Num.F32.to_hash : F32, Hasher -> Hasher

Num.F32.is_negative : F32 -> Bool

Num.F32.is_positive : F32 -> Bool

Num.F32.is_gt : F32, F32 -> Bool

Num.F32.is_gte : F32, F32 -> Bool

Num.F32.is_lt : F32, F32 -> Bool

Num.F32.is_lte : F32, F32 -> Bool

Num.F32.max : F32, F32 -> F32

Num.F32.min : F32, F32 -> F32

Num.F32.negate : F32 -> F32

Num.F32.abs : F32 -> F32

Num.F32.sqrt : F32 -> F32

Num.F32.sqrt_try : F32 -> Try(F32, [SqrtOfNegative, ..])

Num.F32.pow : F32, F32 -> F32

Num.F32.sin : F32 -> F32

Num.F32.cos : F32 -> F32

Num.F32.tan : F32 -> F32

Num.F32.asin : F32 -> F32

Num.F32.acos : F32 -> F32

Num.F32.atan : F32 -> F32

Num.F32.plus : F32, F32 -> F32

Num.F32.minus : F32, F32 -> F32

Num.F32.times : F32, F32 -> F32

Num.F32.div_by : F32, F32 -> F32

Num.F32.div_trunc_by : F32, F32 -> F32

Num.F32.div_floor_by : F32, F32 -> F32

Num.F32.rem_by : F32, F32 -> F32

Num.F32.abs_diff : F32, F32 -> F32

Num.F32.round_to_i8 : F32 -> I8

Num.F32.round_to_i16 : F32 -> I16

Num.F32.round_to_i32 : F32 -> I32

Num.F32.round_to_i64 : F32 -> I64

Num.F32.round_to_i128 : F32 -> I128

Num.F32.round_to_u8 : F32 -> U8

Num.F32.round_to_u16 : F32 -> U16

Num.F32.round_to_u32 : F32 -> U32

Num.F32.round_to_u64 : F32 -> U64

Num.F32.round_to_u128 : F32 -> U128

Num.F32.floor_to_i8 : F32 -> I8

Num.F32.floor_to_i16 : F32 -> I16

Num.F32.floor_to_i32 : F32 -> I32

Num.F32.floor_to_i64 : F32 -> I64

Num.F32.floor_to_i128 : F32 -> I128

Num.F32.floor_to_u8 : F32 -> U8

Num.F32.floor_to_u16 : F32 -> U16

Num.F32.floor_to_u32 : F32 -> U32

Num.F32.floor_to_u64 : F32 -> U64

Num.F32.floor_to_u128 : F32 -> U128

Num.F32.ceiling_to_i8 : F32 -> I8

Num.F32.ceiling_to_i16 : F32 -> I16

Num.F32.ceiling_to_i32 : F32 -> I32

Num.F32.ceiling_to_i64 : F32 -> I64

Num.F32.ceiling_to_i128 : F32 -> I128

Num.F32.ceiling_to_u8 : F32 -> U8

Num.F32.ceiling_to_u16 : F32 -> U16

Num.F32.ceiling_to_u32 : F32 -> U32

Num.F32.ceiling_to_u64 : F32 -> U64

Num.F32.ceiling_to_u128 : F32 -> U128

Num.F32.from_int_digits : List(U8) -> Try(F32, [OutOfRange])

Num.F32.from_dec_digits : (List(U8), List(U8)) -> Try(F32, [OutOfRange])

Num.F32.from_numeral : Numeral -> Try(F32, [InvalidNumeral(Str)])

Num.F32.range_exclusive : F32, F32 -> Iter(F32)

Num.F32.range_inclusive : F32, F32 -> Iter(F32)

Num.F32.from_str : Str -> Try(F32, [BadNumStr, ..])

Num.F32.to_i8_wrap : F32 -> I8

Num.F32.to_i8_try : F32 -> Try(I8, [OutOfRange])

Num.F32.to_i16_wrap : F32 -> I16

Num.F32.to_i16_try : F32 -> Try(I16, [OutOfRange])

Num.F32.to_i32_wrap : F32 -> I32

Num.F32.to_i32_try : F32 -> Try(I32, [OutOfRange])

Num.F32.to_i64_wrap : F32 -> I64

Num.F32.to_i64_try : F32 -> Try(I64, [OutOfRange])

Num.F32.to_i128_wrap : F32 -> I128

Num.F32.to_i128_try : F32 -> Try(I128, [OutOfRange])

Num.F32.to_u8_wrap : F32 -> U8

Num.F32.to_u8_try : F32 -> Try(U8, [OutOfRange])

Num.F32.to_u16_wrap : F32 -> U16

Num.F32.to_u16_try : F32 -> Try(U16, [OutOfRange])

Num.F32.to_u32_wrap : F32 -> U32

Num.F32.to_u32_try : F32 -> Try(U32, [OutOfRange])

Num.F32.to_u64_wrap : F32 -> U64

Num.F32.to_u64_try : F32 -> Try(U64, [OutOfRange])

Num.F32.to_u128_wrap : F32 -> U128

Num.F32.to_u128_try : F32 -> Try(U128, [OutOfRange])

Num.F32.to_f32 : F32 -> F32

Num.F32.to_f32_wrap : F32 -> F32

Num.F32.to_f32_try : F32 -> Try(F32, _never_fails)

Num.F32.to_f64 : F32 -> F64

Num.F32.encode : F32, fmt -> Try(encoded, err) where [fmt.encode_f32 : fmt, F32 -> Try(encoded, err)]

Num.F32.decode : src, fmt -> (Try(F32, err), src) where [fmt.decode_f32 : fmt, src -> (Try(F32, err), src)]

Num.F64

Num.F64.parser_for : _

Num.F64.encoder_for : _

Num.F64.default : () -> F64

Num.F64.highest : F64

Num.F64.lowest : F64

Num.F64.nan : F64

Num.F64.infinity : F64

Num.F64.e : F64

Num.F64.pi : F64

Num.F64.tau : F64

Num.F64.to_str : F64 -> Str

Num.F64.to_bits : F64 -> U64

Num.F64.from_bits : U64 -> F64

Num.F64.is_nan : F64 -> Bool

Num.F64.is_infinite : F64 -> Bool

Num.F64.is_finite : F64 -> Bool

Num.F64.is_zero : F64 -> Bool

Num.F64.is_float_eq : F64, F64 -> Bool

Num.F64.is_eq : _

Num.F64.to_hash : F64, Hasher -> Hasher

Num.F64.is_negative : F64 -> Bool

Num.F64.is_positive : F64 -> Bool

Num.F64.is_gt : F64, F64 -> Bool

Num.F64.is_gte : F64, F64 -> Bool

Num.F64.is_lt : F64, F64 -> Bool

Num.F64.is_lte : F64, F64 -> Bool

Num.F64.max : F64, F64 -> F64

Num.F64.min : F64, F64 -> F64

Num.F64.negate : F64 -> F64

Num.F64.abs : F64 -> F64

Num.F64.sqrt : F64 -> F64

Num.F64.sqrt_try : F64 -> Try(F64, [SqrtOfNegative, ..])

Num.F64.pow : F64, F64 -> F64

Num.F64.sin : F64 -> F64

Num.F64.cos : F64 -> F64

Num.F64.tan : F64 -> F64

Num.F64.asin : F64 -> F64

Num.F64.acos : F64 -> F64

Num.F64.atan : F64 -> F64

Num.F64.plus : F64, F64 -> F64

Num.F64.minus : F64, F64 -> F64

Num.F64.times : F64, F64 -> F64

Num.F64.div_by : F64, F64 -> F64

Num.F64.div_trunc_by : F64, F64 -> F64

Num.F64.div_floor_by : F64, F64 -> F64

Num.F64.rem_by : F64, F64 -> F64

Num.F64.abs_diff : F64, F64 -> F64

Num.F64.round_to_i8 : F64 -> I8

Num.F64.round_to_i16 : F64 -> I16

Num.F64.round_to_i32 : F64 -> I32

Num.F64.round_to_i64 : F64 -> I64

Num.F64.round_to_i128 : F64 -> I128

Num.F64.round_to_u8 : F64 -> U8

Num.F64.round_to_u16 : F64 -> U16

Num.F64.round_to_u32 : F64 -> U32

Num.F64.round_to_u64 : F64 -> U64

Num.F64.round_to_u128 : F64 -> U128

Num.F64.floor_to_i8 : F64 -> I8

Num.F64.floor_to_i16 : F64 -> I16

Num.F64.floor_to_i32 : F64 -> I32

Num.F64.floor_to_i64 : F64 -> I64

Num.F64.floor_to_i128 : F64 -> I128

Num.F64.floor_to_u8 : F64 -> U8

Num.F64.floor_to_u16 : F64 -> U16

Num.F64.floor_to_u32 : F64 -> U32

Num.F64.floor_to_u64 : F64 -> U64

Num.F64.floor_to_u128 : F64 -> U128

Num.F64.ceiling_to_i8 : F64 -> I8

Num.F64.ceiling_to_i16 : F64 -> I16

Num.F64.ceiling_to_i32 : F64 -> I32

Num.F64.ceiling_to_i64 : F64 -> I64

Num.F64.ceiling_to_i128 : F64 -> I128

Num.F64.ceiling_to_u8 : F64 -> U8

Num.F64.ceiling_to_u16 : F64 -> U16

Num.F64.ceiling_to_u32 : F64 -> U32

Num.F64.ceiling_to_u64 : F64 -> U64

Num.F64.ceiling_to_u128 : F64 -> U128

Num.F64.from_int_digits : List(U8) -> Try(F64, [OutOfRange])

Num.F64.from_dec_digits : (List(U8), List(U8)) -> Try(F64, [OutOfRange])

Num.F64.from_numeral : Numeral -> Try(F64, [InvalidNumeral(Str)])

Num.F64.range_exclusive : F64, F64 -> Iter(F64)

Num.F64.range_inclusive : F64, F64 -> Iter(F64)

Num.F64.from_str : Str -> Try(F64, [BadNumStr, ..])

Num.F64.to_i8_wrap : F64 -> I8

Num.F64.to_i8_try : F64 -> Try(I8, [OutOfRange])

Num.F64.to_i16_wrap : F64 -> I16

Num.F64.to_i16_try : F64 -> Try(I16, [OutOfRange])

Num.F64.to_i32_wrap : F64 -> I32

Num.F64.to_i32_try : F64 -> Try(I32, [OutOfRange])

Num.F64.to_i64_wrap : F64 -> I64

Num.F64.to_i64_try : F64 -> Try(I64, [OutOfRange])

Num.F64.to_i128_wrap : F64 -> I128

Num.F64.to_i128_try : F64 -> Try(I128, [OutOfRange])

Num.F64.to_u8_wrap : F64 -> U8

Num.F64.to_u8_try : F64 -> Try(U8, [OutOfRange])

Num.F64.to_u16_wrap : F64 -> U16

Num.F64.to_u16_try : F64 -> Try(U16, [OutOfRange])

Num.F64.to_u32_wrap : F64 -> U32

Num.F64.to_u32_try : F64 -> Try(U32, [OutOfRange])

Num.F64.to_u64_wrap : F64 -> U64

Num.F64.to_u64_try : F64 -> Try(U64, [OutOfRange])

Num.F64.to_u128_wrap : F64 -> U128

Num.F64.to_u128_try : F64 -> Try(U128, [OutOfRange])

Num.F64.to_f32_wrap : F64 -> F32

Num.F64.to_f32_try : F64 -> Try(F32, [OutOfRange])

Num.F64.to_f64 : F64 -> F64

Num.F64.to_f64_wrap : F64 -> F64

Num.F64.to_f64_try : F64 -> Try(F64, _never_fails)

Num.F64.encode : F64, fmt -> Try(encoded, err) where [fmt.encode_f64 : fmt, F64 -> Try(encoded, err)]

Num.F64.decode : src, fmt -> (Try(F64, err), src) where [fmt.decode_f64 : fmt, src -> (Try(F64, err), src)]

Set.parser_for : _

Set.encoder_for : _

Set.is_eq : Set(a), Set(a) -> Bool where [a.is_eq : a, a -> Bool]

Set.to_hash : Set(a), Hasher -> Hasher where [a.to_hash : a, Hasher -> Hasher]

Set.empty : () -> Set(_item)

Set.single : item -> Set(item)

Set.len : Set(_item) -> U64

Set.is_empty : Set(_item) -> Bool

Set.contains : Set(a), a -> Bool where [a.is_eq : a, a -> Bool]

Set.insert : Set(a), a -> Set(a) where [a.is_eq : a, a -> Bool]

Set.remove : Set(a), a -> Set(a) where [a.is_eq : a, a -> Bool]

Set.to_list : Set(a) -> List(a)

Set.from_list : List(a) -> Set(a) where [a.is_eq : a, a -> Bool]

Set.keep_if : Set(a), (a -> Bool) -> Set(a)

Set.drop_if : Set(a), (a -> Bool) -> Set(a)

Set.union : Set(a), Set(a) -> Set(a) where [a.is_eq : a, a -> Bool]

Set.intersection : Set(a), Set(a) -> Set(a) where [a.is_eq : a, a -> Bool]

Set.difference : Set(a), Set(a) -> Set(a) where [a.is_eq : a, a -> Bool]

Set.map : Set(a), (a -> b) -> Set(b) where [b.is_eq : b, b -> Bool]

Str.parser_for : _

Str.encoder_for : _

Str.is_empty : Str -> Bool

Str.concat : Str, Str -> Str

Str.contains : Str, Str -> Bool

Str.trim : Str -> Str

Str.trim_start : Str -> Str

Str.trim_end : Str -> Str

Str.caseless_ascii_equals : Str, Str -> Bool

Str.with_ascii_lowercased : Str -> Str

Str.with_ascii_uppercased : Str -> Str

Str.starts_with : Str, Str -> Bool

Str.ends_with : Str, Str -> Bool

Str.repeat : Str, U64 -> Str

Str.with_prefix : Str, Str -> Str

Str.drop_prefix : Str, Str -> Str

Str.drop_prefix_caseless_ascii : Str, Str -> Try(Str, [NotFound])

Str.drop_suffix : Str, Str -> Str

Str.find_first : Str, Str -> Try({ before : Str, after : Str }, [NotFound])

Str.count_utf8_bytes : Str -> U64

Str.with_capacity : U64 -> Str

Str.reserve : Str, U64 -> Str

Str.release_excess_capacity : Str -> Str

Str.to_utf8 : Str -> List(U8)

Str.to_str : Str -> Str

Str.from_utf8_lossy : List(U8) -> Str

Str.from_utf8 : List(U8) -> Try(Str, [BadUtf8({ problem : Utf8Problem, index : U64 }), ..])

Str.from_quote : Str -> Try(Str, [BadQuotedBytes(Str)])

Str.from_interpolation : Str, Iter((Str, Str)) -> Str

Str.split_on : Str, Str -> List(Str)

Str.join_with : List(Str), Str -> Str

Str.is_eq : Str, Str -> Bool

Str.to_hash : Str, Hasher -> Hasher

Str.inspect : _val -> Str

Str.encode : Str, fmt -> Try(encoded, err) where [fmt.encode_str : fmt, Str -> Try(encoded, err)]

Str.decode : src, fmt -> (Try(Str, err), src) where [fmt.decode_str : fmt, src -> (Try(Str, err), src)]

Str.Utf8Problem := [InvalidStartByte, UnexpectedEndOfSequence, ExpectedContinuation, OverlongEncoding, CodepointTooLarge, EncodesSurrogateHalf]

Str.Utf8Problem.is_eq : Utf8Problem, Utf8Problem -> Bool

Stream.from_iter : Iter(item) -> Stream(item)

Stream.map : Stream(a), (a => b) -> Stream(b)

Stream.map! : Stream(a), (a => b) => Stream(b)

Stream.next! : Stream(item) => [One({ item : item, rest : Stream(item) }), Skip({ rest : Stream(item) }), Done]

Stream.size_hint : Stream(item) -> [Known(U64), Unknown]

Stream.collect! : Stream(item) => List(item)

Try.parser_for : _

Try.encoder_for : _

Try.is_ok : Try(_ok, _err) -> Bool

Try.is_err : Try(_ok, _err) -> Bool

Try.from_interpolation : Str, Iter((interpolated, Str)) -> Try(ok, err) where [ok.from_interpolation : Str, Iter((interpolated, Str)) -> Try(ok, err)]

Try.ok_or : Try(ok, _err), ok -> ok

Try.err_or : Try(_ok, err), err -> err

Try.map_ok : Try(a, err), (a -> b) -> Try(b, err)

Try.map_ok! : Try(a, err), (a => b) => Try(b, err)

Try.map_err : Try(ok, a), (a -> b) -> Try(ok, b)

Try.map_err! : Try(ok, a), (a => b) => Try(ok, b)

Try.map_both : Try(a, b), (a -> c), (b -> d) -> Try(c, d)

Try.map_both! : Try(a, b), (a => c), (b => d) => Try(c, d)

Try.map2 : Try(a, err), Try(b, err), (a, b -> c) -> Try(c, err)

Try.map2! : Try(a, err), Try(b, err), (a, b => c) => Try(c, err)

Try.on_err : Try(ok, a), (a -> Try(ok, b)) -> Try(ok, b)

Try.on_err! : Try(ok, a), (a => Try(ok, b)) => Try(ok, b)

Try.catch : Try(ok, err), (err -> a), (ok -> a) -> a

Try.catch! : Try(ok, err), (err => a), (ok => a) => a

Try.collapse : Try(a, a) -> a

Try.is_eq : Try(ok, err), Try(ok, err) -> Bool where [ok.is_eq : ok, ok -> Bool, err.is_eq : err, err -> Bool]

Try.to_hash : Try(ok, err), Hasher -> Hasher where [ok.to_hash : ok, Hasher -> Hasher, err.to_hash : err, Hasher -> Hasher]