• Bool.not : Bool -> Bool
• Bool.is_eq : Bool, Bool -> Bool
• Bool.to_hash : Bool, Hasher -> Hasher
• Bool.encode : Bool, fmt -> Try(encoded, err) where { fmt.encode_bool : fmt, Bool -> Try(encoded, err) }
• Bool.decode : src, fmt -> (Try(Bool, err), src) where { fmt.decode_bool : fmt, src -> (Try(Bool, err), src) }
• Box.box : item -> Box(item)
• Box.unbox : Box(item) -> item
• Crypto.DigestBytesErr := [WrongLength({ expected : U64, actual : U64 })]
• Crypto.DigestHexErr := [WrongLength({ expected : U64, actual : U64 }), InvalidHex({ index : U64, byte : U8 })]
• Crypto.SHA256
• Crypto.SHA256.hash : List(U8) -> Digest
• Crypto.SHA256.hash_chunks : Iter(List(U8)) -> Digest
• Crypto.SHA256.Digest
• Crypto.SHA256.Digest.to_bytes : Digest -> List(U8)
• Crypto.SHA256.Digest.to_hex : Digest -> Str
• Crypto.SHA256.Digest.from_bytes : List(U8) -> Try(Digest, DigestBytesErr)
• Crypto.SHA256.Digest.from_hex : Str -> Try(Digest, DigestHexErr)
• Crypto.SHA256.Digest.is_eq : Digest, Digest -> Bool
• Crypto.SHA256.Digest.to_hash : Digest, Hasher -> Hasher
• Crypto.SHA256.Digest.to_inspect : Digest -> Str
• Crypto.SHA256.Hasher
• Crypto.SHA256.Hasher.empty : -> Hasher
• Crypto.SHA256.Hasher.write : Hasher, List(U8) -> Hasher
• Crypto.SHA256.Hasher.finish : Hasher -> Digest
• Crypto.BLAKE3
• Crypto.BLAKE3.hash : List(U8) -> Digest
• Crypto.BLAKE3.hash_chunks : Iter(List(U8)) -> Digest
• Crypto.BLAKE3.Digest
• Crypto.BLAKE3.Digest.to_bytes : Digest -> List(U8)
• Crypto.BLAKE3.Digest.to_hex : Digest -> Str
• Crypto.BLAKE3.Digest.from_bytes : List(U8) -> Try(Digest, DigestBytesErr)
• Crypto.BLAKE3.Digest.from_hex : Str -> Try(Digest, DigestHexErr)
• Crypto.BLAKE3.Digest.is_eq : Digest, Digest -> Bool
• Crypto.BLAKE3.Digest.to_hash : Digest, Hasher -> Hasher
• Crypto.BLAKE3.Digest.to_inspect : Digest -> Str
• Crypto.BLAKE3.Hasher
• Crypto.BLAKE3.Hasher.empty : -> Hasher
• Crypto.BLAKE3.Hasher.write : Hasher, List(U8) -> Hasher
• Crypto.BLAKE3.Hasher.finish : Hasher -> Digest
• Dict.is_eq : Dict(k, v), Dict(k, v) -> Bool where { k.is_eq : k, k -> Bool, k.to_hash : k, Hasher -> Hasher, v.is_eq : v, v -> Bool }
• Dict.to_hash : Dict(k, v), Hasher -> Hasher where { k.to_hash : k, Hasher -> Hasher, v.to_hash : v, Hasher -> Hasher }
• Dict.empty : -> Dict(_k, _v)
• Dict.with_capacity : U64 -> Dict(_k, _v)
• Dict.capacity : Dict(_k, _v) -> U64
• Dict.reserve : Dict(k, v), U64 -> Dict(k, v) where { k.to_hash : k, Hasher -> Hasher }
• Dict.release_excess_capacity : Dict(k, v) -> Dict(k, v) where { k.to_hash : k, Hasher -> Hasher }
• Dict.clear : Dict(k, v) -> Dict(k, v)
• Dict.single : k, v -> Dict(k, v) where { k.is_eq : k, k -> Bool, k.to_hash : k, Hasher -> Hasher }
• Dict.len : Dict(_k, _v) -> U64
• Dict.is_empty : Dict(_k, _v) -> Bool
• Dict.get : Dict(k, v), k -> Try(v, [KeyNotFound, ..]) where { k.is_eq : k, k -> Bool, k.to_hash : k, Hasher -> Hasher }
• Dict.contains : Dict(k, _v), k -> Bool where { k.is_eq : k, k -> Bool, k.to_hash : k, Hasher -> Hasher }
• Dict.insert : Dict(k, v), k, v -> Dict(k, v) where { k.is_eq : k, k -> Bool, k.to_hash : k, Hasher -> Hasher }
• Dict.remove : Dict(k, v), k -> Dict(k, v) where { k.is_eq : k, k -> Bool, k.to_hash : k, Hasher -> Hasher }
• Dict.to_list : Dict(k, v) -> List((k, v))
• Dict.from_list : List((k, v)) -> Dict(k, v) where { k.is_eq : k, k -> Bool, k.to_hash : k, Hasher -> Hasher }
• Dict.keys : Dict(k, _v) -> List(k)
• Dict.values : Dict(_k, v) -> List(v)
• Dict.fold : Dict(k, v), state, (state, k, v -> state) -> state
• Dict.keep_if : Dict(k, v), ((k, v) -> Bool) -> Dict(k, v) where { k.to_hash : k, Hasher -> Hasher }
• Dict.drop_if : Dict(k, v), ((k, v) -> Bool) -> Dict(k, v) where { k.to_hash : k, Hasher -> Hasher }
• Dict.map : Dict(k, a), (k, a -> b) -> Dict(k, b)
• Dict.join_map : Dict(a, b), (a, b -> Dict(x, y)) -> Dict(x, y) where { x.is_eq : x, x -> Bool, x.to_hash : x, Hasher -> Hasher }
• Dict.insert_all : Dict(k, v), Dict(k, v) -> Dict(k, v) where { k.is_eq : k, k -> Bool, k.to_hash : k, Hasher -> Hasher }
• Dict.keep_shared : Dict(k, v), Dict(k, v) -> Dict(k, v) where { k.is_eq : k, k -> Bool, k.to_hash : k, Hasher -> Hasher, v.is_eq : v, v -> Bool }
• Dict.remove_all : Dict(k, v), Dict(k, _w) -> Dict(k, v) where { k.is_eq : k, k -> Bool, k.to_hash : k, Hasher -> Hasher }
• Dict.update : Dict(k, v), k, (Try(v, [Missing]) -> Try(v, [Missing])) -> Dict(k, v) where { k.is_eq : k, k -> Bool, k.to_hash : k, Hasher -> Hasher }
• Dict.DictBucket : { dist_and_fingerprint : U32, entry_index : U32 }
• Dict.DictData : { entries : List((k, v)), buckets : List(DictBucket), max_entries_before_grow : U64, shifts : U8 }
• Dict.DictMetadata : { buckets : List(DictBucket), max_entries_before_grow : U64, shifts : U8 }
• Encoding.FieldName
• Encoding.FieldName.name : FieldName(_shape) -> Str
• Encoding.FieldName.FieldNames
• Encoding.FieldName.FieldNames.rename_fields : FieldNames(_shape), (Str -> Str) -> FieldNames(_shape)
• Encoding.FieldName.FieldNames.shortest_name : FieldNames(_shape) -> U64
• Encoding.FieldName.FieldNames.longest_name : FieldNames(_shape) -> U64
• Encoding.FieldName.FieldNames.iter : FieldNames(_shape) -> Iter(FieldName(_shape))
• Encoding.FieldName.FieldNames.for_size : FieldNames(_shape), U64 -> Iter(FieldName(_shape))
• Encoding.ParseTagUnionSpec
• Encoding.ParseTagUnionSpec.parse : ParseTagUnionSpec(_shape), { tag : Str, encoding : _encoding, state : _state, missing : _err } -> Try({ value : _shape, rest : _state }, _err)
• Encoding.JsonState
• Encoding.JsonEncodeState
• 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 }, Json)
• Encoding.JsonEncoding.parse_bool : JsonEncoding, JsonState -> Try({ value : Bool, rest : JsonState }, Json)
• Encoding.JsonEncoding.parse_u8 : JsonEncoding, JsonState -> Try({ value : U8, rest : JsonState }, Json)
• Encoding.JsonEncoding.parse_i8 : JsonEncoding, JsonState -> Try({ value : I8, rest : JsonState }, Json)
• Encoding.JsonEncoding.parse_u16 : JsonEncoding, JsonState -> Try({ value : U16, rest : JsonState }, Json)
• Encoding.JsonEncoding.parse_i16 : JsonEncoding, JsonState -> Try({ value : I16, rest : JsonState }, Json)
• Encoding.JsonEncoding.parse_u32 : JsonEncoding, JsonState -> Try({ value : U32, rest : JsonState }, Json)
• Encoding.JsonEncoding.parse_i32 : JsonEncoding, JsonState -> Try({ value : I32, rest : JsonState }, Json)
• Encoding.JsonEncoding.parse_u64 : JsonEncoding, JsonState -> Try({ value : U64, rest : JsonState }, Json)
• Encoding.JsonEncoding.parse_i64 : JsonEncoding, JsonState -> Try({ value : I64, rest : JsonState }, Json)
• Encoding.JsonEncoding.parse_u128 : JsonEncoding, JsonState -> Try({ value : U128, rest : JsonState }, Json)
• Encoding.JsonEncoding.parse_i128 : JsonEncoding, JsonState -> Try({ value : I128, rest : JsonState }, Json)
• Encoding.JsonEncoding.parse_dec : JsonEncoding, JsonState -> Try({ value : Dec, rest : JsonState }, Json)
• Encoding.JsonEncoding.parse_f32 : JsonEncoding, JsonState -> Try({ value : F32, rest : JsonState }, Json)
• Encoding.JsonEncoding.parse_f64 : JsonEncoding, JsonState -> Try({ value : F64, rest : JsonState }, Json)
• Encoding.JsonEncoding.parse_null : JsonEncoding, JsonState -> Try(JsonState, Json)
• Encoding.JsonEncoding.parse_array_start : JsonEncoding, JsonState -> Try(JsonState, Json)
• Encoding.JsonEncoding.parse_array_next : JsonEncoding, JsonState -> Try([Element(JsonState), Done(JsonState)], Json)
• Encoding.JsonEncoding.parse_array_after_element : JsonEncoding, JsonState -> Try([Continue(JsonState), Done(JsonState)], Json)
• 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 })], Json)
• Encoding.JsonEncoding.parse_object_next : JsonEncoding, JsonState -> Try([Entry({ key : Str, rest : JsonState }), Done({ rest : JsonState })], Json)
• Encoding.JsonEncoding.skip_record_field : JsonEncoding, JsonState -> Try(JsonState, Json)
• Encoding.JsonEncoding.missing_record_field : JsonEncoding, Str, JsonState -> Json
• Encoding.JsonEncoding.missing_optional_field : JsonEncoding, Str, JsonState -> [Missing, ..]
• Encoding.JsonEncoding.invalid_value : JsonEncoding, JsonState -> Json
• Encoding.JsonEncoding.parse_tag_union : JsonEncoding, ParseTagUnionSpec(a), JsonState -> Try({ value : a, rest : JsonState }, Json)
• Encoding.JsonEncoding.begin_record : JsonEncodeState -> Try(JsonEncodeState, _never_fails)
• Encoding.JsonEncoding.encode_record_field : Str, JsonEncodeState -> Try(JsonEncodeState, _never_fails)
• Encoding.JsonEncoding.end_record : JsonEncodeState -> Try(JsonEncodeState, _never_fails)
• Encoding.JsonEncoding.begin_array : JsonEncodeState -> Try(JsonEncodeState, _never_fails)
• Encoding.JsonEncoding.encode_array_element : JsonEncodeState -> Try(JsonEncodeState, _never_fails)
• Encoding.JsonEncoding.end_array : JsonEncodeState -> Try(JsonEncodeState, _never_fails)
• 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, Json)
• Encoding.JsonEncoding.parse_key_bool : JsonEncoding, Str -> Try(Bool, Json)
• Encoding.JsonEncoding.parse_key_u8 : JsonEncoding, Str -> Try(U8, Json)
• Encoding.JsonEncoding.parse_key_i8 : JsonEncoding, Str -> Try(I8, Json)
• Encoding.JsonEncoding.parse_key_u16 : JsonEncoding, Str -> Try(U16, Json)
• Encoding.JsonEncoding.parse_key_i16 : JsonEncoding, Str -> Try(I16, Json)
• Encoding.JsonEncoding.parse_key_u32 : JsonEncoding, Str -> Try(U32, Json)
• Encoding.JsonEncoding.parse_key_i32 : JsonEncoding, Str -> Try(I32, Json)
• Encoding.JsonEncoding.parse_key_u64 : JsonEncoding, Str -> Try(U64, Json)
• Encoding.JsonEncoding.parse_key_i64 : JsonEncoding, Str -> Try(I64, Json)
• Encoding.JsonEncoding.parse_key_u128 : JsonEncoding, Str -> Try(U128, Json)
• Encoding.JsonEncoding.parse_key_i128 : JsonEncoding, Str -> Try(I128, Json)
• Encoding.JsonEncoding.parse_key_dec : JsonEncoding, Str -> Try(Dec, Json)
• Encoding.JsonEncoding.parse_key_f32 : JsonEncoding, Str -> Try(F32, Json)
• Encoding.JsonEncoding.parse_key_f64 : JsonEncoding, Str -> Try(F64, Json)
• 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 }, HttpHeader)
• Encoding.HttpHeaderEncoding.parse_u64 : HttpHeaderEncoding, HttpHeaderState -> Try({ value : U64, rest : HttpHeaderState }, HttpHeader)
• 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 })], HttpHeader)
• Encoding.HttpHeaderEncoding.skip_record_field : HttpHeaderEncoding, HttpHeaderState -> Try(HttpHeaderState, HttpHeader)
• Encoding.HttpHeaderEncoding.missing_record_field : HttpHeaderEncoding, Str, HttpHeaderState -> HttpHeader
• Encoding.HttpHeaderEncoding.missing_optional_field : HttpHeaderEncoding, Str, HttpHeaderState -> [Missing]
• Encoding.Json := [MissingRequired, InvalidJson]
• Encoding.Json.parse_str : JsonEncoding, JsonState -> Try({ value : Str, rest : JsonState }, Json)
• Encoding.Json.parse_bool : JsonEncoding, JsonState -> Try({ value : Bool, rest : JsonState }, Json)
• Encoding.Json.parse_u8 : JsonEncoding, JsonState -> Try({ value : U8, rest : JsonState }, Json)
• Encoding.Json.parse_i8 : JsonEncoding, JsonState -> Try({ value : I8, rest : JsonState }, Json)
• Encoding.Json.parse_u16 : JsonEncoding, JsonState -> Try({ value : U16, rest : JsonState }, Json)
• Encoding.Json.parse_i16 : JsonEncoding, JsonState -> Try({ value : I16, rest : JsonState }, Json)
• Encoding.Json.parse_u32 : JsonEncoding, JsonState -> Try({ value : U32, rest : JsonState }, Json)
• Encoding.Json.parse_i32 : JsonEncoding, JsonState -> Try({ value : I32, rest : JsonState }, Json)
• Encoding.Json.parse_u64 : JsonEncoding, JsonState -> Try({ value : U64, rest : JsonState }, Json)
• Encoding.Json.parse_i64 : JsonEncoding, JsonState -> Try({ value : I64, rest : JsonState }, Json)
• Encoding.Json.parse_u128 : JsonEncoding, JsonState -> Try({ value : U128, rest : JsonState }, Json)
• Encoding.Json.parse_i128 : JsonEncoding, JsonState -> Try({ value : I128, rest : JsonState }, Json)
• Encoding.Json.parse_dec : JsonEncoding, JsonState -> Try({ value : Dec, rest : JsonState }, Json)
• Encoding.Json.parse_f32 : JsonEncoding, JsonState -> Try({ value : F32, rest : JsonState }, Json)
• Encoding.Json.parse_f64 : JsonEncoding, JsonState -> Try({ value : F64, rest : JsonState }, Json)
• Encoding.Json.parse_null : JsonEncoding, JsonState -> Try(JsonState, Json)
• Encoding.Json.parse_array_start : JsonEncoding, JsonState -> Try(JsonState, Json)
• Encoding.Json.parse_array_next : JsonEncoding, JsonState -> Try([Element(JsonState), Done(JsonState)], Json)
• Encoding.Json.parse_array_after_element : JsonEncoding, JsonState -> Try([Continue(JsonState), Done(JsonState)], Json)
• 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.begin_array : JsonEncoding, JsonEncodeState -> Try(JsonEncodeState, _never_fails)
• Encoding.Json.encode_array_element : JsonEncoding, JsonEncodeState -> Try(JsonEncodeState, _never_fails)
• Encoding.Json.end_array : JsonEncoding, JsonEncodeState -> Try(JsonEncodeState, _never_fails)
• Encoding.Json.encode : a -> Try(Str, err) where { a.encode_to : a, JsonEncoding -> JsonEncodeState -> Try(JsonEncodeState, err) }
• Encoding.Json.parse : Str -> Try(a, Json) where { a.parser_for : JsonEncoding -> JsonState -> Try({ value : a, rest : JsonState }, Json) }
• Encoding.Json.parse_trailing_commas : Str -> Try(a, Json) where { a.parser_for : JsonEncoding -> JsonState -> Try({ value : a, rest : JsonState }, Json) }
• Encoding.Json.parser_camel : -> Str -> Try(a, Json) where { a.parser_for : JsonEncoding -> JsonState -> Try({ value : a, rest : JsonState }, Json) }
• Encoding.Json.invalid_json : Json
• Encoding.Json.parse_json_bool : Str -> Try({ value : Bool, rest : JsonState }, Json)
• Encoding.Json.parse_json_null : Str -> Try(JsonState, Json)
• Encoding.Json.parse_array_start_from_json : Str -> Try(JsonState, Json)
• Encoding.Json.parse_array_next_from_json : Str -> Try([Element(JsonState), Done(JsonState)], Json)
• Encoding.Json.parse_array_after_element_from_json : JsonEncoding, Str -> Try([Continue(JsonState), Done(JsonState)], Json)
• Encoding.Json.parse_json_unsigned_int : Str, (Str -> Try(a, [BadNumStr])) -> Try({ value : a, rest : JsonState }, Json)
• Encoding.Json.parse_json_signed_int : Str, (Str -> Try(a, [BadNumStr])) -> Try({ value : a, rest : JsonState }, Json)
• Encoding.Json.parse_json_number : Str, (Str -> Try(a, [BadNumStr])) -> Try({ value : a, rest : JsonState }, Json)
• 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, Json)
• Encoding.Json.parse_json_key_signed_int : Str, (Str -> Try(a, [BadNumStr])) -> Try(a, Json)
• Encoding.Json.parse_json_key_number : Str, (Str -> Try(a, [BadNumStr])) -> Try(a, Json)
• 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.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 })], Json)
• Encoding.Json.parse_record_field_after_object_start : a, Str -> Try([Done({ rest : JsonState }), TryField({ name : Str, rest : JsonState })], Json)
• Encoding.Json.parse_record_field_after_value : JsonEncoding, Str -> Try([Done({ rest : JsonState }), ..[TryField({ name : Str, rest : JsonState })]], Json)
• Encoding.Json.parse_record_field_start : a, Str -> Try([TryField({ name : Str, rest : JsonState })], Json)
• Encoding.Json.snake_to_camel : Str -> Str
• Encoding.Json.upper_first_ascii : Str -> Str
• Encoding.Json.skip_json_value : JsonEncoding, JsonState -> Try(JsonState, Json)
• Encoding.Json.skip_json_object : JsonEncoding, Str -> Try(JsonState, Json)
• Encoding.Json.skip_json_array : JsonEncoding, Str -> Try(JsonState, Json)
• Encoding.Json.parse_tag_union_from_json : Str, JsonEncoding, ParseTagUnionSpec(a) -> Try({ value : a, rest : JsonState }, Json)
• Encoding.Json.finish_tag_payload : JsonEncoding, a, Str -> Try({ value : a, rest : JsonState }, Json)
• Encoding.Json.consume_empty_json_object : Str -> Try({ after : Str }, Json)
• 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 }, Json)
• Encoding.Json.split_json_scalar_tail : Str -> Try({ value : Str, after : Str }, Json)
• Encoding.HttpHeader := [MissingRequired, BadHeader]
• Encoding.HttpHeader.parser_for : -> Str -> Try(output, HttpHeader) where { output.parser_for : HttpHeaderEncoding -> HttpHeaderState -> Try({ value : output, rest : HttpHeaderState }, HttpHeader) }
• Encoding.HttpHeader.parse : Str -> Try(output, HttpHeader) where { output.parser_for : HttpHeaderEncoding -> HttpHeaderState -> Try({ value : output, rest : HttpHeaderState }, HttpHeader) }
• Encoding.HttpHeader.parse_str : HttpHeaderEncoding, HttpHeaderState -> Try({ value : Str, rest : HttpHeaderState }, HttpHeader)
• Encoding.HttpHeader.parse_u64 : HttpHeaderEncoding, HttpHeaderState -> Try({ value : U64, rest : HttpHeaderState }, HttpHeader)
• 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 })], HttpHeader)
• Encoding.HttpHeader.take_header_value : Str -> Try({ value : Str, after : Str }, HttpHeader)
• 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.exclusive_range : num, num -> 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)]), num.steps_between : num, num -> [Known(U64), Unknown] }
• Iter.inclusive_range : num, num -> 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)]), num.steps_between : num, num -> [Known(U64), Unknown] }
• 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.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.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.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.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.encode : List(item), fmt -> Try(encoded, err) where { fmt.encode_list : fmt, List(item), (item, fmt -> Try(encoded, err)) -> Try(encoded, err), item.encode : item, fmt -> Try(encoded, 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.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.steps_between : U8, U8 -> [Known(U64), Unknown]
• 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_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_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.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.steps_between : I8, I8 -> [Known(U64), Unknown]
• 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_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_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.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.steps_between : U16, U16 -> [Known(U64), Unknown]
• 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_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_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.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.steps_between : I16, I16 -> [Known(U64), Unknown]
• 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_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_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.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.steps_between : U32, U32 -> [Known(U64), Unknown]
• 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_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_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.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.steps_between : I32, I32 -> [Known(U64), Unknown]
• 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_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_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.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.steps_between : U64, U64 -> [Known(U64), Unknown]
• 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_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_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.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.steps_between : I64, I64 -> [Known(U64), Unknown]
• 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_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_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.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.steps_between : U128, U128 -> [Known(U64), Unknown]
• 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_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_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.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.steps_between : I128, I128 -> [Known(U64), Unknown]
• 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_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_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.default : -> Dec
• Num.Dec.highest : Dec
• Num.Dec.lowest : Dec
• Num.Dec.e : Dec
• Num.Dec.pi : Dec
• Num.Dec.tau : 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.steps_between : Dec, Dec -> [Known(U64), Unknown]
• 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.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 -> 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.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.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.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.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_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.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.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.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.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.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.is_eq : Set(a), Set(a) -> Bool where { a.is_eq : a, a -> Bool }
• 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.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.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.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.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 }

Encoding

FieldName

name : FieldName(_shape) -> Str

FieldNames

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

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

JsonState

JsonEncodeState

JsonEncoding

rename_field : JsonEncoding, Str -> Str

allows_trailing_commas : JsonEncoding -> Bool

parse_str : JsonEncoding, JsonState -> Try({ value : Str, rest : JsonState }, Json)

parse_bool : JsonEncoding, JsonState -> Try({ value : Bool, rest : JsonState }, Json)

parse_u8 : JsonEncoding, JsonState -> Try({ value : U8, rest : JsonState }, Json)

parse_i8 : JsonEncoding, JsonState -> Try({ value : I8, rest : JsonState }, Json)

parse_u16 : JsonEncoding, JsonState -> Try({ value : U16, rest : JsonState }, Json)

parse_i16 : JsonEncoding, JsonState -> Try({ value : I16, rest : JsonState }, Json)

parse_u32 : JsonEncoding, JsonState -> Try({ value : U32, rest : JsonState }, Json)

parse_i32 : JsonEncoding, JsonState -> Try({ value : I32, rest : JsonState }, Json)

parse_u64 : JsonEncoding, JsonState -> Try({ value : U64, rest : JsonState }, Json)

parse_i64 : JsonEncoding, JsonState -> Try({ value : I64, rest : JsonState }, Json)

parse_u128 : JsonEncoding, JsonState -> Try({ value : U128, rest : JsonState }, Json)

parse_i128 : JsonEncoding, JsonState -> Try({ value : I128, rest : JsonState }, Json)

parse_dec : JsonEncoding, JsonState -> Try({ value : Dec, rest : JsonState }, Json)

parse_f32 : JsonEncoding, JsonState -> Try({ value : F32, rest : JsonState }, Json)

parse_f64 : JsonEncoding, JsonState -> Try({ value : F64, rest : JsonState }, Json)

parse_null : JsonEncoding, JsonState -> Try(JsonState, Json)

parse_array_start : JsonEncoding, JsonState -> Try(JsonState, Json)

parse_array_next : JsonEncoding, JsonState -> Try([Element(JsonState), Done(JsonState)], Json)

parse_array_after_element : JsonEncoding, JsonState -> Try([Continue(JsonState), Done(JsonState)], Json)

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 })], Json)

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

skip_record_field : JsonEncoding, JsonState -> Try(JsonState, Json)

missing_record_field : JsonEncoding, Str, JsonState -> Json

missing_optional_field : JsonEncoding, Str, JsonState -> [Missing, ..]

invalid_value : JsonEncoding, JsonState -> Json

parse_tag_union : JsonEncoding, ParseTagUnionSpec(a), JsonState -> Try({ value : a, rest : JsonState }, Json)

begin_record : JsonEncodeState -> Try(JsonEncodeState, _never_fails)

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

end_record : JsonEncodeState -> Try(JsonEncodeState, _never_fails)

begin_array : JsonEncodeState -> Try(JsonEncodeState, _never_fails)

encode_array_element : JsonEncodeState -> Try(JsonEncodeState, _never_fails)

end_array : JsonEncodeState -> Try(JsonEncodeState, _never_fails)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

encode_null : JsonEncodeState -> Try(JsonEncodeState, _never_fails)

parse_key_str : JsonEncoding, Str -> Try(Str, Json)

parse_key_bool : JsonEncoding, Str -> Try(Bool, Json)

parse_key_u8 : JsonEncoding, Str -> Try(U8, Json)

parse_key_i8 : JsonEncoding, Str -> Try(I8, Json)

parse_key_u16 : JsonEncoding, Str -> Try(U16, Json)

parse_key_i16 : JsonEncoding, Str -> Try(I16, Json)

parse_key_u32 : JsonEncoding, Str -> Try(U32, Json)

parse_key_i32 : JsonEncoding, Str -> Try(I32, Json)

parse_key_u64 : JsonEncoding, Str -> Try(U64, Json)

parse_key_i64 : JsonEncoding, Str -> Try(I64, Json)

parse_key_u128 : JsonEncoding, Str -> Try(U128, Json)

parse_key_i128 : JsonEncoding, Str -> Try(I128, Json)

parse_key_dec : JsonEncoding, Str -> Try(Dec, Json)

parse_key_f32 : JsonEncoding, Str -> Try(F32, Json)

parse_key_f64 : JsonEncoding, Str -> Try(F64, Json)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

HttpHeaderState

HttpHeaderEncoding

rename_field : HttpHeaderEncoding, Str -> Str

parse_str : HttpHeaderEncoding, HttpHeaderState -> Try({ value : Str, rest : HttpHeaderState }, HttpHeader)

parse_u64 : HttpHeaderEncoding, HttpHeaderState -> Try({ value : U64, rest : HttpHeaderState }, HttpHeader)

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 })], HttpHeader)

skip_record_field : HttpHeaderEncoding, HttpHeaderState -> Try(HttpHeaderState, HttpHeader)

missing_record_field : HttpHeaderEncoding, Str, HttpHeaderState -> HttpHeader

missing_optional_field : HttpHeaderEncoding, Str, HttpHeaderState -> [Missing]

Json

:= [MissingRequired, InvalidJson]

parse_str : JsonEncoding, JsonState -> Try({ value : Str, rest : JsonState }, Json)

parse_bool : JsonEncoding, JsonState -> Try({ value : Bool, rest : JsonState }, Json)

parse_u8 : JsonEncoding, JsonState -> Try({ value : U8, rest : JsonState }, Json)

parse_i8 : JsonEncoding, JsonState -> Try({ value : I8, rest : JsonState }, Json)

parse_u16 : JsonEncoding, JsonState -> Try({ value : U16, rest : JsonState }, Json)

parse_i16 : JsonEncoding, JsonState -> Try({ value : I16, rest : JsonState }, Json)

parse_u32 : JsonEncoding, JsonState -> Try({ value : U32, rest : JsonState }, Json)

parse_i32 : JsonEncoding, JsonState -> Try({ value : I32, rest : JsonState }, Json)

parse_u64 : JsonEncoding, JsonState -> Try({ value : U64, rest : JsonState }, Json)

parse_i64 : JsonEncoding, JsonState -> Try({ value : I64, rest : JsonState }, Json)

parse_u128 : JsonEncoding, JsonState -> Try({ value : U128, rest : JsonState }, Json)

parse_i128 : JsonEncoding, JsonState -> Try({ value : I128, rest : JsonState }, Json)

parse_dec : JsonEncoding, JsonState -> Try({ value : Dec, rest : JsonState }, Json)

parse_f32 : JsonEncoding, JsonState -> Try({ value : F32, rest : JsonState }, Json)

parse_f64 : JsonEncoding, JsonState -> Try({ value : F64, rest : JsonState }, Json)

parse_null : JsonEncoding, JsonState -> Try(JsonState, Json)

parse_array_start : JsonEncoding, JsonState -> Try(JsonState, Json)

parse_array_next : JsonEncoding, JsonState -> Try([Element(JsonState), Done(JsonState)], Json)

parse_array_after_element : JsonEncoding, JsonState -> Try([Continue(JsonState), Done(JsonState)], Json)

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)

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

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

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

encode : a -> Try(Str, err) where { a.encode_to : a, JsonEncoding -> JsonEncodeState -> Try(JsonEncodeState, err) }

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

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

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

invalid_json : Json

parse_json_bool : Str -> Try({ value : Bool, rest : JsonState }, Json)

parse_json_null : Str -> Try(JsonState, Json)

parse_array_start_from_json : Str -> Try(JsonState, Json)

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

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

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

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

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

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, digits_len : U64, point : I64 }

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

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

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

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

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

container_needs_comma : JsonEncodeState -> Bool

mark_container_has_item : List(Bool) -> List(Bool)

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_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 })], Json)

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

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

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

snake_to_camel : Str -> Str

upper_first_ascii : Str -> Str

skip_json_value : JsonEncoding, JsonState -> Try(JsonState, Json)

skip_json_object : JsonEncoding, Str -> Try(JsonState, Json)

skip_json_array : JsonEncoding, Str -> Try(JsonState, Json)

parse_tag_union_from_json : Str, JsonEncoding, ParseTagUnionSpec(a) -> Try({ value : a, rest : JsonState }, Json)

finish_tag_payload : JsonEncoding, a, Str -> Try({ value : a, rest : JsonState }, Json)

consume_empty_json_object : Str -> Try({ after : Str }, Json)

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 }, Json)

split_json_scalar_tail : Str -> Try({ value : Str, after : Str }, Json)

HttpHeader

:= [MissingRequired, BadHeader]

parser_for : -> Str -> Try(output, HttpHeader) where { output.parser_for : HttpHeaderEncoding -> HttpHeaderState -> Try({ value : output, rest : HttpHeaderState }, HttpHeader) }

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

parse_str : HttpHeaderEncoding, HttpHeaderState -> Try({ value : Str, rest : HttpHeaderState }, HttpHeader)

parse_u64 : HttpHeaderEncoding, HttpHeaderState -> Try({ value : U64, rest : HttpHeaderState }, 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 })], HttpHeader)

take_header_value : Str -> Try({ value : Str, after : Str }, HttpHeader)

underscores_to_dashes : Str -> Str